Physical Quantities  v1.0.0
C++ library of physical quantities, physical models, and units of measure for scientific computing. https://github.com/acodcha/phq
MemoryRate.hpp
Go to the documentation of this file.
1 // Copyright © 2020-2024 Alexandre Coderre-Chabot
2 //
3 // This file is part of Physical Quantities (PhQ), a C++ library of physical quantities, physical
4 // models, and units of measure for scientific computing.
5 //
6 // Physical Quantities is hosted at:
7 // https://github.com/acodcha/phq
8 //
9 // Physical Quantities is licensed under the MIT License:
10 // https://mit-license.org
11 //
12 // Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
13 // associated documentation files (the "Software"), to deal in the Software without restriction,
14 // including without limitation the rights to use, copy, modify, merge, publish, distribute,
15 // sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
16 // furnished to do so, subject to the following conditions:
17 // - The above copyright notice and this permission notice shall be included in all copies or
18 // substantial portions of the Software.
19 // - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
20 // BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
21 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
22 // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM
23 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 
25 #ifndef PHQ_UNIT_MEMORY_RATE_HPP
26 #define PHQ_UNIT_MEMORY_RATE_HPP
27 
28 #include <cstddef>
29 #include <cstdint>
30 #include <functional>
31 #include <map>
32 #include <ostream>
33 #include <string_view>
34 #include <unordered_map>
35 
36 #include "../Base.hpp"
37 #include "../Dimension/ElectricCurrent.hpp"
38 #include "../Dimension/Length.hpp"
39 #include "../Dimension/LuminousIntensity.hpp"
40 #include "../Dimension/Mass.hpp"
41 #include "../Dimension/SubstanceAmount.hpp"
42 #include "../Dimension/Temperature.hpp"
43 #include "../Dimension/Time.hpp"
44 #include "../Dimensions.hpp"
45 #include "../Unit.hpp"
46 #include "../UnitSystem.hpp"
47 
48 namespace PhQ {
49 
50 namespace Unit {
51 
52 /// \brief Computer memory rate unit. Can represent the time rate of change of memory or a memory
53 /// transfer speed.
54 enum class MemoryRate : int8_t {
55  /// \brief Bit per second (b/s) memory rate unit.
56  BitPerSecond,
57 
58  /// \brief Byte per second (B/s) memory rate unit.
59  BytePerSecond,
60 
61  /// \brief Kilobit per second (kb/s) memory rate unit.
62  KilobitPerSecond,
63 
64  /// \brief Kibibit per second (kib/s) memory rate unit.
65  KibibitPerSecond,
66 
67  /// \brief Kilobyte per second (kB/s) memory rate unit.
68  KilobytePerSecond,
69 
70  /// \brief Kibibyte per second (kiB/s) memory rate unit.
71  KibibytePerSecond,
72 
73  /// \brief Megabit per second (Mb/s) memory rate unit.
74  MegabitPerSecond,
75 
76  /// \brief Mebibit per second (Mib/s) memory rate unit.
77  MebibitPerSecond,
78 
79  /// \brief Megabyte per second (MB/s) memory rate unit.
80  MegabytePerSecond,
81 
82  /// \brief Mebibyte per second (MiB/s) memory rate unit.
83  MebibytePerSecond,
84 
85  /// \brief Gigabit per second (Gb/s) memory rate unit.
86  GigabitPerSecond,
87 
88  /// \brief Gibibit per second (Gib/s) memory rate unit.
89  GibibitPerSecond,
90 
91  /// \brief Gigabyte per second (GB/s) memory rate unit.
92  GigabytePerSecond,
93 
94  /// \brief Gibibyte per second (GiB/s) memory rate unit.
95  GibibytePerSecond,
96 
97  /// \brief Terabit per second (Tb/s) memory rate unit.
98  TerabitPerSecond,
99 
100  /// \brief Tebibit per second (Tib/s) memory rate unit.
101  TebibitPerSecond,
102 
103  /// \brief Terabyte per second (TB/s) memory rate unit.
104  TerabytePerSecond,
105 
106  /// \brief Tebibyte per second (TiB/s) memory rate unit.
107  TebibytePerSecond,
108 
109  /// \brief Petabit per second (Pb/s) memory rate unit.
110  PetabitPerSecond,
111 
112  /// \brief Pebibit per second (Pib/s) memory rate unit.
113  PebibitPerSecond,
114 
115  /// \brief Petabyte per second (PB/s) memory rate unit.
116  PetabytePerSecond,
117 
118  /// \brief Pebibyte per second (PiB/s) memory rate unit.
119  PebibytePerSecond,
120 
121  /// \brief Bit per minute (b/min) memory rate unit.
122  BitPerMinute,
123 
124  /// \brief Byte per minute (B/min) memory rate unit.
125  BytePerMinute,
126 
127  /// \brief Kilobit per minute (kb/min) memory rate unit.
128  KilobitPerMinute,
129 
130  /// \brief Kibibit per minute (kib/min) memory rate unit.
131  KibibitPerMinute,
132 
133  /// \brief Kilobyte per minute (kB/min) memory rate unit.
134  KilobytePerMinute,
135 
136  /// \brief Kibibyte per minute (kiB/min) memory rate unit.
137  KibibytePerMinute,
138 
139  /// \brief Megabit per minute (Mb/min) memory rate unit.
140  MegabitPerMinute,
141 
142  /// \brief Mebibit per minute (Mib/min) memory rate unit.
143  MebibitPerMinute,
144 
145  /// \brief Megabyte per minute (MB/min) memory rate unit.
146  MegabytePerMinute,
147 
148  /// \brief Mebibyte per minute (MiB/min) memory rate unit.
149  MebibytePerMinute,
150 
151  /// \brief Gigabit per minute (Gb/min) memory rate unit.
152  GigabitPerMinute,
153 
154  /// \brief Gibibit per minute (Gib/min) memory rate unit.
155  GibibitPerMinute,
156 
157  /// \brief Gigabyte per minute (GB/min) memory rate unit.
158  GigabytePerMinute,
159 
160  /// \brief Gibibyte per minute (GiB/min) memory rate unit.
161  GibibytePerMinute,
162 
163  /// \brief Terabit per minute (Tb/min) memory rate unit.
164  TerabitPerMinute,
165 
166  /// \brief Tebibit per minute (Tib/min) memory rate unit.
167  TebibitPerMinute,
168 
169  /// \brief Terabyte per minute (TB/min) memory rate unit.
170  TerabytePerMinute,
171 
172  /// \brief Tebibyte per minute (TiB/min) memory rate unit.
173  TebibytePerMinute,
174 
175  /// \brief Petabit per minute (Pb/min) memory rate unit.
176  PetabitPerMinute,
177 
178  /// \brief Pebibit per minute (Pib/min) memory rate unit.
179  PebibitPerMinute,
180 
181  /// \brief Petabyte per minute (PB/min) memory rate unit.
182  PetabytePerMinute,
183 
184  /// \brief Pebibyte per minute (PiB/min) memory rate unit.
185  PebibytePerMinute,
186 
187  /// \brief Bit per hour (b/hr) memory rate unit.
188  BitPerHour,
189 
190  /// \brief Byte per hour (B/hr) memory rate unit.
191  BytePerHour,
192 
193  /// \brief Kilobit per hour (kb/hr) memory rate unit.
194  KilobitPerHour,
195 
196  /// \brief Kibibit per hour (kib/hr) memory rate unit.
197  KibibitPerHour,
198 
199  /// \brief Kilobyte per hour (kB/hr) memory rate unit.
200  KilobytePerHour,
201 
202  /// \brief Kibibyte per hour (kiB/hr) memory rate unit.
203  KibibytePerHour,
204 
205  /// \brief Megabit per hour (Mb/hr) memory rate unit.
206  MegabitPerHour,
207 
208  /// \brief Mebibit per hour (Mib/hr) memory rate unit.
209  MebibitPerHour,
210 
211  /// \brief Megabyte per hour (MB/hr) memory rate unit.
212  MegabytePerHour,
213 
214  /// \brief Mebibyte per hour (MiB/hr) memory rate unit.
215  MebibytePerHour,
216 
217  /// \brief Gigabit per hour (Gb/hr) memory rate unit.
218  GigabitPerHour,
219 
220  /// \brief Gibibit per hour (Gib/hr) memory rate unit.
221  GibibitPerHour,
222 
223  /// \brief Gigabyte per hour (GB/hr) memory rate unit.
224  GigabytePerHour,
225 
226  /// \brief Gibibyte per hour (GiB/hr) memory rate unit.
227  GibibytePerHour,
228 
229  /// \brief Terabit per hour (Tb/hr) memory rate unit.
230  TerabitPerHour,
231 
232  /// \brief Tebibit per hour (Tib/hr) memory rate unit.
233  TebibitPerHour,
234 
235  /// \brief Terabyte per hour (TB/hr) memory rate unit.
236  TerabytePerHour,
237 
238  /// \brief Tebibyte per hour (TiB/hr) memory rate unit.
239  TebibytePerHour,
240 
241  /// \brief Petabit per hour (Pb/hr) memory rate unit.
242  PetabitPerHour,
243 
244  /// \brief Pebibit per hour (Pib/hr) memory rate unit.
245  PebibitPerHour,
246 
247  /// \brief Petabyte per hour (PB/hr) memory rate unit.
248  PetabytePerHour,
249 
250  /// \brief Pebibyte per hour (PiB/hr) memory rate unit.
251  PebibytePerHour,
252 };
253 
254 } // namespace Unit
255 
256 /// \brief Standard computer memory rate unit: bit per second (b/s).
257 template <>
258 inline constexpr const Unit::MemoryRate Standard<Unit::MemoryRate>{Unit::MemoryRate::BitPerSecond};
259 
260 /// \brief Physical dimension set of computer memory rate units.
261 template <>
262 inline constexpr const Dimensions RelatedDimensions<Unit::MemoryRate>{
263  Dimensions{Dimension::Time{-1}, Dimension::Length{0}, Dimension::Mass{0},
264  Dimension::ElectricCurrent{0}, Dimension::Temperature{0},
265  Dimension::SubstanceAmount{0}, Dimension::LuminousIntensity{0}}
266 };
267 
268 inline std::ostream& operator<<(std::ostream& stream, const Unit::MemoryRate unit) {
269  stream << Abbreviation(unit);
270  return stream;
271 }
272 
273 namespace Internal {
274 
275 template <>
276 inline const std::map<UnitSystem, Unit::MemoryRate> ConsistentUnits<Unit::MemoryRate>{
277  {UnitSystem::MetreKilogramSecondKelvin, Unit::MemoryRate::BitPerSecond},
278  {UnitSystem::MillimetreGramSecondKelvin, Unit::MemoryRate::BitPerSecond},
279  {UnitSystem::FootPoundSecondRankine, Unit::MemoryRate::BitPerSecond},
280  {UnitSystem::InchPoundSecondRankine, Unit::MemoryRate::BitPerSecond},
281 };
282 
283 template <>
284 inline const std::map<Unit::MemoryRate, UnitSystem> RelatedUnitSystems<Unit::MemoryRate>{};
285 
286 template <>
287 inline const std::map<Unit::MemoryRate, std::string_view> Abbreviations<Unit::MemoryRate>{
288  {Unit::MemoryRate::BitPerSecond, "b/s" },
289  {Unit::MemoryRate::BytePerSecond, "B/s" },
290  {Unit::MemoryRate::KilobitPerSecond, "kb/s" },
291  {Unit::MemoryRate::KibibitPerSecond, "kib/s" },
292  {Unit::MemoryRate::KilobytePerSecond, "kB/s" },
293  {Unit::MemoryRate::KibibytePerSecond, "kiB/s" },
294  {Unit::MemoryRate::MegabitPerSecond, "Mb/s" },
295  {Unit::MemoryRate::MebibitPerSecond, "Mib/s" },
296  {Unit::MemoryRate::MegabytePerSecond, "MB/s" },
297  {Unit::MemoryRate::MebibytePerSecond, "MiB/s" },
298  {Unit::MemoryRate::GigabitPerSecond, "Gb/s" },
299  {Unit::MemoryRate::GibibitPerSecond, "Gib/s" },
300  {Unit::MemoryRate::GigabytePerSecond, "GB/s" },
301  {Unit::MemoryRate::GibibytePerSecond, "GiB/s" },
302  {Unit::MemoryRate::TerabitPerSecond, "Tb/s" },
303  {Unit::MemoryRate::TebibitPerSecond, "Tib/s" },
304  {Unit::MemoryRate::TerabytePerSecond, "TB/s" },
305  {Unit::MemoryRate::TebibytePerSecond, "TiB/s" },
306  {Unit::MemoryRate::PetabitPerSecond, "Pb/s" },
307  {Unit::MemoryRate::PebibitPerSecond, "Pib/s" },
308  {Unit::MemoryRate::PetabytePerSecond, "PB/s" },
309  {Unit::MemoryRate::PebibytePerSecond, "PiB/s" },
310  {Unit::MemoryRate::BitPerMinute, "b/min" },
311  {Unit::MemoryRate::BytePerMinute, "B/min" },
312  {Unit::MemoryRate::KilobitPerMinute, "kb/min" },
313  {Unit::MemoryRate::KibibitPerMinute, "kib/min"},
314  {Unit::MemoryRate::KilobytePerMinute, "kB/min" },
315  {Unit::MemoryRate::KibibytePerMinute, "kiB/min"},
316  {Unit::MemoryRate::MegabitPerMinute, "Mb/min" },
317  {Unit::MemoryRate::MebibitPerMinute, "Mib/min"},
318  {Unit::MemoryRate::MegabytePerMinute, "MB/min" },
319  {Unit::MemoryRate::MebibytePerMinute, "MiB/min"},
320  {Unit::MemoryRate::GigabitPerMinute, "Gb/min" },
321  {Unit::MemoryRate::GibibitPerMinute, "Gib/min"},
322  {Unit::MemoryRate::GigabytePerMinute, "GB/min" },
323  {Unit::MemoryRate::GibibytePerMinute, "GiB/min"},
324  {Unit::MemoryRate::TerabitPerMinute, "Tb/min" },
325  {Unit::MemoryRate::TebibitPerMinute, "Tib/min"},
326  {Unit::MemoryRate::TerabytePerMinute, "TB/min" },
327  {Unit::MemoryRate::TebibytePerMinute, "TiB/min"},
328  {Unit::MemoryRate::PetabitPerMinute, "Pb/min" },
329  {Unit::MemoryRate::PebibitPerMinute, "Pib/min"},
330  {Unit::MemoryRate::PetabytePerMinute, "PB/min" },
331  {Unit::MemoryRate::PebibytePerMinute, "PiB/min"},
332  {Unit::MemoryRate::BitPerHour, "b/hr" },
333  {Unit::MemoryRate::BytePerHour, "B/hr" },
334  {Unit::MemoryRate::KilobitPerHour, "kb/hr" },
335  {Unit::MemoryRate::KibibitPerHour, "kib/hr" },
336  {Unit::MemoryRate::KilobytePerHour, "kB/hr" },
337  {Unit::MemoryRate::KibibytePerHour, "kiB/hr" },
338  {Unit::MemoryRate::MegabitPerHour, "Mb/hr" },
339  {Unit::MemoryRate::MebibitPerHour, "Mib/hr" },
340  {Unit::MemoryRate::MegabytePerHour, "MB/hr" },
341  {Unit::MemoryRate::MebibytePerHour, "MiB/hr" },
342  {Unit::MemoryRate::GigabitPerHour, "Gb/hr" },
343  {Unit::MemoryRate::GibibitPerHour, "Gib/hr" },
344  {Unit::MemoryRate::GigabytePerHour, "GB/hr" },
345  {Unit::MemoryRate::GibibytePerHour, "GiB/hr" },
346  {Unit::MemoryRate::TerabitPerHour, "Tb/hr" },
347  {Unit::MemoryRate::TebibitPerHour, "Tib/hr" },
348  {Unit::MemoryRate::TerabytePerHour, "TB/hr" },
349  {Unit::MemoryRate::TebibytePerHour, "TiB/hr" },
350  {Unit::MemoryRate::PetabitPerHour, "Pb/hr" },
351  {Unit::MemoryRate::PebibitPerHour, "Pib/hr" },
352  {Unit::MemoryRate::PetabytePerHour, "PB/hr" },
353  {Unit::MemoryRate::PebibytePerHour, "PiB/hr" },
354 };
355 
356 template <>
357 inline const std::unordered_map<std::string_view, Unit::MemoryRate> Spellings<Unit::MemoryRate>{
358  {"b/s", Unit::MemoryRate::BitPerSecond },
359  {"B/s", Unit::MemoryRate::BytePerSecond },
360  {"kb/s", Unit::MemoryRate::KilobitPerSecond },
361  {"kB/s", Unit::MemoryRate::KilobytePerSecond},
362  {"kib/s", Unit::MemoryRate::KibibitPerSecond },
363  {"kiB/s", Unit::MemoryRate::KibibytePerSecond},
364  {"Mb/s", Unit::MemoryRate::MegabitPerSecond },
365  {"MB/s", Unit::MemoryRate::MegabytePerSecond},
366  {"Mib/s", Unit::MemoryRate::MebibitPerSecond },
367  {"MiB/s", Unit::MemoryRate::MebibytePerSecond},
368  {"Gb/s", Unit::MemoryRate::GigabitPerSecond },
369  {"GB/s", Unit::MemoryRate::GigabytePerSecond},
370  {"Gib/s", Unit::MemoryRate::GibibitPerSecond },
371  {"GiB/s", Unit::MemoryRate::GibibytePerSecond},
372  {"Tb/s", Unit::MemoryRate::TerabitPerSecond },
373  {"TB/s", Unit::MemoryRate::TerabytePerSecond},
374  {"Tib/s", Unit::MemoryRate::TebibitPerSecond },
375  {"TiB/s", Unit::MemoryRate::TebibytePerSecond},
376  {"Pb/s", Unit::MemoryRate::PetabitPerSecond },
377  {"PB/s", Unit::MemoryRate::PetabytePerSecond},
378  {"Pib/s", Unit::MemoryRate::PebibitPerSecond },
379  {"PiB/s", Unit::MemoryRate::PebibytePerSecond},
380  {"b/min", Unit::MemoryRate::BitPerMinute },
381  {"B/min", Unit::MemoryRate::BytePerMinute },
382  {"kb/min", Unit::MemoryRate::KilobitPerMinute },
383  {"kB/min", Unit::MemoryRate::KilobytePerMinute},
384  {"kib/min", Unit::MemoryRate::KibibitPerMinute },
385  {"kiB/min", Unit::MemoryRate::KibibytePerMinute},
386  {"Mb/min", Unit::MemoryRate::MegabitPerMinute },
387  {"MB/min", Unit::MemoryRate::MegabytePerMinute},
388  {"Mib/min", Unit::MemoryRate::MebibitPerMinute },
389  {"MiB/min", Unit::MemoryRate::MebibytePerMinute},
390  {"Gb/min", Unit::MemoryRate::GigabitPerMinute },
391  {"GB/min", Unit::MemoryRate::GigabytePerMinute},
392  {"Gib/min", Unit::MemoryRate::GibibitPerMinute },
393  {"GiB/min", Unit::MemoryRate::GibibytePerMinute},
394  {"Tb/min", Unit::MemoryRate::TerabitPerMinute },
395  {"TB/min", Unit::MemoryRate::TerabytePerMinute},
396  {"Tib/min", Unit::MemoryRate::TebibitPerMinute },
397  {"TiB/min", Unit::MemoryRate::TebibytePerMinute},
398  {"Pb/min", Unit::MemoryRate::PetabitPerMinute },
399  {"PB/min", Unit::MemoryRate::PetabytePerMinute},
400  {"Pib/min", Unit::MemoryRate::PebibitPerMinute },
401  {"PiB/min", Unit::MemoryRate::PebibytePerMinute},
402  {"b/hr", Unit::MemoryRate::BitPerHour },
403  {"B/hr", Unit::MemoryRate::BytePerHour },
404  {"kb/hr", Unit::MemoryRate::KilobitPerHour },
405  {"kB/hr", Unit::MemoryRate::KilobytePerHour },
406  {"kib/hr", Unit::MemoryRate::KibibitPerHour },
407  {"kiB/hr", Unit::MemoryRate::KibibytePerHour },
408  {"Mb/hr", Unit::MemoryRate::MegabitPerHour },
409  {"MB/hr", Unit::MemoryRate::MegabytePerHour },
410  {"Mib/hr", Unit::MemoryRate::MebibitPerHour },
411  {"MiB/hr", Unit::MemoryRate::MebibytePerHour },
412  {"Gb/hr", Unit::MemoryRate::GigabitPerHour },
413  {"GB/hr", Unit::MemoryRate::GigabytePerHour },
414  {"Gib/hr", Unit::MemoryRate::GibibitPerHour },
415  {"GiB/hr", Unit::MemoryRate::GibibytePerHour },
416  {"Tb/hr", Unit::MemoryRate::TerabitPerHour },
417  {"TB/hr", Unit::MemoryRate::TerabytePerHour },
418  {"Tib/hr", Unit::MemoryRate::TebibitPerHour },
419  {"TiB/hr", Unit::MemoryRate::TebibytePerHour },
420  {"Pb/hr", Unit::MemoryRate::PetabitPerHour },
421  {"PB/hr", Unit::MemoryRate::PetabytePerHour },
422  {"Pib/hr", Unit::MemoryRate::PebibitPerHour },
423  {"PiB/hr", Unit::MemoryRate::PebibytePerHour },
424 };
425 
426 template <>
427 template <typename NumericType>
428 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::BitPerSecond>::FromStandard(
429  NumericType& /*value*/) noexcept {}
430 
431 template <>
432 template <typename NumericType>
433 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::BitPerSecond>::ToStandard(
434  NumericType& /*value*/) noexcept {}
435 
436 template <>
437 template <typename NumericType>
438 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::BytePerSecond>::FromStandard(
439  NumericType& value) noexcept {
440  value *= static_cast<NumericType>(0.125L);
441 }
442 
443 template <>
444 template <typename NumericType>
445 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::BytePerSecond>::ToStandard(
446  NumericType& value) noexcept {
447  value *= static_cast<NumericType>(8.0L);
448 }
449 
450 template <>
451 template <typename NumericType>
452 inline constexpr void
453 Conversion<Unit::MemoryRate, Unit::MemoryRate::KilobitPerSecond>::FromStandard(
454  NumericType& value) noexcept {
455  value *= static_cast<NumericType>(0.001L);
456 }
457 
458 template <>
459 template <typename NumericType>
460 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KilobitPerSecond>::ToStandard(
461  NumericType& value) noexcept {
462  value *= static_cast<NumericType>(1000.0L);
463 }
464 
465 template <>
466 template <typename NumericType>
467 inline constexpr void
468 Conversion<Unit::MemoryRate, Unit::MemoryRate::KibibitPerSecond>::FromStandard(
469  NumericType& value) noexcept {
470  value /= static_cast<NumericType>(1024.0L);
471 }
472 
473 template <>
474 template <typename NumericType>
475 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KibibitPerSecond>::ToStandard(
476  NumericType& value) noexcept {
477  value *= static_cast<NumericType>(1024.0L);
478 }
479 
480 template <>
481 template <typename NumericType>
482 inline constexpr void
483 Conversion<Unit::MemoryRate, Unit::MemoryRate::KilobytePerSecond>::FromStandard(
484  NumericType& value) noexcept {
485  value /= static_cast<NumericType>(8000.0L);
486 }
487 
488 template <>
489 template <typename NumericType>
490 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KilobytePerSecond>::ToStandard(
491  NumericType& value) noexcept {
492  value *= static_cast<NumericType>(8000.0L);
493 }
494 
495 template <>
496 template <typename NumericType>
497 inline constexpr void
498 Conversion<Unit::MemoryRate, Unit::MemoryRate::KibibytePerSecond>::FromStandard(
499  NumericType& value) noexcept {
500  value /= (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L));
501 }
502 
503 template <>
504 template <typename NumericType>
505 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KibibytePerSecond>::ToStandard(
506  NumericType& value) noexcept {
507  value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L);
508 }
509 
510 template <>
511 template <typename NumericType>
512 inline constexpr void
513 Conversion<Unit::MemoryRate, Unit::MemoryRate::MegabitPerSecond>::FromStandard(
514  NumericType& value) noexcept {
515  value *= static_cast<NumericType>(1.0E-6L);
516 }
517 
518 template <>
519 template <typename NumericType>
520 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MegabitPerSecond>::ToStandard(
521  NumericType& value) noexcept {
522  value *= static_cast<NumericType>(1000000.0L);
523 }
524 
525 template <>
526 template <typename NumericType>
527 inline constexpr void
528 Conversion<Unit::MemoryRate, Unit::MemoryRate::MebibitPerSecond>::FromStandard(
529  NumericType& value) noexcept {
530  value /= (static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L));
531 }
532 
533 template <>
534 template <typename NumericType>
535 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MebibitPerSecond>::ToStandard(
536  NumericType& value) noexcept {
537  value *= static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L);
538 }
539 
540 template <>
541 template <typename NumericType>
542 inline constexpr void
543 Conversion<Unit::MemoryRate, Unit::MemoryRate::MegabytePerSecond>::FromStandard(
544  NumericType& value) noexcept {
545  value /= static_cast<NumericType>(8000000.0L);
546 }
547 
548 template <>
549 template <typename NumericType>
550 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MegabytePerSecond>::ToStandard(
551  NumericType& value) noexcept {
552  value *= static_cast<NumericType>(8000000.0L);
553 }
554 
555 template <>
556 template <typename NumericType>
557 inline constexpr void
558 Conversion<Unit::MemoryRate, Unit::MemoryRate::MebibytePerSecond>::FromStandard(
559  NumericType& value) noexcept {
560  value /= (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
561  * static_cast<NumericType>(1024.0L));
562 }
563 
564 template <>
565 template <typename NumericType>
566 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MebibytePerSecond>::ToStandard(
567  NumericType& value) noexcept {
568  value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
569  * static_cast<NumericType>(1024.0L);
570 }
571 
572 template <>
573 template <typename NumericType>
574 inline constexpr void
575 Conversion<Unit::MemoryRate, Unit::MemoryRate::GigabitPerSecond>::FromStandard(
576  NumericType& value) noexcept {
577  value *= static_cast<NumericType>(1.0E-9L);
578 }
579 
580 template <>
581 template <typename NumericType>
582 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GigabitPerSecond>::ToStandard(
583  NumericType& value) noexcept {
584  value *= static_cast<NumericType>(1.0E9L);
585 }
586 
587 template <>
588 template <typename NumericType>
589 inline constexpr void
590 Conversion<Unit::MemoryRate, Unit::MemoryRate::GibibitPerSecond>::FromStandard(
591  NumericType& value) noexcept {
592  value /= (static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
593  * static_cast<NumericType>(1024.0L));
594 }
595 
596 template <>
597 template <typename NumericType>
598 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GibibitPerSecond>::ToStandard(
599  NumericType& value) noexcept {
600  value *= static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
601  * static_cast<NumericType>(1024.0L);
602 }
603 
604 template <>
605 template <typename NumericType>
606 inline constexpr void
607 Conversion<Unit::MemoryRate, Unit::MemoryRate::GigabytePerSecond>::FromStandard(
608  NumericType& value) noexcept {
609  value /= static_cast<NumericType>(8.0E9L);
610 }
611 
612 template <>
613 template <typename NumericType>
614 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GigabytePerSecond>::ToStandard(
615  NumericType& value) noexcept {
616  value *= static_cast<NumericType>(8.0E9L);
617 }
618 
619 template <>
620 template <typename NumericType>
621 inline constexpr void
622 Conversion<Unit::MemoryRate, Unit::MemoryRate::GibibytePerSecond>::FromStandard(
623  NumericType& value) noexcept {
624  value /= (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
625  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L));
626 }
627 
628 template <>
629 template <typename NumericType>
630 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GibibytePerSecond>::ToStandard(
631  NumericType& value) noexcept {
632  value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
633  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L);
634 }
635 
636 template <>
637 template <typename NumericType>
638 inline constexpr void
639 Conversion<Unit::MemoryRate, Unit::MemoryRate::TerabitPerSecond>::FromStandard(
640  NumericType& value) noexcept {
641  value *= static_cast<NumericType>(1.0E-12L);
642 }
643 
644 template <>
645 template <typename NumericType>
646 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TerabitPerSecond>::ToStandard(
647  NumericType& value) noexcept {
648  value *= static_cast<NumericType>(1.0E12L);
649 }
650 
651 template <>
652 template <typename NumericType>
653 inline constexpr void
654 Conversion<Unit::MemoryRate, Unit::MemoryRate::TebibitPerSecond>::FromStandard(
655  NumericType& value) noexcept {
656  value /= (static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
657  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L));
658 }
659 
660 template <>
661 template <typename NumericType>
662 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TebibitPerSecond>::ToStandard(
663  NumericType& value) noexcept {
664  value *= static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
665  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L);
666 }
667 
668 template <>
669 template <typename NumericType>
670 inline constexpr void
671 Conversion<Unit::MemoryRate, Unit::MemoryRate::TerabytePerSecond>::FromStandard(
672  NumericType& value) noexcept {
673  value /= static_cast<NumericType>(8.0E12L);
674 }
675 
676 template <>
677 template <typename NumericType>
678 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TerabytePerSecond>::ToStandard(
679  NumericType& value) noexcept {
680  value *= static_cast<NumericType>(8.0E12L);
681 }
682 
683 template <>
684 template <typename NumericType>
685 inline constexpr void
686 Conversion<Unit::MemoryRate, Unit::MemoryRate::TebibytePerSecond>::FromStandard(
687  NumericType& value) noexcept {
688  value /= (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
689  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
690  * static_cast<NumericType>(1024.0L));
691 }
692 
693 template <>
694 template <typename NumericType>
695 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TebibytePerSecond>::ToStandard(
696  NumericType& value) noexcept {
697  value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
698  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
699  * static_cast<NumericType>(1024.0L);
700 }
701 
702 template <>
703 template <typename NumericType>
704 inline constexpr void
705 Conversion<Unit::MemoryRate, Unit::MemoryRate::PetabitPerSecond>::FromStandard(
706  NumericType& value) noexcept {
707  value *= static_cast<NumericType>(1.0E-15L);
708 }
709 
710 template <>
711 template <typename NumericType>
712 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PetabitPerSecond>::ToStandard(
713  NumericType& value) noexcept {
714  value *= static_cast<NumericType>(1.0E15L);
715 }
716 
717 template <>
718 template <typename NumericType>
719 inline constexpr void
720 Conversion<Unit::MemoryRate, Unit::MemoryRate::PebibitPerSecond>::FromStandard(
721  NumericType& value) noexcept {
722  value /= (static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
723  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
724  * static_cast<NumericType>(1024.0L));
725 }
726 
727 template <>
728 template <typename NumericType>
729 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PebibitPerSecond>::ToStandard(
730  NumericType& value) noexcept {
731  value *= static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
732  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
733  * static_cast<NumericType>(1024.0L);
734 }
735 
736 template <>
737 template <typename NumericType>
738 inline constexpr void
739 Conversion<Unit::MemoryRate, Unit::MemoryRate::PetabytePerSecond>::FromStandard(
740  NumericType& value) noexcept {
741  value /= static_cast<NumericType>(8.0E15L);
742 }
743 
744 template <>
745 template <typename NumericType>
746 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PetabytePerSecond>::ToStandard(
747  NumericType& value) noexcept {
748  value *= static_cast<NumericType>(8.0E15L);
749 }
750 
751 template <>
752 template <typename NumericType>
753 inline constexpr void
754 Conversion<Unit::MemoryRate, Unit::MemoryRate::PebibytePerSecond>::FromStandard(
755  NumericType& value) noexcept {
756  value /= (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
757  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
758  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L));
759 }
760 
761 template <>
762 template <typename NumericType>
763 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PebibytePerSecond>::ToStandard(
764  NumericType& value) noexcept {
765  value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
766  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
767  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L);
768 }
769 
770 template <>
771 template <typename NumericType>
772 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::BitPerMinute>::FromStandard(
773  NumericType& value) noexcept {
774  value *= static_cast<NumericType>(60.0L);
775 }
776 
777 template <>
778 template <typename NumericType>
779 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::BitPerMinute>::ToStandard(
780  NumericType& value) noexcept {
781  value /= static_cast<NumericType>(60.0L);
782 }
783 
784 template <>
785 template <typename NumericType>
786 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::BytePerMinute>::FromStandard(
787  NumericType& value) noexcept {
788  value *= static_cast<NumericType>(60.0L) / static_cast<NumericType>(8.0L);
789 }
790 
791 template <>
792 template <typename NumericType>
793 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::BytePerMinute>::ToStandard(
794  NumericType& value) noexcept {
795  value *= static_cast<NumericType>(8.0L) / static_cast<NumericType>(60.0L);
796 }
797 
798 template <>
799 template <typename NumericType>
800 inline constexpr void
801 Conversion<Unit::MemoryRate, Unit::MemoryRate::KilobitPerMinute>::FromStandard(
802  NumericType& value) noexcept {
803  value *= static_cast<NumericType>(60.0L) / static_cast<NumericType>(1000.0L);
804 }
805 
806 template <>
807 template <typename NumericType>
808 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KilobitPerMinute>::ToStandard(
809  NumericType& value) noexcept {
810  value *= static_cast<NumericType>(1000.0L) / static_cast<NumericType>(60.0L);
811 }
812 
813 template <>
814 template <typename NumericType>
815 inline constexpr void
816 Conversion<Unit::MemoryRate, Unit::MemoryRate::KibibitPerMinute>::FromStandard(
817  NumericType& value) noexcept {
818  value *= static_cast<NumericType>(60.0L) / static_cast<NumericType>(1024.0L);
819 }
820 
821 template <>
822 template <typename NumericType>
823 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KibibitPerMinute>::ToStandard(
824  NumericType& value) noexcept {
825  value *= static_cast<NumericType>(1024.0L) / static_cast<NumericType>(60.0L);
826 }
827 
828 template <>
829 template <typename NumericType>
830 inline constexpr void
831 Conversion<Unit::MemoryRate, Unit::MemoryRate::KilobytePerMinute>::FromStandard(
832  NumericType& value) noexcept {
833  value *= static_cast<NumericType>(60.0L) / static_cast<NumericType>(8000.0L);
834 }
835 
836 template <>
837 template <typename NumericType>
838 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KilobytePerMinute>::ToStandard(
839  NumericType& value) noexcept {
840  value *= static_cast<NumericType>(8000.0L) / static_cast<NumericType>(60.0L);
841 }
842 
843 template <>
844 template <typename NumericType>
845 inline constexpr void
846 Conversion<Unit::MemoryRate, Unit::MemoryRate::KibibytePerMinute>::FromStandard(
847  NumericType& value) noexcept {
848  value *= static_cast<NumericType>(60.0L)
849  / (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L));
850 }
851 
852 template <>
853 template <typename NumericType>
854 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KibibytePerMinute>::ToStandard(
855  NumericType& value) noexcept {
856  value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
857  / static_cast<NumericType>(60.0L);
858 }
859 
860 template <>
861 template <typename NumericType>
862 inline constexpr void
863 Conversion<Unit::MemoryRate, Unit::MemoryRate::MegabitPerMinute>::FromStandard(
864  NumericType& value) noexcept {
865  value *= static_cast<NumericType>(60.0L) / static_cast<NumericType>(1000000.0L);
866 }
867 
868 template <>
869 template <typename NumericType>
870 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MegabitPerMinute>::ToStandard(
871  NumericType& value) noexcept {
872  value *= static_cast<NumericType>(1000000.0L) / static_cast<NumericType>(60.0L);
873 }
874 
875 template <>
876 template <typename NumericType>
877 inline constexpr void
878 Conversion<Unit::MemoryRate, Unit::MemoryRate::MebibitPerMinute>::FromStandard(
879  NumericType& value) noexcept {
880  value *= static_cast<NumericType>(60.0L)
881  / (static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L));
882 }
883 
884 template <>
885 template <typename NumericType>
886 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MebibitPerMinute>::ToStandard(
887  NumericType& value) noexcept {
888  value *= static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
889  / static_cast<NumericType>(60.0L);
890 }
891 
892 template <>
893 template <typename NumericType>
894 inline constexpr void
895 Conversion<Unit::MemoryRate, Unit::MemoryRate::MegabytePerMinute>::FromStandard(
896  NumericType& value) noexcept {
897  value *= static_cast<NumericType>(60.0L) / static_cast<NumericType>(8000000.0L);
898 }
899 
900 template <>
901 template <typename NumericType>
902 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MegabytePerMinute>::ToStandard(
903  NumericType& value) noexcept {
904  value *= static_cast<NumericType>(8000000.0L) / static_cast<NumericType>(60.0L);
905 }
906 
907 template <>
908 template <typename NumericType>
909 inline constexpr void
910 Conversion<Unit::MemoryRate, Unit::MemoryRate::MebibytePerMinute>::FromStandard(
911  NumericType& value) noexcept {
912  value *= static_cast<NumericType>(60.0L)
913  / (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
914  * static_cast<NumericType>(1024.0L));
915 }
916 
917 template <>
918 template <typename NumericType>
919 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MebibytePerMinute>::ToStandard(
920  NumericType& value) noexcept {
921  value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
922  * static_cast<NumericType>(1024.0L) / static_cast<NumericType>(60.0L);
923 }
924 
925 template <>
926 template <typename NumericType>
927 inline constexpr void
928 Conversion<Unit::MemoryRate, Unit::MemoryRate::GigabitPerMinute>::FromStandard(
929  NumericType& value) noexcept {
930  value *= static_cast<NumericType>(60.0L) / static_cast<NumericType>(1.0E9L);
931 }
932 
933 template <>
934 template <typename NumericType>
935 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GigabitPerMinute>::ToStandard(
936  NumericType& value) noexcept {
937  value *= static_cast<NumericType>(1.0E9L) / static_cast<NumericType>(60.0L);
938 }
939 
940 template <>
941 template <typename NumericType>
942 inline constexpr void
943 Conversion<Unit::MemoryRate, Unit::MemoryRate::GibibitPerMinute>::FromStandard(
944  NumericType& value) noexcept {
945  value *= static_cast<NumericType>(60.0L)
946  / (static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
947  * static_cast<NumericType>(1024.0L));
948 }
949 
950 template <>
951 template <typename NumericType>
952 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GibibitPerMinute>::ToStandard(
953  NumericType& value) noexcept {
954  value *= static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
955  * static_cast<NumericType>(1024.0L) / static_cast<NumericType>(60.0L);
956 }
957 
958 template <>
959 template <typename NumericType>
960 inline constexpr void
961 Conversion<Unit::MemoryRate, Unit::MemoryRate::GigabytePerMinute>::FromStandard(
962  NumericType& value) noexcept {
963  value *= static_cast<NumericType>(60.0L) / (static_cast<NumericType>(8.0E9L));
964 }
965 
966 template <>
967 template <typename NumericType>
968 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GigabytePerMinute>::ToStandard(
969  NumericType& value) noexcept {
970  value *= static_cast<NumericType>(8.0E9L) / static_cast<NumericType>(60.0L);
971 }
972 
973 template <>
974 template <typename NumericType>
975 inline constexpr void
976 Conversion<Unit::MemoryRate, Unit::MemoryRate::GibibytePerMinute>::FromStandard(
977  NumericType& value) noexcept {
978  value *= static_cast<NumericType>(60.0L)
979  / (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
980  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L));
981 }
982 
983 template <>
984 template <typename NumericType>
985 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GibibytePerMinute>::ToStandard(
986  NumericType& value) noexcept {
987  value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
988  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
989  / static_cast<NumericType>(60.0L);
990 }
991 
992 template <>
993 template <typename NumericType>
994 inline constexpr void
995 Conversion<Unit::MemoryRate, Unit::MemoryRate::TerabitPerMinute>::FromStandard(
996  NumericType& value) noexcept {
997  value *= static_cast<NumericType>(60.0L) / static_cast<NumericType>(1.0E12L);
998 }
999 
1000 template <>
1001 template <typename NumericType>
1002 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TerabitPerMinute>::ToStandard(
1003  NumericType& value) noexcept {
1004  value *= static_cast<NumericType>(1.0E12L) / static_cast<NumericType>(60.0L);
1005 }
1006 
1007 template <>
1008 template <typename NumericType>
1009 inline constexpr void
1010 Conversion<Unit::MemoryRate, Unit::MemoryRate::TebibitPerMinute>::FromStandard(
1011  NumericType& value) noexcept {
1012  value *= static_cast<NumericType>(60.0L)
1013  / (static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1014  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L));
1015 }
1016 
1017 template <>
1018 template <typename NumericType>
1019 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TebibitPerMinute>::ToStandard(
1020  NumericType& value) noexcept {
1021  value *= static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1022  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1023  / static_cast<NumericType>(60.0L);
1024 }
1025 
1026 template <>
1027 template <typename NumericType>
1028 inline constexpr void
1029 Conversion<Unit::MemoryRate, Unit::MemoryRate::TerabytePerMinute>::FromStandard(
1030  NumericType& value) noexcept {
1031  value *= static_cast<NumericType>(60.0L) / static_cast<NumericType>(8.0E12L);
1032 }
1033 
1034 template <>
1035 template <typename NumericType>
1036 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TerabytePerMinute>::ToStandard(
1037  NumericType& value) noexcept {
1038  value *= static_cast<NumericType>(8.0E12L) / static_cast<NumericType>(60.0L);
1039 }
1040 
1041 template <>
1042 template <typename NumericType>
1043 inline constexpr void
1044 Conversion<Unit::MemoryRate, Unit::MemoryRate::TebibytePerMinute>::FromStandard(
1045  NumericType& value) noexcept {
1046  value *= static_cast<NumericType>(60.0L)
1047  / (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1048  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1049  * static_cast<NumericType>(1024.0L));
1050 }
1051 
1052 template <>
1053 template <typename NumericType>
1054 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TebibytePerMinute>::ToStandard(
1055  NumericType& value) noexcept {
1056  value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1057  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1058  * static_cast<NumericType>(1024.0L) / static_cast<NumericType>(60.0L);
1059 }
1060 
1061 template <>
1062 template <typename NumericType>
1063 inline constexpr void
1064 Conversion<Unit::MemoryRate, Unit::MemoryRate::PetabitPerMinute>::FromStandard(
1065  NumericType& value) noexcept {
1066  value *= static_cast<NumericType>(60.0L) / static_cast<NumericType>(1.0E15L);
1067 }
1068 
1069 template <>
1070 template <typename NumericType>
1071 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PetabitPerMinute>::ToStandard(
1072  NumericType& value) noexcept {
1073  value *= static_cast<NumericType>(1.0E15L) / static_cast<NumericType>(60.0L);
1074 }
1075 
1076 template <>
1077 template <typename NumericType>
1078 inline constexpr void
1079 Conversion<Unit::MemoryRate, Unit::MemoryRate::PebibitPerMinute>::FromStandard(
1080  NumericType& value) noexcept {
1081  value *= static_cast<NumericType>(60.0L)
1082  / (static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1083  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1084  * static_cast<NumericType>(1024.0L));
1085 }
1086 
1087 template <>
1088 template <typename NumericType>
1089 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PebibitPerMinute>::ToStandard(
1090  NumericType& value) noexcept {
1091  value *= static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1092  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1093  * static_cast<NumericType>(1024.0L) / static_cast<NumericType>(60.0L);
1094 }
1095 
1096 template <>
1097 template <typename NumericType>
1098 inline constexpr void
1099 Conversion<Unit::MemoryRate, Unit::MemoryRate::PetabytePerMinute>::FromStandard(
1100  NumericType& value) noexcept {
1101  value *= static_cast<NumericType>(60.0L) / static_cast<NumericType>(8.0E15L);
1102 }
1103 
1104 template <>
1105 template <typename NumericType>
1106 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PetabytePerMinute>::ToStandard(
1107  NumericType& value) noexcept {
1108  value *= static_cast<NumericType>(8.0E15L) / static_cast<NumericType>(60.0L);
1109 }
1110 
1111 template <>
1112 template <typename NumericType>
1113 inline constexpr void
1114 Conversion<Unit::MemoryRate, Unit::MemoryRate::PebibytePerMinute>::FromStandard(
1115  NumericType& value) noexcept {
1116  value *= static_cast<NumericType>(60.0L)
1117  / (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1118  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1119  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L));
1120 }
1121 
1122 template <>
1123 template <typename NumericType>
1124 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PebibytePerMinute>::ToStandard(
1125  NumericType& value) noexcept {
1126  value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1127  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1128  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1129  / static_cast<NumericType>(60.0L);
1130 }
1131 
1132 template <>
1133 template <typename NumericType>
1134 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::BitPerHour>::FromStandard(
1135  NumericType& value) noexcept {
1136  value *= static_cast<NumericType>(3600.0L);
1137 }
1138 
1139 template <>
1140 template <typename NumericType>
1141 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::BitPerHour>::ToStandard(
1142  NumericType& value) noexcept {
1143  value /= static_cast<NumericType>(3600.0L);
1144 }
1145 
1146 template <>
1147 template <typename NumericType>
1148 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::BytePerHour>::FromStandard(
1149  NumericType& value) noexcept {
1150  value *= static_cast<NumericType>(3600.0L) / static_cast<NumericType>(8.0L);
1151 }
1152 
1153 template <>
1154 template <typename NumericType>
1155 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::BytePerHour>::ToStandard(
1156  NumericType& value) noexcept {
1157  value *= static_cast<NumericType>(8.0L) / static_cast<NumericType>(3600.0L);
1158 }
1159 
1160 template <>
1161 template <typename NumericType>
1162 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KilobitPerHour>::FromStandard(
1163  NumericType& value) noexcept {
1164  value *= static_cast<NumericType>(3600.0L) / static_cast<NumericType>(1000.0L);
1165 }
1166 
1167 template <>
1168 template <typename NumericType>
1169 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KilobitPerHour>::ToStandard(
1170  NumericType& value) noexcept {
1171  value *= static_cast<NumericType>(1000.0L) / static_cast<NumericType>(3600.0L);
1172 }
1173 
1174 template <>
1175 template <typename NumericType>
1176 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KibibitPerHour>::FromStandard(
1177  NumericType& value) noexcept {
1178  value *= static_cast<NumericType>(3600.0L) / static_cast<NumericType>(1024.0L);
1179 }
1180 
1181 template <>
1182 template <typename NumericType>
1183 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KibibitPerHour>::ToStandard(
1184  NumericType& value) noexcept {
1185  value *= static_cast<NumericType>(1024.0L) / static_cast<NumericType>(3600.0L);
1186 }
1187 
1188 template <>
1189 template <typename NumericType>
1190 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KilobytePerHour>::FromStandard(
1191  NumericType& value) noexcept {
1192  value *= static_cast<NumericType>(3600.0L) / static_cast<NumericType>(8000.0L);
1193 }
1194 
1195 template <>
1196 template <typename NumericType>
1197 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KilobytePerHour>::ToStandard(
1198  NumericType& value) noexcept {
1199  value *= static_cast<NumericType>(8000.0L) / static_cast<NumericType>(3600.0L);
1200 }
1201 
1202 template <>
1203 template <typename NumericType>
1204 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KibibytePerHour>::FromStandard(
1205  NumericType& value) noexcept {
1206  value *= static_cast<NumericType>(3600.0L)
1207  / (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L));
1208 }
1209 
1210 template <>
1211 template <typename NumericType>
1212 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KibibytePerHour>::ToStandard(
1213  NumericType& value) noexcept {
1214  value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1215  / static_cast<NumericType>(3600.0L);
1216 }
1217 
1218 template <>
1219 template <typename NumericType>
1220 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MegabitPerHour>::FromStandard(
1221  NumericType& value) noexcept {
1222  value *= static_cast<NumericType>(3600.0L) / static_cast<NumericType>(1000000.0L);
1223 }
1224 
1225 template <>
1226 template <typename NumericType>
1227 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MegabitPerHour>::ToStandard(
1228  NumericType& value) noexcept {
1229  value *= static_cast<NumericType>(1000000.0L) / static_cast<NumericType>(3600.0L);
1230 }
1231 
1232 template <>
1233 template <typename NumericType>
1234 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MebibitPerHour>::FromStandard(
1235  NumericType& value) noexcept {
1236  value *= static_cast<NumericType>(3600.0L)
1237  / (static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L));
1238 }
1239 
1240 template <>
1241 template <typename NumericType>
1242 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MebibitPerHour>::ToStandard(
1243  NumericType& value) noexcept {
1244  value *= static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1245  / static_cast<NumericType>(3600.0L);
1246 }
1247 
1248 template <>
1249 template <typename NumericType>
1250 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MegabytePerHour>::FromStandard(
1251  NumericType& value) noexcept {
1252  value *= static_cast<NumericType>(3600.0L) / static_cast<NumericType>(8000000.0L);
1253 }
1254 
1255 template <>
1256 template <typename NumericType>
1257 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MegabytePerHour>::ToStandard(
1258  NumericType& value) noexcept {
1259  value *= static_cast<NumericType>(8000000.0L) / static_cast<NumericType>(3600.0L);
1260 }
1261 
1262 template <>
1263 template <typename NumericType>
1264 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MebibytePerHour>::FromStandard(
1265  NumericType& value) noexcept {
1266  value *= static_cast<NumericType>(3600.0L)
1267  / (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1268  * static_cast<NumericType>(1024.0L));
1269 }
1270 
1271 template <>
1272 template <typename NumericType>
1273 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MebibytePerHour>::ToStandard(
1274  NumericType& value) noexcept {
1275  value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1276  * static_cast<NumericType>(1024.0L) / static_cast<NumericType>(3600.0L);
1277 }
1278 
1279 template <>
1280 template <typename NumericType>
1281 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GigabitPerHour>::FromStandard(
1282  NumericType& value) noexcept {
1283  value *= static_cast<NumericType>(3600.0L) / static_cast<NumericType>(1.0E9L);
1284 }
1285 
1286 template <>
1287 template <typename NumericType>
1288 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GigabitPerHour>::ToStandard(
1289  NumericType& value) noexcept {
1290  value *= static_cast<NumericType>(1.0E9L) / static_cast<NumericType>(3600.0L);
1291 }
1292 
1293 template <>
1294 template <typename NumericType>
1295 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GibibitPerHour>::FromStandard(
1296  NumericType& value) noexcept {
1297  value *= static_cast<NumericType>(3600.0L)
1298  / (static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1299  * static_cast<NumericType>(1024.0L));
1300 }
1301 
1302 template <>
1303 template <typename NumericType>
1304 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GibibitPerHour>::ToStandard(
1305  NumericType& value) noexcept {
1306  value *= static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1307  * static_cast<NumericType>(1024.0L) / static_cast<NumericType>(3600.0L);
1308 }
1309 
1310 template <>
1311 template <typename NumericType>
1312 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GigabytePerHour>::FromStandard(
1313  NumericType& value) noexcept {
1314  value *= static_cast<NumericType>(3600.0L) / (static_cast<NumericType>(8.0E9L));
1315 }
1316 
1317 template <>
1318 template <typename NumericType>
1319 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GigabytePerHour>::ToStandard(
1320  NumericType& value) noexcept {
1321  value *= static_cast<NumericType>(8.0E9L) / static_cast<NumericType>(3600.0L);
1322 }
1323 
1324 template <>
1325 template <typename NumericType>
1326 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GibibytePerHour>::FromStandard(
1327  NumericType& value) noexcept {
1328  value *= static_cast<NumericType>(3600.0L)
1329  / (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1330  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L));
1331 }
1332 
1333 template <>
1334 template <typename NumericType>
1335 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GibibytePerHour>::ToStandard(
1336  NumericType& value) noexcept {
1337  value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1338  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1339  / static_cast<NumericType>(3600.0L);
1340 }
1341 
1342 template <>
1343 template <typename NumericType>
1344 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TerabitPerHour>::FromStandard(
1345  NumericType& value) noexcept {
1346  value *= static_cast<NumericType>(3600.0L) / static_cast<NumericType>(1.0E12L);
1347 }
1348 
1349 template <>
1350 template <typename NumericType>
1351 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TerabitPerHour>::ToStandard(
1352  NumericType& value) noexcept {
1353  value *= static_cast<NumericType>(1.0E12L) / static_cast<NumericType>(3600.0L);
1354 }
1355 
1356 template <>
1357 template <typename NumericType>
1358 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TebibitPerHour>::FromStandard(
1359  NumericType& value) noexcept {
1360  value *= static_cast<NumericType>(3600.0L)
1361  / (static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1362  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L));
1363 }
1364 
1365 template <>
1366 template <typename NumericType>
1367 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TebibitPerHour>::ToStandard(
1368  NumericType& value) noexcept {
1369  value *= static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1370  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1371  / static_cast<NumericType>(3600.0L);
1372 }
1373 
1374 template <>
1375 template <typename NumericType>
1376 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TerabytePerHour>::FromStandard(
1377  NumericType& value) noexcept {
1378  value *= static_cast<NumericType>(3600.0L) / static_cast<NumericType>(8.0E12L);
1379 }
1380 
1381 template <>
1382 template <typename NumericType>
1383 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TerabytePerHour>::ToStandard(
1384  NumericType& value) noexcept {
1385  value *= static_cast<NumericType>(8.0E12L) / static_cast<NumericType>(3600.0L);
1386 }
1387 
1388 template <>
1389 template <typename NumericType>
1390 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TebibytePerHour>::FromStandard(
1391  NumericType& value) noexcept {
1392  value *= static_cast<NumericType>(3600.0L)
1393  / (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1394  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1395  * static_cast<NumericType>(1024.0L));
1396 }
1397 
1398 template <>
1399 template <typename NumericType>
1400 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TebibytePerHour>::ToStandard(
1401  NumericType& value) noexcept {
1402  value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1403  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1404  * static_cast<NumericType>(1024.0L) / static_cast<NumericType>(3600.0L);
1405 }
1406 
1407 template <>
1408 template <typename NumericType>
1409 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PetabitPerHour>::FromStandard(
1410  NumericType& value) noexcept {
1411  value *= static_cast<NumericType>(3600.0L) / static_cast<NumericType>(1.0E15L);
1412 }
1413 
1414 template <>
1415 template <typename NumericType>
1416 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PetabitPerHour>::ToStandard(
1417  NumericType& value) noexcept {
1418  value *= static_cast<NumericType>(1.0E15L) / static_cast<NumericType>(3600.0L);
1419 }
1420 
1421 template <>
1422 template <typename NumericType>
1423 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PebibitPerHour>::FromStandard(
1424  NumericType& value) noexcept {
1425  value *= static_cast<NumericType>(3600.0L)
1426  / (static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1427  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1428  * static_cast<NumericType>(1024.0L));
1429 }
1430 
1431 template <>
1432 template <typename NumericType>
1433 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PebibitPerHour>::ToStandard(
1434  NumericType& value) noexcept {
1435  value *= static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1436  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1437  * static_cast<NumericType>(1024.0L) / static_cast<NumericType>(3600.0L);
1438 }
1439 
1440 template <>
1441 template <typename NumericType>
1442 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PetabytePerHour>::FromStandard(
1443  NumericType& value) noexcept {
1444  value *= static_cast<NumericType>(3600.0L) / static_cast<NumericType>(8.0E15L);
1445 }
1446 
1447 template <>
1448 template <typename NumericType>
1449 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PetabytePerHour>::ToStandard(
1450  NumericType& value) noexcept {
1451  value *= static_cast<NumericType>(8.0E15L) / static_cast<NumericType>(3600.0L);
1452 }
1453 
1454 template <>
1455 template <typename NumericType>
1456 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PebibytePerHour>::FromStandard(
1457  NumericType& value) noexcept {
1458  value *= static_cast<NumericType>(3600.0L)
1459  / (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1460  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1461  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L));
1462 }
1463 
1464 template <>
1465 template <typename NumericType>
1466 inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PebibytePerHour>::ToStandard(
1467  NumericType& value) noexcept {
1468  value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1469  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1470  * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1471  / static_cast<NumericType>(3600.0L);
1472 }
1473 
1474 template <typename NumericType>
1475 inline const std::map<Unit::MemoryRate,
1476  std::function<void(NumericType* values, const std::size_t size)>>
1477  MapOfConversionsFromStandard<Unit::MemoryRate, NumericType>{
1478  {Unit::MemoryRate::BitPerSecond,
1479  Conversions<Unit::MemoryRate, Unit::MemoryRate::BitPerSecond>::FromStandard<NumericType> },
1480  {Unit::MemoryRate::BytePerSecond,
1481  Conversions<Unit::MemoryRate, Unit::MemoryRate::BytePerSecond>::FromStandard<NumericType>},
1482  {Unit::MemoryRate::KilobitPerSecond,
1483  Conversions<Unit::MemoryRate,
1484  Unit::MemoryRate::KilobitPerSecond>::FromStandard<NumericType> },
1485  {Unit::MemoryRate::KibibitPerSecond,
1486  Conversions<Unit::MemoryRate,
1487  Unit::MemoryRate::KibibitPerSecond>::FromStandard<NumericType> },
1488  {Unit::MemoryRate::KilobytePerSecond,
1489  Conversions<Unit::MemoryRate,
1490  Unit::MemoryRate::KilobytePerSecond>::FromStandard<NumericType> },
1491  {Unit::MemoryRate::KibibytePerSecond,
1492  Conversions<Unit::MemoryRate,
1493  Unit::MemoryRate::KibibytePerSecond>::FromStandard<NumericType> },
1494  {Unit::MemoryRate::MegabitPerSecond,
1495  Conversions<Unit::MemoryRate,
1496  Unit::MemoryRate::MegabitPerSecond>::FromStandard<NumericType> },
1497  {Unit::MemoryRate::MebibitPerSecond,
1498  Conversions<Unit::MemoryRate,
1499  Unit::MemoryRate::MebibitPerSecond>::FromStandard<NumericType> },
1500  {Unit::MemoryRate::MegabytePerSecond,
1501  Conversions<Unit::MemoryRate,
1502  Unit::MemoryRate::MegabytePerSecond>::FromStandard<NumericType> },
1503  {Unit::MemoryRate::MebibytePerSecond,
1504  Conversions<Unit::MemoryRate,
1505  Unit::MemoryRate::MebibytePerSecond>::FromStandard<NumericType> },
1506  {Unit::MemoryRate::GigabitPerSecond,
1507  Conversions<Unit::MemoryRate,
1508  Unit::MemoryRate::GigabitPerSecond>::FromStandard<NumericType> },
1509  {Unit::MemoryRate::GibibitPerSecond,
1510  Conversions<Unit::MemoryRate,
1511  Unit::MemoryRate::GibibitPerSecond>::FromStandard<NumericType> },
1512  {Unit::MemoryRate::GigabytePerSecond,
1513  Conversions<Unit::MemoryRate,
1514  Unit::MemoryRate::GigabytePerSecond>::FromStandard<NumericType> },
1515  {Unit::MemoryRate::GibibytePerSecond,
1516  Conversions<Unit::MemoryRate,
1517  Unit::MemoryRate::GibibytePerSecond>::FromStandard<NumericType> },
1518  {Unit::MemoryRate::TerabitPerSecond,
1519  Conversions<Unit::MemoryRate,
1520  Unit::MemoryRate::TerabitPerSecond>::FromStandard<NumericType> },
1521  {Unit::MemoryRate::TebibitPerSecond,
1522  Conversions<Unit::MemoryRate,
1523  Unit::MemoryRate::TebibitPerSecond>::FromStandard<NumericType> },
1524  {Unit::MemoryRate::TerabytePerSecond,
1525  Conversions<Unit::MemoryRate,
1526  Unit::MemoryRate::TerabytePerSecond>::FromStandard<NumericType> },
1527  {Unit::MemoryRate::TebibytePerSecond,
1528  Conversions<Unit::MemoryRate,
1529  Unit::MemoryRate::TebibytePerSecond>::FromStandard<NumericType> },
1530  {Unit::MemoryRate::PetabitPerSecond,
1531  Conversions<Unit::MemoryRate,
1532  Unit::MemoryRate::PetabitPerSecond>::FromStandard<NumericType> },
1533  {Unit::MemoryRate::PebibitPerSecond,
1534  Conversions<Unit::MemoryRate,
1535  Unit::MemoryRate::PebibitPerSecond>::FromStandard<NumericType> },
1536  {Unit::MemoryRate::PetabytePerSecond,
1537  Conversions<Unit::MemoryRate,
1538  Unit::MemoryRate::PetabytePerSecond>::FromStandard<NumericType> },
1539  {Unit::MemoryRate::PebibytePerSecond,
1540  Conversions<Unit::MemoryRate,
1541  Unit::MemoryRate::PebibytePerSecond>::FromStandard<NumericType> },
1542  {Unit::MemoryRate::BitPerMinute,
1543  Conversions<Unit::MemoryRate, Unit::MemoryRate::BitPerMinute>::FromStandard<NumericType> },
1544  {Unit::MemoryRate::BytePerMinute,
1545  Conversions<Unit::MemoryRate, Unit::MemoryRate::BytePerMinute>::FromStandard<NumericType>},
1546  {Unit::MemoryRate::KilobitPerMinute,
1547  Conversions<Unit::MemoryRate,
1548  Unit::MemoryRate::KilobitPerMinute>::FromStandard<NumericType> },
1549  {Unit::MemoryRate::KibibitPerMinute,
1550  Conversions<Unit::MemoryRate,
1551  Unit::MemoryRate::KibibitPerMinute>::FromStandard<NumericType> },
1552  {Unit::MemoryRate::KilobytePerMinute,
1553  Conversions<Unit::MemoryRate,
1554  Unit::MemoryRate::KilobytePerMinute>::FromStandard<NumericType> },
1555  {Unit::MemoryRate::KibibytePerMinute,
1556  Conversions<Unit::MemoryRate,
1557  Unit::MemoryRate::KibibytePerMinute>::FromStandard<NumericType> },
1558  {Unit::MemoryRate::MegabitPerMinute,
1559  Conversions<Unit::MemoryRate,
1560  Unit::MemoryRate::MegabitPerMinute>::FromStandard<NumericType> },
1561  {Unit::MemoryRate::MebibitPerMinute,
1562  Conversions<Unit::MemoryRate,
1563  Unit::MemoryRate::MebibitPerMinute>::FromStandard<NumericType> },
1564  {Unit::MemoryRate::MegabytePerMinute,
1565  Conversions<Unit::MemoryRate,
1566  Unit::MemoryRate::MegabytePerMinute>::FromStandard<NumericType> },
1567  {Unit::MemoryRate::MebibytePerMinute,
1568  Conversions<Unit::MemoryRate,
1569  Unit::MemoryRate::MebibytePerMinute>::FromStandard<NumericType> },
1570  {Unit::MemoryRate::GigabitPerMinute,
1571  Conversions<Unit::MemoryRate,
1572  Unit::MemoryRate::GigabitPerMinute>::FromStandard<NumericType> },
1573  {Unit::MemoryRate::GibibitPerMinute,
1574  Conversions<Unit::MemoryRate,
1575  Unit::MemoryRate::GibibitPerMinute>::FromStandard<NumericType> },
1576  {Unit::MemoryRate::GigabytePerMinute,
1577  Conversions<Unit::MemoryRate,
1578  Unit::MemoryRate::GigabytePerMinute>::FromStandard<NumericType> },
1579  {Unit::MemoryRate::GibibytePerMinute,
1580  Conversions<Unit::MemoryRate,
1581  Unit::MemoryRate::GibibytePerMinute>::FromStandard<NumericType> },
1582  {Unit::MemoryRate::TerabitPerMinute,
1583  Conversions<Unit::MemoryRate,
1584  Unit::MemoryRate::TerabitPerMinute>::FromStandard<NumericType> },
1585  {Unit::MemoryRate::TebibitPerMinute,
1586  Conversions<Unit::MemoryRate,
1587  Unit::MemoryRate::TebibitPerMinute>::FromStandard<NumericType> },
1588  {Unit::MemoryRate::TerabytePerMinute,
1589  Conversions<Unit::MemoryRate,
1590  Unit::MemoryRate::TerabytePerMinute>::FromStandard<NumericType> },
1591  {Unit::MemoryRate::TebibytePerMinute,
1592  Conversions<Unit::MemoryRate,
1593  Unit::MemoryRate::TebibytePerMinute>::FromStandard<NumericType> },
1594  {Unit::MemoryRate::PetabitPerMinute,
1595  Conversions<Unit::MemoryRate,
1596  Unit::MemoryRate::PetabitPerMinute>::FromStandard<NumericType> },
1597  {Unit::MemoryRate::PebibitPerMinute,
1598  Conversions<Unit::MemoryRate,
1599  Unit::MemoryRate::PebibitPerMinute>::FromStandard<NumericType> },
1600  {Unit::MemoryRate::PetabytePerMinute,
1601  Conversions<Unit::MemoryRate,
1602  Unit::MemoryRate::PetabytePerMinute>::FromStandard<NumericType> },
1603  {Unit::MemoryRate::PebibytePerMinute,
1604  Conversions<Unit::MemoryRate,
1605  Unit::MemoryRate::PebibytePerMinute>::FromStandard<NumericType> },
1606  {Unit::MemoryRate::BitPerHour,
1607  Conversions<Unit::MemoryRate, Unit::MemoryRate::BitPerHour>::FromStandard<NumericType> },
1608  {Unit::MemoryRate::BytePerHour,
1609  Conversions<Unit::MemoryRate, Unit::MemoryRate::BytePerHour>::FromStandard<NumericType> },
1610  {Unit::MemoryRate::KilobitPerHour,
1611  Conversions<Unit::MemoryRate,
1612  Unit::MemoryRate::KilobitPerHour>::FromStandard<NumericType> },
1613  {Unit::MemoryRate::KibibitPerHour,
1614  Conversions<Unit::MemoryRate,
1615  Unit::MemoryRate::KibibitPerHour>::FromStandard<NumericType> },
1616  {Unit::MemoryRate::KilobytePerHour,
1617  Conversions<Unit::MemoryRate,
1618  Unit::MemoryRate::KilobytePerHour>::FromStandard<NumericType> },
1619  {Unit::MemoryRate::KibibytePerHour,
1620  Conversions<Unit::MemoryRate,
1621  Unit::MemoryRate::KibibytePerHour>::FromStandard<NumericType> },
1622  {Unit::MemoryRate::MegabitPerHour,
1623  Conversions<Unit::MemoryRate,
1624  Unit::MemoryRate::MegabitPerHour>::FromStandard<NumericType> },
1625  {Unit::MemoryRate::MebibitPerHour,
1626  Conversions<Unit::MemoryRate,
1627  Unit::MemoryRate::MebibitPerHour>::FromStandard<NumericType> },
1628  {Unit::MemoryRate::MegabytePerHour,
1629  Conversions<Unit::MemoryRate,
1630  Unit::MemoryRate::MegabytePerHour>::FromStandard<NumericType> },
1631  {Unit::MemoryRate::MebibytePerHour,
1632  Conversions<Unit::MemoryRate,
1633  Unit::MemoryRate::MebibytePerHour>::FromStandard<NumericType> },
1634  {Unit::MemoryRate::GigabitPerHour,
1635  Conversions<Unit::MemoryRate,
1636  Unit::MemoryRate::GigabitPerHour>::FromStandard<NumericType> },
1637  {Unit::MemoryRate::GibibitPerHour,
1638  Conversions<Unit::MemoryRate,
1639  Unit::MemoryRate::GibibitPerHour>::FromStandard<NumericType> },
1640  {Unit::MemoryRate::GigabytePerHour,
1641  Conversions<Unit::MemoryRate,
1642  Unit::MemoryRate::GigabytePerHour>::FromStandard<NumericType> },
1643  {Unit::MemoryRate::GibibytePerHour,
1644  Conversions<Unit::MemoryRate,
1645  Unit::MemoryRate::GibibytePerHour>::FromStandard<NumericType> },
1646  {Unit::MemoryRate::TerabitPerHour,
1647  Conversions<Unit::MemoryRate,
1648  Unit::MemoryRate::TerabitPerHour>::FromStandard<NumericType> },
1649  {Unit::MemoryRate::TebibitPerHour,
1650  Conversions<Unit::MemoryRate,
1651  Unit::MemoryRate::TebibitPerHour>::FromStandard<NumericType> },
1652  {Unit::MemoryRate::TerabytePerHour,
1653  Conversions<Unit::MemoryRate,
1654  Unit::MemoryRate::TerabytePerHour>::FromStandard<NumericType> },
1655  {Unit::MemoryRate::TebibytePerHour,
1656  Conversions<Unit::MemoryRate,
1657  Unit::MemoryRate::TebibytePerHour>::FromStandard<NumericType> },
1658  {Unit::MemoryRate::PetabitPerHour,
1659  Conversions<Unit::MemoryRate,
1660  Unit::MemoryRate::PetabitPerHour>::FromStandard<NumericType> },
1661  {Unit::MemoryRate::PebibitPerHour,
1662  Conversions<Unit::MemoryRate,
1663  Unit::MemoryRate::PebibitPerHour>::FromStandard<NumericType> },
1664  {Unit::MemoryRate::PetabytePerHour,
1665  Conversions<Unit::MemoryRate,
1666  Unit::MemoryRate::PetabytePerHour>::FromStandard<NumericType> },
1667  {Unit::MemoryRate::PebibytePerHour,
1668  Conversions<Unit::MemoryRate,
1669  Unit::MemoryRate::PebibytePerHour>::FromStandard<NumericType> },
1670 };
1671 
1672 template <typename NumericType>
1673 inline const std::map<Unit::MemoryRate,
1674  std::function<void(NumericType* const values, const std::size_t size)>>
1675  MapOfConversionsToStandard<Unit::MemoryRate, NumericType>{
1676  {Unit::MemoryRate::BitPerSecond,
1677  Conversions<Unit::MemoryRate, Unit::MemoryRate::BitPerSecond>::ToStandard<NumericType> },
1678  {Unit::MemoryRate::BytePerSecond,
1679  Conversions<Unit::MemoryRate, Unit::MemoryRate::BytePerSecond>::ToStandard<NumericType> },
1680  {Unit::MemoryRate::KilobitPerSecond,
1681  Conversions<Unit::MemoryRate,
1682  Unit::MemoryRate::KilobitPerSecond>::ToStandard<NumericType> },
1683  {Unit::MemoryRate::KibibitPerSecond,
1684  Conversions<Unit::MemoryRate,
1685  Unit::MemoryRate::KibibitPerSecond>::ToStandard<NumericType> },
1686  {Unit::MemoryRate::KilobytePerSecond,
1687  Conversions<Unit::MemoryRate,
1688  Unit::MemoryRate::KilobytePerSecond>::ToStandard<NumericType> },
1689  {Unit::MemoryRate::KibibytePerSecond,
1690  Conversions<Unit::MemoryRate,
1691  Unit::MemoryRate::KibibytePerSecond>::ToStandard<NumericType> },
1692  {Unit::MemoryRate::MegabitPerSecond,
1693  Conversions<Unit::MemoryRate,
1694  Unit::MemoryRate::MegabitPerSecond>::ToStandard<NumericType> },
1695  {Unit::MemoryRate::MebibitPerSecond,
1696  Conversions<Unit::MemoryRate,
1697  Unit::MemoryRate::MebibitPerSecond>::ToStandard<NumericType> },
1698  {Unit::MemoryRate::MegabytePerSecond,
1699  Conversions<Unit::MemoryRate,
1700  Unit::MemoryRate::MegabytePerSecond>::ToStandard<NumericType> },
1701  {Unit::MemoryRate::MebibytePerSecond,
1702  Conversions<Unit::MemoryRate,
1703  Unit::MemoryRate::MebibytePerSecond>::ToStandard<NumericType> },
1704  {Unit::MemoryRate::GigabitPerSecond,
1705  Conversions<Unit::MemoryRate,
1706  Unit::MemoryRate::GigabitPerSecond>::ToStandard<NumericType> },
1707  {Unit::MemoryRate::GibibitPerSecond,
1708  Conversions<Unit::MemoryRate,
1709  Unit::MemoryRate::GibibitPerSecond>::ToStandard<NumericType> },
1710  {Unit::MemoryRate::GigabytePerSecond,
1711  Conversions<Unit::MemoryRate,
1712  Unit::MemoryRate::GigabytePerSecond>::ToStandard<NumericType> },
1713  {Unit::MemoryRate::GibibytePerSecond,
1714  Conversions<Unit::MemoryRate,
1715  Unit::MemoryRate::GibibytePerSecond>::ToStandard<NumericType> },
1716  {Unit::MemoryRate::TerabitPerSecond,
1717  Conversions<Unit::MemoryRate,
1718  Unit::MemoryRate::TerabitPerSecond>::ToStandard<NumericType> },
1719  {Unit::MemoryRate::TebibitPerSecond,
1720  Conversions<Unit::MemoryRate,
1721  Unit::MemoryRate::TebibitPerSecond>::ToStandard<NumericType> },
1722  {Unit::MemoryRate::TerabytePerSecond,
1723  Conversions<Unit::MemoryRate,
1724  Unit::MemoryRate::TerabytePerSecond>::ToStandard<NumericType> },
1725  {Unit::MemoryRate::TebibytePerSecond,
1726  Conversions<Unit::MemoryRate,
1727  Unit::MemoryRate::TebibytePerSecond>::ToStandard<NumericType> },
1728  {Unit::MemoryRate::PetabitPerSecond,
1729  Conversions<Unit::MemoryRate,
1730  Unit::MemoryRate::PetabitPerSecond>::ToStandard<NumericType> },
1731  {Unit::MemoryRate::PebibitPerSecond,
1732  Conversions<Unit::MemoryRate,
1733  Unit::MemoryRate::PebibitPerSecond>::ToStandard<NumericType> },
1734  {Unit::MemoryRate::PetabytePerSecond,
1735  Conversions<Unit::MemoryRate,
1736  Unit::MemoryRate::PetabytePerSecond>::ToStandard<NumericType> },
1737  {Unit::MemoryRate::PebibytePerSecond,
1738  Conversions<Unit::MemoryRate,
1739  Unit::MemoryRate::PebibytePerSecond>::ToStandard<NumericType> },
1740  {Unit::MemoryRate::BitPerMinute,
1741  Conversions<Unit::MemoryRate, Unit::MemoryRate::BitPerMinute>::ToStandard<NumericType> },
1742  {Unit::MemoryRate::BytePerMinute,
1743  Conversions<Unit::MemoryRate, Unit::MemoryRate::BytePerMinute>::ToStandard<NumericType> },
1744  {Unit::MemoryRate::KilobitPerMinute,
1745  Conversions<Unit::MemoryRate,
1746  Unit::MemoryRate::KilobitPerMinute>::ToStandard<NumericType> },
1747  {Unit::MemoryRate::KibibitPerMinute,
1748  Conversions<Unit::MemoryRate,
1749  Unit::MemoryRate::KibibitPerMinute>::ToStandard<NumericType> },
1750  {Unit::MemoryRate::KilobytePerMinute,
1751  Conversions<Unit::MemoryRate,
1752  Unit::MemoryRate::KilobytePerMinute>::ToStandard<NumericType> },
1753  {Unit::MemoryRate::KibibytePerMinute,
1754  Conversions<Unit::MemoryRate,
1755  Unit::MemoryRate::KibibytePerMinute>::ToStandard<NumericType> },
1756  {Unit::MemoryRate::MegabitPerMinute,
1757  Conversions<Unit::MemoryRate,
1758  Unit::MemoryRate::MegabitPerMinute>::ToStandard<NumericType> },
1759  {Unit::MemoryRate::MebibitPerMinute,
1760  Conversions<Unit::MemoryRate,
1761  Unit::MemoryRate::MebibitPerMinute>::ToStandard<NumericType> },
1762  {Unit::MemoryRate::MegabytePerMinute,
1763  Conversions<Unit::MemoryRate,
1764  Unit::MemoryRate::MegabytePerMinute>::ToStandard<NumericType> },
1765  {Unit::MemoryRate::MebibytePerMinute,
1766  Conversions<Unit::MemoryRate,
1767  Unit::MemoryRate::MebibytePerMinute>::ToStandard<NumericType> },
1768  {Unit::MemoryRate::GigabitPerMinute,
1769  Conversions<Unit::MemoryRate,
1770  Unit::MemoryRate::GigabitPerMinute>::ToStandard<NumericType> },
1771  {Unit::MemoryRate::GibibitPerMinute,
1772  Conversions<Unit::MemoryRate,
1773  Unit::MemoryRate::GibibitPerMinute>::ToStandard<NumericType> },
1774  {Unit::MemoryRate::GigabytePerMinute,
1775  Conversions<Unit::MemoryRate,
1776  Unit::MemoryRate::GigabytePerMinute>::ToStandard<NumericType> },
1777  {Unit::MemoryRate::GibibytePerMinute,
1778  Conversions<Unit::MemoryRate,
1779  Unit::MemoryRate::GibibytePerMinute>::ToStandard<NumericType> },
1780  {Unit::MemoryRate::TerabitPerMinute,
1781  Conversions<Unit::MemoryRate,
1782  Unit::MemoryRate::TerabitPerMinute>::ToStandard<NumericType> },
1783  {Unit::MemoryRate::TebibitPerMinute,
1784  Conversions<Unit::MemoryRate,
1785  Unit::MemoryRate::TebibitPerMinute>::ToStandard<NumericType> },
1786  {Unit::MemoryRate::TerabytePerMinute,
1787  Conversions<Unit::MemoryRate,
1788  Unit::MemoryRate::TerabytePerMinute>::ToStandard<NumericType> },
1789  {Unit::MemoryRate::TebibytePerMinute,
1790  Conversions<Unit::MemoryRate,
1791  Unit::MemoryRate::TebibytePerMinute>::ToStandard<NumericType> },
1792  {Unit::MemoryRate::PetabitPerMinute,
1793  Conversions<Unit::MemoryRate,
1794  Unit::MemoryRate::PetabitPerMinute>::ToStandard<NumericType> },
1795  {Unit::MemoryRate::PebibitPerMinute,
1796  Conversions<Unit::MemoryRate,
1797  Unit::MemoryRate::PebibitPerMinute>::ToStandard<NumericType> },
1798  {Unit::MemoryRate::PetabytePerMinute,
1799  Conversions<Unit::MemoryRate,
1800  Unit::MemoryRate::PetabytePerMinute>::ToStandard<NumericType> },
1801  {Unit::MemoryRate::PebibytePerMinute,
1802  Conversions<Unit::MemoryRate,
1803  Unit::MemoryRate::PebibytePerMinute>::ToStandard<NumericType> },
1804  {Unit::MemoryRate::BitPerHour,
1805  Conversions<Unit::MemoryRate, Unit::MemoryRate::BitPerHour>::ToStandard<NumericType> },
1806  {Unit::MemoryRate::BytePerHour,
1807  Conversions<Unit::MemoryRate, Unit::MemoryRate::BytePerHour>::ToStandard<NumericType> },
1808  {Unit::MemoryRate::KilobitPerHour,
1809  Conversions<Unit::MemoryRate, Unit::MemoryRate::KilobitPerHour>::ToStandard<NumericType> },
1810  {Unit::MemoryRate::KibibitPerHour,
1811  Conversions<Unit::MemoryRate, Unit::MemoryRate::KibibitPerHour>::ToStandard<NumericType> },
1812  {Unit::MemoryRate::KilobytePerHour,
1813  Conversions<Unit::MemoryRate, Unit::MemoryRate::KilobytePerHour>::ToStandard<NumericType>},
1814  {Unit::MemoryRate::KibibytePerHour,
1815  Conversions<Unit::MemoryRate, Unit::MemoryRate::KibibytePerHour>::ToStandard<NumericType>},
1816  {Unit::MemoryRate::MegabitPerHour,
1817  Conversions<Unit::MemoryRate, Unit::MemoryRate::MegabitPerHour>::ToStandard<NumericType> },
1818  {Unit::MemoryRate::MebibitPerHour,
1819  Conversions<Unit::MemoryRate, Unit::MemoryRate::MebibitPerHour>::ToStandard<NumericType> },
1820  {Unit::MemoryRate::MegabytePerHour,
1821  Conversions<Unit::MemoryRate, Unit::MemoryRate::MegabytePerHour>::ToStandard<NumericType>},
1822  {Unit::MemoryRate::MebibytePerHour,
1823  Conversions<Unit::MemoryRate, Unit::MemoryRate::MebibytePerHour>::ToStandard<NumericType>},
1824  {Unit::MemoryRate::GigabitPerHour,
1825  Conversions<Unit::MemoryRate, Unit::MemoryRate::GigabitPerHour>::ToStandard<NumericType> },
1826  {Unit::MemoryRate::GibibitPerHour,
1827  Conversions<Unit::MemoryRate, Unit::MemoryRate::GibibitPerHour>::ToStandard<NumericType> },
1828  {Unit::MemoryRate::GigabytePerHour,
1829  Conversions<Unit::MemoryRate, Unit::MemoryRate::GigabytePerHour>::ToStandard<NumericType>},
1830  {Unit::MemoryRate::GibibytePerHour,
1831  Conversions<Unit::MemoryRate, Unit::MemoryRate::GibibytePerHour>::ToStandard<NumericType>},
1832  {Unit::MemoryRate::TerabitPerHour,
1833  Conversions<Unit::MemoryRate, Unit::MemoryRate::TerabitPerHour>::ToStandard<NumericType> },
1834  {Unit::MemoryRate::TebibitPerHour,
1835  Conversions<Unit::MemoryRate, Unit::MemoryRate::TebibitPerHour>::ToStandard<NumericType> },
1836  {Unit::MemoryRate::TerabytePerHour,
1837  Conversions<Unit::MemoryRate, Unit::MemoryRate::TerabytePerHour>::ToStandard<NumericType>},
1838  {Unit::MemoryRate::TebibytePerHour,
1839  Conversions<Unit::MemoryRate, Unit::MemoryRate::TebibytePerHour>::ToStandard<NumericType>},
1840  {Unit::MemoryRate::PetabitPerHour,
1841  Conversions<Unit::MemoryRate, Unit::MemoryRate::PetabitPerHour>::ToStandard<NumericType> },
1842  {Unit::MemoryRate::PebibitPerHour,
1843  Conversions<Unit::MemoryRate, Unit::MemoryRate::PebibitPerHour>::ToStandard<NumericType> },
1844  {Unit::MemoryRate::PetabytePerHour,
1845  Conversions<Unit::MemoryRate, Unit::MemoryRate::PetabytePerHour>::ToStandard<NumericType>},
1846  {Unit::MemoryRate::PebibytePerHour,
1847  Conversions<Unit::MemoryRate, Unit::MemoryRate::PebibytePerHour>::ToStandard<NumericType>},
1848 };
1849 
1850 } // namespace Internal
1851 
1852 } // namespace PhQ
1853 
1854 #endif // PHQ_UNIT_MEMORY_RATE_HPP
PhQ::Unit::ElectricCurrent
ElectricCurrent
Electric current units.
Definition: ElectricCurrent.hpp:53
PhQ::Unit::Mass
Mass
Mass units.
Definition: Mass.hpp:53
PhQ::Unit::Length
Length
Length units.
Definition: Length.hpp:53
PhQ::Unit::SubstanceAmount
SubstanceAmount
Amount of substance units.
Definition: SubstanceAmount.hpp:53
PhQ::Unit::MemoryRate
MemoryRate
Computer memory rate unit. Can represent the time rate of change of memory or a memory transfer speed...
Definition: MemoryRate.hpp:54
PhQ::Unit::MemoryRate::PetabitPerSecond
@ PetabitPerSecond
Petabit per second (Pb/s) memory rate unit.
PhQ::Unit::MemoryRate::KibibitPerMinute
@ KibibitPerMinute
Kibibit per minute (kib/min) memory rate unit.
PhQ::Unit::MemoryRate::TerabytePerSecond
@ TerabytePerSecond
Terabyte per second (TB/s) memory rate unit.
PhQ::Unit::MemoryRate::GigabytePerMinute
@ GigabytePerMinute
Gigabyte per minute (GB/min) memory rate unit.
PhQ::Unit::MemoryRate::GibibytePerMinute
@ GibibytePerMinute
Gibibyte per minute (GiB/min) memory rate unit.
PhQ::Unit::MemoryRate::MebibytePerHour
@ MebibytePerHour
Mebibyte per hour (MiB/hr) memory rate unit.
PhQ::Unit::MemoryRate::BytePerMinute
@ BytePerMinute
Byte per minute (B/min) memory rate unit.
PhQ::Unit::MemoryRate::TerabytePerMinute
@ TerabytePerMinute
Terabyte per minute (TB/min) memory rate unit.
PhQ::Unit::MemoryRate::GigabytePerHour
@ GigabytePerHour
Gigabyte per hour (GB/hr) memory rate unit.
PhQ::Unit::MemoryRate::TebibytePerMinute
@ TebibytePerMinute
Tebibyte per minute (TiB/min) memory rate unit.
PhQ::Unit::MemoryRate::KilobitPerHour
@ KilobitPerHour
Kilobit per hour (kb/hr) memory rate unit.
PhQ::Unit::MemoryRate::PebibytePerHour
@ PebibytePerHour
Pebibyte per hour (PiB/hr) memory rate unit.
PhQ::Unit::MemoryRate::PebibytePerSecond
@ PebibytePerSecond
Pebibyte per second (PiB/s) memory rate unit.
PhQ::Unit::MemoryRate::GibibitPerHour
@ GibibitPerHour
Gibibit per hour (Gib/hr) memory rate unit.
PhQ::Unit::MemoryRate::TebibytePerHour
@ TebibytePerHour
Tebibyte per hour (TiB/hr) memory rate unit.
PhQ::Unit::MemoryRate::KilobytePerMinute
@ KilobytePerMinute
Kilobyte per minute (kB/min) memory rate unit.
PhQ::Unit::MemoryRate::MebibitPerMinute
@ MebibitPerMinute
Mebibit per minute (Mib/min) memory rate unit.
PhQ::Unit::MemoryRate::KilobitPerMinute
@ KilobitPerMinute
Kilobit per minute (kb/min) memory rate unit.
PhQ::Unit::MemoryRate::BitPerHour
@ BitPerHour
Bit per hour (b/hr) memory rate unit.
PhQ::Unit::MemoryRate::KibibitPerHour
@ KibibitPerHour
Kibibit per hour (kib/hr) memory rate unit.
PhQ::Unit::MemoryRate::TerabitPerSecond
@ TerabitPerSecond
Terabit per second (Tb/s) memory rate unit.
PhQ::Unit::MemoryRate::PetabytePerSecond
@ PetabytePerSecond
Petabyte per second (PB/s) memory rate unit.
PhQ::Unit::MemoryRate::PetabitPerMinute
@ PetabitPerMinute
Petabit per minute (Pb/min) memory rate unit.
PhQ::Unit::MemoryRate::MegabytePerMinute
@ MegabytePerMinute
Megabyte per minute (MB/min) memory rate unit.
PhQ::Unit::MemoryRate::TerabitPerHour
@ TerabitPerHour
Terabit per hour (Tb/hr) memory rate unit.
PhQ::Unit::MemoryRate::BitPerSecond
@ BitPerSecond
Bit per second (b/s) memory rate unit.
PhQ::Unit::MemoryRate::MebibytePerSecond
@ MebibytePerSecond
Mebibyte per second (MiB/s) memory rate unit.
PhQ::Unit::MemoryRate::MegabitPerHour
@ MegabitPerHour
Megabit per hour (Mb/hr) memory rate unit.
PhQ::Unit::MemoryRate::PetabytePerMinute
@ PetabytePerMinute
Petabyte per minute (PB/min) memory rate unit.
PhQ::Unit::MemoryRate::TebibitPerMinute
@ TebibitPerMinute
Tebibit per minute (Tib/min) memory rate unit.
PhQ::Unit::MemoryRate::GigabitPerSecond
@ GigabitPerSecond
Gigabit per second (Gb/s) memory rate unit.
PhQ::Unit::MemoryRate::GibibytePerHour
@ GibibytePerHour
Gibibyte per hour (GiB/hr) memory rate unit.
PhQ::Unit::MemoryRate::MebibytePerMinute
@ MebibytePerMinute
Mebibyte per minute (MiB/min) memory rate unit.
PhQ::Unit::MemoryRate::MebibitPerSecond
@ MebibitPerSecond
Mebibit per second (Mib/s) memory rate unit.
PhQ::Unit::MemoryRate::KibibytePerSecond
@ KibibytePerSecond
Kibibyte per second (kiB/s) memory rate unit.
PhQ::Unit::MemoryRate::KibibytePerHour
@ KibibytePerHour
Kibibyte per hour (kiB/hr) memory rate unit.
PhQ::Unit::MemoryRate::GibibitPerMinute
@ GibibitPerMinute
Gibibit per minute (Gib/min) memory rate unit.
PhQ::Unit::MemoryRate::GibibytePerSecond
@ GibibytePerSecond
Gibibyte per second (GiB/s) memory rate unit.
PhQ::Unit::MemoryRate::PetabitPerHour
@ PetabitPerHour
Petabit per hour (Pb/hr) memory rate unit.
PhQ::Unit::MemoryRate::PebibitPerMinute
@ PebibitPerMinute
Pebibit per minute (Pib/min) memory rate unit.
PhQ::Unit::MemoryRate::BytePerSecond
@ BytePerSecond
Byte per second (B/s) memory rate unit.
PhQ::Unit::MemoryRate::PebibitPerSecond
@ PebibitPerSecond
Pebibit per second (Pib/s) memory rate unit.
PhQ::Unit::MemoryRate::TebibitPerSecond
@ TebibitPerSecond
Tebibit per second (Tib/s) memory rate unit.
PhQ::Unit::MemoryRate::MegabytePerSecond
@ MegabytePerSecond
Megabyte per second (MB/s) memory rate unit.
PhQ::Unit::MemoryRate::MegabytePerHour
@ MegabytePerHour
Megabyte per hour (MB/hr) memory rate unit.
PhQ::Unit::MemoryRate::BytePerHour
@ BytePerHour
Byte per hour (B/hr) memory rate unit.
PhQ::Unit::MemoryRate::PebibytePerMinute
@ PebibytePerMinute
Pebibyte per minute (PiB/min) memory rate unit.
PhQ::Unit::MemoryRate::TerabitPerMinute
@ TerabitPerMinute
Terabit per minute (Tb/min) memory rate unit.
PhQ::Unit::MemoryRate::KibibytePerMinute
@ KibibytePerMinute
Kibibyte per minute (kiB/min) memory rate unit.
PhQ::Unit::MemoryRate::MebibitPerHour
@ MebibitPerHour
Mebibit per hour (Mib/hr) memory rate unit.
PhQ::Unit::MemoryRate::KibibitPerSecond
@ KibibitPerSecond
Kibibit per second (kib/s) memory rate unit.
PhQ::Unit::MemoryRate::MegabitPerSecond
@ MegabitPerSecond
Megabit per second (Mb/s) memory rate unit.
PhQ::Unit::MemoryRate::TebibitPerHour
@ TebibitPerHour
Tebibit per hour (Tib/hr) memory rate unit.
PhQ::Unit::MemoryRate::TerabytePerHour
@ TerabytePerHour
Terabyte per hour (TB/hr) memory rate unit.
PhQ::Unit::MemoryRate::GigabytePerSecond
@ GigabytePerSecond
Gigabyte per second (GB/s) memory rate unit.
PhQ::Unit::MemoryRate::GigabitPerMinute
@ GigabitPerMinute
Gigabit per minute (Gb/min) memory rate unit.
PhQ::Unit::MemoryRate::KilobytePerSecond
@ KilobytePerSecond
Kilobyte per second (kB/s) memory rate unit.
PhQ::Unit::MemoryRate::KilobytePerHour
@ KilobytePerHour
Kilobyte per hour (kB/hr) memory rate unit.
PhQ::Unit::MemoryRate::GibibitPerSecond
@ GibibitPerSecond
Gibibit per second (Gib/s) memory rate unit.
PhQ::Unit::MemoryRate::GigabitPerHour
@ GigabitPerHour
Gigabit per hour (Gb/hr) memory rate unit.
PhQ::Unit::MemoryRate::KilobitPerSecond
@ KilobitPerSecond
Kilobit per second (kb/s) memory rate unit.
PhQ::Unit::MemoryRate::PetabytePerHour
@ PetabytePerHour
Petabyte per hour (PB/hr) memory rate unit.
PhQ::Unit::MemoryRate::MegabitPerMinute
@ MegabitPerMinute
Megabit per minute (Mb/min) memory rate unit.
PhQ::Unit::MemoryRate::BitPerMinute
@ BitPerMinute
Bit per minute (b/min) memory rate unit.
PhQ::Unit::MemoryRate::TebibytePerSecond
@ TebibytePerSecond
Tebibyte per second (TiB/s) memory rate unit.
PhQ::Unit::MemoryRate::PebibitPerHour
@ PebibitPerHour
Pebibit per hour (Pib/hr) memory rate unit.
PhQ::Unit::Temperature
Temperature
Temperature units. Not to be confused with temperature difference units. For example,...
Definition: Temperature.hpp:55
PhQ::Unit::Time
Time
Time units.
Definition: Time.hpp:53
PhQ
Namespace that encompasses all of the Physical Quantities library's content.
Definition: Acceleration.hpp:44
PhQ::UnitSystem::FootPoundSecondRankine
@ FootPoundSecondRankine
Foot-pound-second-rankine (ft·lbf·s·°R) system.
PhQ::UnitSystem::MillimetreGramSecondKelvin
@ MillimetreGramSecondKelvin
Millimetre-gram-second-kelvin (mm·g·s·K) system.
PhQ::UnitSystem::MetreKilogramSecondKelvin
@ MetreKilogramSecondKelvin
Metre-kilogram-second-kelvin (m·kg·s·K) system.
PhQ::UnitSystem::InchPoundSecondRankine
@ InchPoundSecondRankine
Inch-pound-second-rankine (in·lbf·s·°R) system.
PhQ::Abbreviation
std::string_view Abbreviation(const Enumeration enumeration)
Returns the abbreviation of a given enumeration value. For example, PhQ::Abbreviation(PhQ::Unit::Time...
Definition: Base.hpp:89
PhQ::operator<<
std::ostream & operator<<(std::ostream &stream, const Acceleration< NumericType > &acceleration)
Definition: Acceleration.hpp:265
Physical Quantities (PhQ): Git Repository | Documentation