Physical Quantities  v1.0.0
C++ library of physical quantities, physical models, and units of measure for scientific computing. https://github.com/acodcha/phq
Loading...
Searching...
No Matches
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
48namespace PhQ {
49
50namespace Unit {
51
52/// \brief Computer memory rate unit. Can represent the time rate of change of memory or a memory
53/// transfer speed.
54enum 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).
257template <>
258inline constexpr const Unit::MemoryRate Standard<Unit::MemoryRate>{Unit::MemoryRate::BitPerSecond};
259
260/// \brief Physical dimension set of computer memory rate units.
261template <>
262inline 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
268inline std::ostream& operator<<(std::ostream& stream, const Unit::MemoryRate unit) {
269 stream << Abbreviation(unit);
270 return stream;
271}
272
273namespace Internal {
274
275template <>
276inline 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
283template <>
284inline const std::map<Unit::MemoryRate, UnitSystem> RelatedUnitSystems<Unit::MemoryRate>{};
285
286template <>
287inline 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
356template <>
357inline 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
426template <>
427template <typename NumericType>
428inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::BitPerSecond>::FromStandard(
429 NumericType& /*value*/) noexcept {}
430
431template <>
432template <typename NumericType>
433inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::BitPerSecond>::ToStandard(
434 NumericType& /*value*/) noexcept {}
435
436template <>
437template <typename NumericType>
438inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::BytePerSecond>::FromStandard(
439 NumericType& value) noexcept {
440 value *= static_cast<NumericType>(0.125L);
441}
442
443template <>
444template <typename NumericType>
445inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::BytePerSecond>::ToStandard(
446 NumericType& value) noexcept {
447 value *= static_cast<NumericType>(8.0L);
448}
449
450template <>
451template <typename NumericType>
452inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KilobitPerSecond>::
453 FromStandard(NumericType& value) noexcept {
454 value *= static_cast<NumericType>(0.001L);
455}
456
457template <>
458template <typename NumericType>
459inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KilobitPerSecond>::ToStandard(
460 NumericType& value) noexcept {
461 value *= static_cast<NumericType>(1000.0L);
462}
463
464template <>
465template <typename NumericType>
466inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KibibitPerSecond>::
467 FromStandard(NumericType& value) noexcept {
468 value /= static_cast<NumericType>(1024.0L);
469}
470
471template <>
472template <typename NumericType>
473inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KibibitPerSecond>::ToStandard(
474 NumericType& value) noexcept {
475 value *= static_cast<NumericType>(1024.0L);
476}
477
478template <>
479template <typename NumericType>
480inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KilobytePerSecond>::
481 FromStandard(NumericType& value) noexcept {
482 value /= static_cast<NumericType>(8000.0L);
483}
484
485template <>
486template <typename NumericType>
487inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KilobytePerSecond>::ToStandard(
488 NumericType& value) noexcept {
489 value *= static_cast<NumericType>(8000.0L);
490}
491
492template <>
493template <typename NumericType>
494inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KibibytePerSecond>::
495 FromStandard(NumericType& value) noexcept {
496 value /= (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L));
497}
498
499template <>
500template <typename NumericType>
501inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KibibytePerSecond>::ToStandard(
502 NumericType& value) noexcept {
503 value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L);
504}
505
506template <>
507template <typename NumericType>
508inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MegabitPerSecond>::
509 FromStandard(NumericType& value) noexcept {
510 value *= static_cast<NumericType>(1.0E-6L);
511}
512
513template <>
514template <typename NumericType>
515inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MegabitPerSecond>::ToStandard(
516 NumericType& value) noexcept {
517 value *= static_cast<NumericType>(1000000.0L);
518}
519
520template <>
521template <typename NumericType>
522inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MebibitPerSecond>::
523 FromStandard(NumericType& value) noexcept {
524 value /= (static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L));
525}
526
527template <>
528template <typename NumericType>
529inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MebibitPerSecond>::ToStandard(
530 NumericType& value) noexcept {
531 value *= static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L);
532}
533
534template <>
535template <typename NumericType>
536inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MegabytePerSecond>::
537 FromStandard(NumericType& value) noexcept {
538 value /= static_cast<NumericType>(8000000.0L);
539}
540
541template <>
542template <typename NumericType>
543inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MegabytePerSecond>::ToStandard(
544 NumericType& value) noexcept {
545 value *= static_cast<NumericType>(8000000.0L);
546}
547
548template <>
549template <typename NumericType>
550inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MebibytePerSecond>::
551 FromStandard(NumericType& value) noexcept {
552 value /= (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
553 * static_cast<NumericType>(1024.0L));
554}
555
556template <>
557template <typename NumericType>
558inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MebibytePerSecond>::ToStandard(
559 NumericType& value) noexcept {
560 value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
561 * static_cast<NumericType>(1024.0L);
562}
563
564template <>
565template <typename NumericType>
566inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GigabitPerSecond>::
567 FromStandard(NumericType& value) noexcept {
568 value *= static_cast<NumericType>(1.0E-9L);
569}
570
571template <>
572template <typename NumericType>
573inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GigabitPerSecond>::ToStandard(
574 NumericType& value) noexcept {
575 value *= static_cast<NumericType>(1.0E9L);
576}
577
578template <>
579template <typename NumericType>
580inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GibibitPerSecond>::
581 FromStandard(NumericType& value) noexcept {
582 value /= (static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
583 * static_cast<NumericType>(1024.0L));
584}
585
586template <>
587template <typename NumericType>
588inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GibibitPerSecond>::ToStandard(
589 NumericType& value) noexcept {
590 value *= static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
591 * static_cast<NumericType>(1024.0L);
592}
593
594template <>
595template <typename NumericType>
596inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GigabytePerSecond>::
597 FromStandard(NumericType& value) noexcept {
598 value /= static_cast<NumericType>(8.0E9L);
599}
600
601template <>
602template <typename NumericType>
603inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GigabytePerSecond>::ToStandard(
604 NumericType& value) noexcept {
605 value *= static_cast<NumericType>(8.0E9L);
606}
607
608template <>
609template <typename NumericType>
610inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GibibytePerSecond>::
611 FromStandard(NumericType& value) noexcept {
612 value /= (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
613 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L));
614}
615
616template <>
617template <typename NumericType>
618inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GibibytePerSecond>::ToStandard(
619 NumericType& value) noexcept {
620 value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
621 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L);
622}
623
624template <>
625template <typename NumericType>
626inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TerabitPerSecond>::
627 FromStandard(NumericType& value) noexcept {
628 value *= static_cast<NumericType>(1.0E-12L);
629}
630
631template <>
632template <typename NumericType>
633inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TerabitPerSecond>::ToStandard(
634 NumericType& value) noexcept {
635 value *= static_cast<NumericType>(1.0E12L);
636}
637
638template <>
639template <typename NumericType>
640inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TebibitPerSecond>::
641 FromStandard(NumericType& value) noexcept {
642 value /= (static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
643 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L));
644}
645
646template <>
647template <typename NumericType>
648inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TebibitPerSecond>::ToStandard(
649 NumericType& value) noexcept {
650 value *= static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
651 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L);
652}
653
654template <>
655template <typename NumericType>
656inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TerabytePerSecond>::
657 FromStandard(NumericType& value) noexcept {
658 value /= static_cast<NumericType>(8.0E12L);
659}
660
661template <>
662template <typename NumericType>
663inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TerabytePerSecond>::ToStandard(
664 NumericType& value) noexcept {
665 value *= static_cast<NumericType>(8.0E12L);
666}
667
668template <>
669template <typename NumericType>
670inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TebibytePerSecond>::
671 FromStandard(NumericType& value) noexcept {
672 value /= (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
673 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
674 * static_cast<NumericType>(1024.0L));
675}
676
677template <>
678template <typename NumericType>
679inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TebibytePerSecond>::ToStandard(
680 NumericType& value) noexcept {
681 value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
682 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
683 * static_cast<NumericType>(1024.0L);
684}
685
686template <>
687template <typename NumericType>
688inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PetabitPerSecond>::
689 FromStandard(NumericType& value) noexcept {
690 value *= static_cast<NumericType>(1.0E-15L);
691}
692
693template <>
694template <typename NumericType>
695inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PetabitPerSecond>::ToStandard(
696 NumericType& value) noexcept {
697 value *= static_cast<NumericType>(1.0E15L);
698}
699
700template <>
701template <typename NumericType>
702inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PebibitPerSecond>::
703 FromStandard(NumericType& value) noexcept {
704 value /= (static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
705 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
706 * static_cast<NumericType>(1024.0L));
707}
708
709template <>
710template <typename NumericType>
711inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PebibitPerSecond>::ToStandard(
712 NumericType& value) noexcept {
713 value *= static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
714 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
715 * static_cast<NumericType>(1024.0L);
716}
717
718template <>
719template <typename NumericType>
720inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PetabytePerSecond>::
721 FromStandard(NumericType& value) noexcept {
722 value /= static_cast<NumericType>(8.0E15L);
723}
724
725template <>
726template <typename NumericType>
727inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PetabytePerSecond>::ToStandard(
728 NumericType& value) noexcept {
729 value *= static_cast<NumericType>(8.0E15L);
730}
731
732template <>
733template <typename NumericType>
734inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PebibytePerSecond>::
735 FromStandard(NumericType& value) noexcept {
736 value /= (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
737 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
738 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L));
739}
740
741template <>
742template <typename NumericType>
743inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PebibytePerSecond>::ToStandard(
744 NumericType& value) noexcept {
745 value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
746 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
747 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L);
748}
749
750template <>
751template <typename NumericType>
752inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::BitPerMinute>::FromStandard(
753 NumericType& value) noexcept {
754 value *= static_cast<NumericType>(60.0L);
755}
756
757template <>
758template <typename NumericType>
759inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::BitPerMinute>::ToStandard(
760 NumericType& value) noexcept {
761 value /= static_cast<NumericType>(60.0L);
762}
763
764template <>
765template <typename NumericType>
766inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::BytePerMinute>::FromStandard(
767 NumericType& value) noexcept {
768 value *= static_cast<NumericType>(60.0L) / static_cast<NumericType>(8.0L);
769}
770
771template <>
772template <typename NumericType>
773inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::BytePerMinute>::ToStandard(
774 NumericType& value) noexcept {
775 value *= static_cast<NumericType>(8.0L) / static_cast<NumericType>(60.0L);
776}
777
778template <>
779template <typename NumericType>
780inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KilobitPerMinute>::
781 FromStandard(NumericType& value) noexcept {
782 value *= static_cast<NumericType>(60.0L) / static_cast<NumericType>(1000.0L);
783}
784
785template <>
786template <typename NumericType>
787inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KilobitPerMinute>::ToStandard(
788 NumericType& value) noexcept {
789 value *= static_cast<NumericType>(1000.0L) / static_cast<NumericType>(60.0L);
790}
791
792template <>
793template <typename NumericType>
794inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KibibitPerMinute>::
795 FromStandard(NumericType& value) noexcept {
796 value *= static_cast<NumericType>(60.0L) / static_cast<NumericType>(1024.0L);
797}
798
799template <>
800template <typename NumericType>
801inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KibibitPerMinute>::ToStandard(
802 NumericType& value) noexcept {
803 value *= static_cast<NumericType>(1024.0L) / static_cast<NumericType>(60.0L);
804}
805
806template <>
807template <typename NumericType>
808inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KilobytePerMinute>::
809 FromStandard(NumericType& value) noexcept {
810 value *= static_cast<NumericType>(60.0L) / static_cast<NumericType>(8000.0L);
811}
812
813template <>
814template <typename NumericType>
815inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KilobytePerMinute>::ToStandard(
816 NumericType& value) noexcept {
817 value *= static_cast<NumericType>(8000.0L) / static_cast<NumericType>(60.0L);
818}
819
820template <>
821template <typename NumericType>
822inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KibibytePerMinute>::
823 FromStandard(NumericType& value) noexcept {
824 value *= static_cast<NumericType>(60.0L)
825 / (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L));
826}
827
828template <>
829template <typename NumericType>
830inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KibibytePerMinute>::ToStandard(
831 NumericType& value) noexcept {
832 value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
833 / static_cast<NumericType>(60.0L);
834}
835
836template <>
837template <typename NumericType>
838inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MegabitPerMinute>::
839 FromStandard(NumericType& value) noexcept {
840 value *= static_cast<NumericType>(60.0L) / static_cast<NumericType>(1000000.0L);
841}
842
843template <>
844template <typename NumericType>
845inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MegabitPerMinute>::ToStandard(
846 NumericType& value) noexcept {
847 value *= static_cast<NumericType>(1000000.0L) / static_cast<NumericType>(60.0L);
848}
849
850template <>
851template <typename NumericType>
852inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MebibitPerMinute>::
853 FromStandard(NumericType& value) noexcept {
854 value *= static_cast<NumericType>(60.0L)
855 / (static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L));
856}
857
858template <>
859template <typename NumericType>
860inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MebibitPerMinute>::ToStandard(
861 NumericType& value) noexcept {
862 value *= static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
863 / static_cast<NumericType>(60.0L);
864}
865
866template <>
867template <typename NumericType>
868inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MegabytePerMinute>::
869 FromStandard(NumericType& value) noexcept {
870 value *= static_cast<NumericType>(60.0L) / static_cast<NumericType>(8000000.0L);
871}
872
873template <>
874template <typename NumericType>
875inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MegabytePerMinute>::ToStandard(
876 NumericType& value) noexcept {
877 value *= static_cast<NumericType>(8000000.0L) / static_cast<NumericType>(60.0L);
878}
879
880template <>
881template <typename NumericType>
882inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MebibytePerMinute>::
883 FromStandard(NumericType& value) noexcept {
884 value *= static_cast<NumericType>(60.0L)
885 / (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
886 * static_cast<NumericType>(1024.0L));
887}
888
889template <>
890template <typename NumericType>
891inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MebibytePerMinute>::ToStandard(
892 NumericType& value) noexcept {
893 value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
894 * static_cast<NumericType>(1024.0L) / static_cast<NumericType>(60.0L);
895}
896
897template <>
898template <typename NumericType>
899inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GigabitPerMinute>::
900 FromStandard(NumericType& value) noexcept {
901 value *= static_cast<NumericType>(60.0L) / static_cast<NumericType>(1.0E9L);
902}
903
904template <>
905template <typename NumericType>
906inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GigabitPerMinute>::ToStandard(
907 NumericType& value) noexcept {
908 value *= static_cast<NumericType>(1.0E9L) / static_cast<NumericType>(60.0L);
909}
910
911template <>
912template <typename NumericType>
913inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GibibitPerMinute>::
914 FromStandard(NumericType& value) noexcept {
915 value *= static_cast<NumericType>(60.0L)
916 / (static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
917 * static_cast<NumericType>(1024.0L));
918}
919
920template <>
921template <typename NumericType>
922inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GibibitPerMinute>::ToStandard(
923 NumericType& value) noexcept {
924 value *= static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
925 * static_cast<NumericType>(1024.0L) / static_cast<NumericType>(60.0L);
926}
927
928template <>
929template <typename NumericType>
930inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GigabytePerMinute>::
931 FromStandard(NumericType& value) noexcept {
932 value *= static_cast<NumericType>(60.0L) / (static_cast<NumericType>(8.0E9L));
933}
934
935template <>
936template <typename NumericType>
937inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GigabytePerMinute>::ToStandard(
938 NumericType& value) noexcept {
939 value *= static_cast<NumericType>(8.0E9L) / static_cast<NumericType>(60.0L);
940}
941
942template <>
943template <typename NumericType>
944inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GibibytePerMinute>::
945 FromStandard(NumericType& value) noexcept {
946 value *= static_cast<NumericType>(60.0L)
947 / (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
948 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L));
949}
950
951template <>
952template <typename NumericType>
953inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GibibytePerMinute>::ToStandard(
954 NumericType& value) noexcept {
955 value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
956 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
957 / static_cast<NumericType>(60.0L);
958}
959
960template <>
961template <typename NumericType>
962inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TerabitPerMinute>::
963 FromStandard(NumericType& value) noexcept {
964 value *= static_cast<NumericType>(60.0L) / static_cast<NumericType>(1.0E12L);
965}
966
967template <>
968template <typename NumericType>
969inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TerabitPerMinute>::ToStandard(
970 NumericType& value) noexcept {
971 value *= static_cast<NumericType>(1.0E12L) / static_cast<NumericType>(60.0L);
972}
973
974template <>
975template <typename NumericType>
976inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TebibitPerMinute>::
977 FromStandard(NumericType& value) noexcept {
978 value *= static_cast<NumericType>(60.0L)
979 / (static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
980 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L));
981}
982
983template <>
984template <typename NumericType>
985inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TebibitPerMinute>::ToStandard(
986 NumericType& value) noexcept {
987 value *= static_cast<NumericType>(1024.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
992template <>
993template <typename NumericType>
994inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TerabytePerMinute>::
995 FromStandard(NumericType& value) noexcept {
996 value *= static_cast<NumericType>(60.0L) / static_cast<NumericType>(8.0E12L);
997}
998
999template <>
1000template <typename NumericType>
1001inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TerabytePerMinute>::ToStandard(
1002 NumericType& value) noexcept {
1003 value *= static_cast<NumericType>(8.0E12L) / static_cast<NumericType>(60.0L);
1004}
1005
1006template <>
1007template <typename NumericType>
1008inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TebibytePerMinute>::
1009 FromStandard(NumericType& value) noexcept {
1010 value *= static_cast<NumericType>(60.0L)
1011 / (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1012 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1013 * static_cast<NumericType>(1024.0L));
1014}
1015
1016template <>
1017template <typename NumericType>
1018inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TebibytePerMinute>::ToStandard(
1019 NumericType& value) noexcept {
1020 value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1021 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1022 * static_cast<NumericType>(1024.0L) / static_cast<NumericType>(60.0L);
1023}
1024
1025template <>
1026template <typename NumericType>
1027inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PetabitPerMinute>::
1028 FromStandard(NumericType& value) noexcept {
1029 value *= static_cast<NumericType>(60.0L) / static_cast<NumericType>(1.0E15L);
1030}
1031
1032template <>
1033template <typename NumericType>
1034inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PetabitPerMinute>::ToStandard(
1035 NumericType& value) noexcept {
1036 value *= static_cast<NumericType>(1.0E15L) / static_cast<NumericType>(60.0L);
1037}
1038
1039template <>
1040template <typename NumericType>
1041inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PebibitPerMinute>::
1042 FromStandard(NumericType& value) noexcept {
1043 value *= static_cast<NumericType>(60.0L)
1044 / (static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1045 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1046 * static_cast<NumericType>(1024.0L));
1047}
1048
1049template <>
1050template <typename NumericType>
1051inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PebibitPerMinute>::ToStandard(
1052 NumericType& value) noexcept {
1053 value *= static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1054 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1055 * static_cast<NumericType>(1024.0L) / static_cast<NumericType>(60.0L);
1056}
1057
1058template <>
1059template <typename NumericType>
1060inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PetabytePerMinute>::
1061 FromStandard(NumericType& value) noexcept {
1062 value *= static_cast<NumericType>(60.0L) / static_cast<NumericType>(8.0E15L);
1063}
1064
1065template <>
1066template <typename NumericType>
1067inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PetabytePerMinute>::ToStandard(
1068 NumericType& value) noexcept {
1069 value *= static_cast<NumericType>(8.0E15L) / static_cast<NumericType>(60.0L);
1070}
1071
1072template <>
1073template <typename NumericType>
1074inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PebibytePerMinute>::
1075 FromStandard(NumericType& value) noexcept {
1076 value *= static_cast<NumericType>(60.0L)
1077 / (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1078 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1079 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L));
1080}
1081
1082template <>
1083template <typename NumericType>
1084inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PebibytePerMinute>::ToStandard(
1085 NumericType& value) noexcept {
1086 value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1087 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1088 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1089 / static_cast<NumericType>(60.0L);
1090}
1091
1092template <>
1093template <typename NumericType>
1094inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::BitPerHour>::FromStandard(
1095 NumericType& value) noexcept {
1096 value *= static_cast<NumericType>(3600.0L);
1097}
1098
1099template <>
1100template <typename NumericType>
1101inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::BitPerHour>::ToStandard(
1102 NumericType& value) noexcept {
1103 value /= static_cast<NumericType>(3600.0L);
1104}
1105
1106template <>
1107template <typename NumericType>
1108inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::BytePerHour>::FromStandard(
1109 NumericType& value) noexcept {
1110 value *= static_cast<NumericType>(3600.0L) / static_cast<NumericType>(8.0L);
1111}
1112
1113template <>
1114template <typename NumericType>
1115inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::BytePerHour>::ToStandard(
1116 NumericType& value) noexcept {
1117 value *= static_cast<NumericType>(8.0L) / static_cast<NumericType>(3600.0L);
1118}
1119
1120template <>
1121template <typename NumericType>
1122inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KilobitPerHour>::FromStandard(
1123 NumericType& value) noexcept {
1124 value *= static_cast<NumericType>(3600.0L) / static_cast<NumericType>(1000.0L);
1125}
1126
1127template <>
1128template <typename NumericType>
1129inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KilobitPerHour>::ToStandard(
1130 NumericType& value) noexcept {
1131 value *= static_cast<NumericType>(1000.0L) / static_cast<NumericType>(3600.0L);
1132}
1133
1134template <>
1135template <typename NumericType>
1136inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KibibitPerHour>::FromStandard(
1137 NumericType& value) noexcept {
1138 value *= static_cast<NumericType>(3600.0L) / static_cast<NumericType>(1024.0L);
1139}
1140
1141template <>
1142template <typename NumericType>
1143inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KibibitPerHour>::ToStandard(
1144 NumericType& value) noexcept {
1145 value *= static_cast<NumericType>(1024.0L) / static_cast<NumericType>(3600.0L);
1146}
1147
1148template <>
1149template <typename NumericType>
1150inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KilobytePerHour>::FromStandard(
1151 NumericType& value) noexcept {
1152 value *= static_cast<NumericType>(3600.0L) / static_cast<NumericType>(8000.0L);
1153}
1154
1155template <>
1156template <typename NumericType>
1157inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KilobytePerHour>::ToStandard(
1158 NumericType& value) noexcept {
1159 value *= static_cast<NumericType>(8000.0L) / static_cast<NumericType>(3600.0L);
1160}
1161
1162template <>
1163template <typename NumericType>
1164inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KibibytePerHour>::FromStandard(
1165 NumericType& value) noexcept {
1166 value *= static_cast<NumericType>(3600.0L)
1167 / (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L));
1168}
1169
1170template <>
1171template <typename NumericType>
1172inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::KibibytePerHour>::ToStandard(
1173 NumericType& value) noexcept {
1174 value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1175 / static_cast<NumericType>(3600.0L);
1176}
1177
1178template <>
1179template <typename NumericType>
1180inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MegabitPerHour>::FromStandard(
1181 NumericType& value) noexcept {
1182 value *= static_cast<NumericType>(3600.0L) / static_cast<NumericType>(1000000.0L);
1183}
1184
1185template <>
1186template <typename NumericType>
1187inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MegabitPerHour>::ToStandard(
1188 NumericType& value) noexcept {
1189 value *= static_cast<NumericType>(1000000.0L) / static_cast<NumericType>(3600.0L);
1190}
1191
1192template <>
1193template <typename NumericType>
1194inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MebibitPerHour>::FromStandard(
1195 NumericType& value) noexcept {
1196 value *= static_cast<NumericType>(3600.0L)
1197 / (static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L));
1198}
1199
1200template <>
1201template <typename NumericType>
1202inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MebibitPerHour>::ToStandard(
1203 NumericType& value) noexcept {
1204 value *= static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1205 / static_cast<NumericType>(3600.0L);
1206}
1207
1208template <>
1209template <typename NumericType>
1210inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MegabytePerHour>::FromStandard(
1211 NumericType& value) noexcept {
1212 value *= static_cast<NumericType>(3600.0L) / static_cast<NumericType>(8000000.0L);
1213}
1214
1215template <>
1216template <typename NumericType>
1217inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MegabytePerHour>::ToStandard(
1218 NumericType& value) noexcept {
1219 value *= static_cast<NumericType>(8000000.0L) / static_cast<NumericType>(3600.0L);
1220}
1221
1222template <>
1223template <typename NumericType>
1224inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MebibytePerHour>::FromStandard(
1225 NumericType& value) noexcept {
1226 value *= static_cast<NumericType>(3600.0L)
1227 / (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1228 * static_cast<NumericType>(1024.0L));
1229}
1230
1231template <>
1232template <typename NumericType>
1233inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::MebibytePerHour>::ToStandard(
1234 NumericType& value) noexcept {
1235 value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1236 * static_cast<NumericType>(1024.0L) / static_cast<NumericType>(3600.0L);
1237}
1238
1239template <>
1240template <typename NumericType>
1241inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GigabitPerHour>::FromStandard(
1242 NumericType& value) noexcept {
1243 value *= static_cast<NumericType>(3600.0L) / static_cast<NumericType>(1.0E9L);
1244}
1245
1246template <>
1247template <typename NumericType>
1248inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GigabitPerHour>::ToStandard(
1249 NumericType& value) noexcept {
1250 value *= static_cast<NumericType>(1.0E9L) / static_cast<NumericType>(3600.0L);
1251}
1252
1253template <>
1254template <typename NumericType>
1255inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GibibitPerHour>::FromStandard(
1256 NumericType& value) noexcept {
1257 value *= static_cast<NumericType>(3600.0L)
1258 / (static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1259 * static_cast<NumericType>(1024.0L));
1260}
1261
1262template <>
1263template <typename NumericType>
1264inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GibibitPerHour>::ToStandard(
1265 NumericType& value) noexcept {
1266 value *= static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1267 * static_cast<NumericType>(1024.0L) / static_cast<NumericType>(3600.0L);
1268}
1269
1270template <>
1271template <typename NumericType>
1272inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GigabytePerHour>::FromStandard(
1273 NumericType& value) noexcept {
1274 value *= static_cast<NumericType>(3600.0L) / (static_cast<NumericType>(8.0E9L));
1275}
1276
1277template <>
1278template <typename NumericType>
1279inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GigabytePerHour>::ToStandard(
1280 NumericType& value) noexcept {
1281 value *= static_cast<NumericType>(8.0E9L) / static_cast<NumericType>(3600.0L);
1282}
1283
1284template <>
1285template <typename NumericType>
1286inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GibibytePerHour>::FromStandard(
1287 NumericType& value) noexcept {
1288 value *= static_cast<NumericType>(3600.0L)
1289 / (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1290 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L));
1291}
1292
1293template <>
1294template <typename NumericType>
1295inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::GibibytePerHour>::ToStandard(
1296 NumericType& value) noexcept {
1297 value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1298 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1299 / static_cast<NumericType>(3600.0L);
1300}
1301
1302template <>
1303template <typename NumericType>
1304inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TerabitPerHour>::FromStandard(
1305 NumericType& value) noexcept {
1306 value *= static_cast<NumericType>(3600.0L) / static_cast<NumericType>(1.0E12L);
1307}
1308
1309template <>
1310template <typename NumericType>
1311inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TerabitPerHour>::ToStandard(
1312 NumericType& value) noexcept {
1313 value *= static_cast<NumericType>(1.0E12L) / static_cast<NumericType>(3600.0L);
1314}
1315
1316template <>
1317template <typename NumericType>
1318inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TebibitPerHour>::FromStandard(
1319 NumericType& value) noexcept {
1320 value *= static_cast<NumericType>(3600.0L)
1321 / (static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1322 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L));
1323}
1324
1325template <>
1326template <typename NumericType>
1327inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TebibitPerHour>::ToStandard(
1328 NumericType& value) noexcept {
1329 value *= static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1330 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1331 / static_cast<NumericType>(3600.0L);
1332}
1333
1334template <>
1335template <typename NumericType>
1336inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TerabytePerHour>::FromStandard(
1337 NumericType& value) noexcept {
1338 value *= static_cast<NumericType>(3600.0L) / static_cast<NumericType>(8.0E12L);
1339}
1340
1341template <>
1342template <typename NumericType>
1343inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TerabytePerHour>::ToStandard(
1344 NumericType& value) noexcept {
1345 value *= static_cast<NumericType>(8.0E12L) / static_cast<NumericType>(3600.0L);
1346}
1347
1348template <>
1349template <typename NumericType>
1350inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TebibytePerHour>::FromStandard(
1351 NumericType& value) noexcept {
1352 value *= static_cast<NumericType>(3600.0L)
1353 / (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1354 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1355 * static_cast<NumericType>(1024.0L));
1356}
1357
1358template <>
1359template <typename NumericType>
1360inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::TebibytePerHour>::ToStandard(
1361 NumericType& value) noexcept {
1362 value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1363 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1364 * static_cast<NumericType>(1024.0L) / static_cast<NumericType>(3600.0L);
1365}
1366
1367template <>
1368template <typename NumericType>
1369inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PetabitPerHour>::FromStandard(
1370 NumericType& value) noexcept {
1371 value *= static_cast<NumericType>(3600.0L) / static_cast<NumericType>(1.0E15L);
1372}
1373
1374template <>
1375template <typename NumericType>
1376inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PetabitPerHour>::ToStandard(
1377 NumericType& value) noexcept {
1378 value *= static_cast<NumericType>(1.0E15L) / static_cast<NumericType>(3600.0L);
1379}
1380
1381template <>
1382template <typename NumericType>
1383inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PebibitPerHour>::FromStandard(
1384 NumericType& value) noexcept {
1385 value *= static_cast<NumericType>(3600.0L)
1386 / (static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1387 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1388 * static_cast<NumericType>(1024.0L));
1389}
1390
1391template <>
1392template <typename NumericType>
1393inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PebibitPerHour>::ToStandard(
1394 NumericType& value) noexcept {
1395 value *= static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1396 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1397 * static_cast<NumericType>(1024.0L) / static_cast<NumericType>(3600.0L);
1398}
1399
1400template <>
1401template <typename NumericType>
1402inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PetabytePerHour>::FromStandard(
1403 NumericType& value) noexcept {
1404 value *= static_cast<NumericType>(3600.0L) / static_cast<NumericType>(8.0E15L);
1405}
1406
1407template <>
1408template <typename NumericType>
1409inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PetabytePerHour>::ToStandard(
1410 NumericType& value) noexcept {
1411 value *= static_cast<NumericType>(8.0E15L) / static_cast<NumericType>(3600.0L);
1412}
1413
1414template <>
1415template <typename NumericType>
1416inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PebibytePerHour>::FromStandard(
1417 NumericType& value) noexcept {
1418 value *= static_cast<NumericType>(3600.0L)
1419 / (static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1420 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1421 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L));
1422}
1423
1424template <>
1425template <typename NumericType>
1426inline constexpr void Conversion<Unit::MemoryRate, Unit::MemoryRate::PebibytePerHour>::ToStandard(
1427 NumericType& value) noexcept {
1428 value *= static_cast<NumericType>(8.0L) * static_cast<NumericType>(1024.0L)
1429 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1430 * static_cast<NumericType>(1024.0L) * static_cast<NumericType>(1024.0L)
1431 / static_cast<NumericType>(3600.0L);
1432}
1433
1434template <typename NumericType>
1435inline const std::map<Unit::MemoryRate,
1436 std::function<void(NumericType* values, const std::size_t size)>>
1437 MapOfConversionsFromStandard<Unit::MemoryRate, NumericType>{
1438 {Unit::MemoryRate::BitPerSecond,
1439 Conversions<Unit::MemoryRate, Unit::MemoryRate::BitPerSecond>::FromStandard<NumericType> },
1440 {Unit::MemoryRate::BytePerSecond,
1441 Conversions<Unit::MemoryRate, Unit::MemoryRate::BytePerSecond>::FromStandard<NumericType> },
1442 {Unit::MemoryRate::KilobitPerSecond,
1443 Conversions<Unit::MemoryRate, Unit::MemoryRate::KilobitPerSecond>::
1444 FromStandard<NumericType> },
1445 {Unit::MemoryRate::KibibitPerSecond,
1446 Conversions<Unit::MemoryRate, Unit::MemoryRate::KibibitPerSecond>::
1447 FromStandard<NumericType> },
1448 {Unit::MemoryRate::KilobytePerSecond,
1449 Conversions<Unit::MemoryRate, Unit::MemoryRate::KilobytePerSecond>::
1450 FromStandard<NumericType> },
1451 {Unit::MemoryRate::KibibytePerSecond,
1452 Conversions<Unit::MemoryRate, Unit::MemoryRate::KibibytePerSecond>::
1453 FromStandard<NumericType> },
1454 {Unit::MemoryRate::MegabitPerSecond,
1455 Conversions<Unit::MemoryRate, Unit::MemoryRate::MegabitPerSecond>::
1456 FromStandard<NumericType> },
1457 {Unit::MemoryRate::MebibitPerSecond,
1458 Conversions<Unit::MemoryRate, Unit::MemoryRate::MebibitPerSecond>::
1459 FromStandard<NumericType> },
1460 {Unit::MemoryRate::MegabytePerSecond,
1461 Conversions<Unit::MemoryRate, Unit::MemoryRate::MegabytePerSecond>::
1462 FromStandard<NumericType> },
1463 {Unit::MemoryRate::MebibytePerSecond,
1464 Conversions<Unit::MemoryRate, Unit::MemoryRate::MebibytePerSecond>::
1465 FromStandard<NumericType> },
1466 {Unit::MemoryRate::GigabitPerSecond,
1467 Conversions<Unit::MemoryRate, Unit::MemoryRate::GigabitPerSecond>::
1468 FromStandard<NumericType> },
1469 {Unit::MemoryRate::GibibitPerSecond,
1470 Conversions<Unit::MemoryRate, Unit::MemoryRate::GibibitPerSecond>::
1471 FromStandard<NumericType> },
1472 {Unit::MemoryRate::GigabytePerSecond,
1473 Conversions<Unit::MemoryRate, Unit::MemoryRate::GigabytePerSecond>::
1474 FromStandard<NumericType> },
1475 {Unit::MemoryRate::GibibytePerSecond,
1476 Conversions<Unit::MemoryRate, Unit::MemoryRate::GibibytePerSecond>::
1477 FromStandard<NumericType> },
1478 {Unit::MemoryRate::TerabitPerSecond,
1479 Conversions<Unit::MemoryRate, Unit::MemoryRate::TerabitPerSecond>::
1480 FromStandard<NumericType> },
1481 {Unit::MemoryRate::TebibitPerSecond,
1482 Conversions<Unit::MemoryRate, Unit::MemoryRate::TebibitPerSecond>::
1483 FromStandard<NumericType> },
1484 {Unit::MemoryRate::TerabytePerSecond,
1485 Conversions<Unit::MemoryRate, Unit::MemoryRate::TerabytePerSecond>::
1486 FromStandard<NumericType> },
1487 {Unit::MemoryRate::TebibytePerSecond,
1488 Conversions<Unit::MemoryRate, Unit::MemoryRate::TebibytePerSecond>::
1489 FromStandard<NumericType> },
1490 {Unit::MemoryRate::PetabitPerSecond,
1491 Conversions<Unit::MemoryRate, Unit::MemoryRate::PetabitPerSecond>::
1492 FromStandard<NumericType> },
1493 {Unit::MemoryRate::PebibitPerSecond,
1494 Conversions<Unit::MemoryRate, Unit::MemoryRate::PebibitPerSecond>::
1495 FromStandard<NumericType> },
1496 {Unit::MemoryRate::PetabytePerSecond,
1497 Conversions<Unit::MemoryRate, Unit::MemoryRate::PetabytePerSecond>::
1498 FromStandard<NumericType> },
1499 {Unit::MemoryRate::PebibytePerSecond,
1500 Conversions<Unit::MemoryRate, Unit::MemoryRate::PebibytePerSecond>::
1501 FromStandard<NumericType> },
1502 {Unit::MemoryRate::BitPerMinute,
1503 Conversions<Unit::MemoryRate, Unit::MemoryRate::BitPerMinute>::FromStandard<NumericType> },
1504 {Unit::MemoryRate::BytePerMinute,
1505 Conversions<Unit::MemoryRate, Unit::MemoryRate::BytePerMinute>::FromStandard<NumericType> },
1506 {Unit::MemoryRate::KilobitPerMinute,
1507 Conversions<Unit::MemoryRate, Unit::MemoryRate::KilobitPerMinute>::
1508 FromStandard<NumericType> },
1509 {Unit::MemoryRate::KibibitPerMinute,
1510 Conversions<Unit::MemoryRate, Unit::MemoryRate::KibibitPerMinute>::
1511 FromStandard<NumericType> },
1512 {Unit::MemoryRate::KilobytePerMinute,
1513 Conversions<Unit::MemoryRate, Unit::MemoryRate::KilobytePerMinute>::
1514 FromStandard<NumericType> },
1515 {Unit::MemoryRate::KibibytePerMinute,
1516 Conversions<Unit::MemoryRate, Unit::MemoryRate::KibibytePerMinute>::
1517 FromStandard<NumericType> },
1518 {Unit::MemoryRate::MegabitPerMinute,
1519 Conversions<Unit::MemoryRate, Unit::MemoryRate::MegabitPerMinute>::
1520 FromStandard<NumericType> },
1521 {Unit::MemoryRate::MebibitPerMinute,
1522 Conversions<Unit::MemoryRate, Unit::MemoryRate::MebibitPerMinute>::
1523 FromStandard<NumericType> },
1524 {Unit::MemoryRate::MegabytePerMinute,
1525 Conversions<Unit::MemoryRate, Unit::MemoryRate::MegabytePerMinute>::
1526 FromStandard<NumericType> },
1527 {Unit::MemoryRate::MebibytePerMinute,
1528 Conversions<Unit::MemoryRate, Unit::MemoryRate::MebibytePerMinute>::
1529 FromStandard<NumericType> },
1530 {Unit::MemoryRate::GigabitPerMinute,
1531 Conversions<Unit::MemoryRate, Unit::MemoryRate::GigabitPerMinute>::
1532 FromStandard<NumericType> },
1533 {Unit::MemoryRate::GibibitPerMinute,
1534 Conversions<Unit::MemoryRate, Unit::MemoryRate::GibibitPerMinute>::
1535 FromStandard<NumericType> },
1536 {Unit::MemoryRate::GigabytePerMinute,
1537 Conversions<Unit::MemoryRate, Unit::MemoryRate::GigabytePerMinute>::
1538 FromStandard<NumericType> },
1539 {Unit::MemoryRate::GibibytePerMinute,
1540 Conversions<Unit::MemoryRate, Unit::MemoryRate::GibibytePerMinute>::
1541 FromStandard<NumericType> },
1542 {Unit::MemoryRate::TerabitPerMinute,
1543 Conversions<Unit::MemoryRate, Unit::MemoryRate::TerabitPerMinute>::
1544 FromStandard<NumericType> },
1545 {Unit::MemoryRate::TebibitPerMinute,
1546 Conversions<Unit::MemoryRate, Unit::MemoryRate::TebibitPerMinute>::
1547 FromStandard<NumericType> },
1548 {Unit::MemoryRate::TerabytePerMinute,
1549 Conversions<Unit::MemoryRate, Unit::MemoryRate::TerabytePerMinute>::
1550 FromStandard<NumericType> },
1551 {Unit::MemoryRate::TebibytePerMinute,
1552 Conversions<Unit::MemoryRate, Unit::MemoryRate::TebibytePerMinute>::
1553 FromStandard<NumericType> },
1554 {Unit::MemoryRate::PetabitPerMinute,
1555 Conversions<Unit::MemoryRate, Unit::MemoryRate::PetabitPerMinute>::
1556 FromStandard<NumericType> },
1557 {Unit::MemoryRate::PebibitPerMinute,
1558 Conversions<Unit::MemoryRate, Unit::MemoryRate::PebibitPerMinute>::
1559 FromStandard<NumericType> },
1560 {Unit::MemoryRate::PetabytePerMinute,
1561 Conversions<Unit::MemoryRate, Unit::MemoryRate::PetabytePerMinute>::
1562 FromStandard<NumericType> },
1563 {Unit::MemoryRate::PebibytePerMinute,
1564 Conversions<Unit::MemoryRate, Unit::MemoryRate::PebibytePerMinute>::
1565 FromStandard<NumericType> },
1566 {Unit::MemoryRate::BitPerHour,
1567 Conversions<Unit::MemoryRate, Unit::MemoryRate::BitPerHour>::FromStandard<NumericType> },
1568 {Unit::MemoryRate::BytePerHour,
1569 Conversions<Unit::MemoryRate, Unit::MemoryRate::BytePerHour>::FromStandard<NumericType> },
1570 {Unit::MemoryRate::KilobitPerHour,
1571 Conversions<Unit::MemoryRate, Unit::MemoryRate::KilobitPerHour>::FromStandard<NumericType> },
1572 {Unit::MemoryRate::KibibitPerHour,
1573 Conversions<Unit::MemoryRate, Unit::MemoryRate::KibibitPerHour>::FromStandard<NumericType> },
1574 {Unit::MemoryRate::KilobytePerHour,
1575 Conversions<Unit::MemoryRate, Unit::MemoryRate::KilobytePerHour>::FromStandard<NumericType>},
1576 {Unit::MemoryRate::KibibytePerHour,
1577 Conversions<Unit::MemoryRate, Unit::MemoryRate::KibibytePerHour>::FromStandard<NumericType>},
1578 {Unit::MemoryRate::MegabitPerHour,
1579 Conversions<Unit::MemoryRate, Unit::MemoryRate::MegabitPerHour>::FromStandard<NumericType> },
1580 {Unit::MemoryRate::MebibitPerHour,
1581 Conversions<Unit::MemoryRate, Unit::MemoryRate::MebibitPerHour>::FromStandard<NumericType> },
1582 {Unit::MemoryRate::MegabytePerHour,
1583 Conversions<Unit::MemoryRate, Unit::MemoryRate::MegabytePerHour>::FromStandard<NumericType>},
1584 {Unit::MemoryRate::MebibytePerHour,
1585 Conversions<Unit::MemoryRate, Unit::MemoryRate::MebibytePerHour>::FromStandard<NumericType>},
1586 {Unit::MemoryRate::GigabitPerHour,
1587 Conversions<Unit::MemoryRate, Unit::MemoryRate::GigabitPerHour>::FromStandard<NumericType> },
1588 {Unit::MemoryRate::GibibitPerHour,
1589 Conversions<Unit::MemoryRate, Unit::MemoryRate::GibibitPerHour>::FromStandard<NumericType> },
1590 {Unit::MemoryRate::GigabytePerHour,
1591 Conversions<Unit::MemoryRate, Unit::MemoryRate::GigabytePerHour>::FromStandard<NumericType>},
1592 {Unit::MemoryRate::GibibytePerHour,
1593 Conversions<Unit::MemoryRate, Unit::MemoryRate::GibibytePerHour>::FromStandard<NumericType>},
1594 {Unit::MemoryRate::TerabitPerHour,
1595 Conversions<Unit::MemoryRate, Unit::MemoryRate::TerabitPerHour>::FromStandard<NumericType> },
1596 {Unit::MemoryRate::TebibitPerHour,
1597 Conversions<Unit::MemoryRate, Unit::MemoryRate::TebibitPerHour>::FromStandard<NumericType> },
1598 {Unit::MemoryRate::TerabytePerHour,
1599 Conversions<Unit::MemoryRate, Unit::MemoryRate::TerabytePerHour>::FromStandard<NumericType>},
1600 {Unit::MemoryRate::TebibytePerHour,
1601 Conversions<Unit::MemoryRate, Unit::MemoryRate::TebibytePerHour>::FromStandard<NumericType>},
1602 {Unit::MemoryRate::PetabitPerHour,
1603 Conversions<Unit::MemoryRate, Unit::MemoryRate::PetabitPerHour>::FromStandard<NumericType> },
1604 {Unit::MemoryRate::PebibitPerHour,
1605 Conversions<Unit::MemoryRate, Unit::MemoryRate::PebibitPerHour>::FromStandard<NumericType> },
1606 {Unit::MemoryRate::PetabytePerHour,
1607 Conversions<Unit::MemoryRate, Unit::MemoryRate::PetabytePerHour>::FromStandard<NumericType>},
1608 {Unit::MemoryRate::PebibytePerHour,
1609 Conversions<Unit::MemoryRate, Unit::MemoryRate::PebibytePerHour>::FromStandard<NumericType>},
1610};
1611
1612template <typename NumericType>
1613inline const std::map<Unit::MemoryRate,
1614 std::function<void(NumericType* const values, const std::size_t size)>>
1615 MapOfConversionsToStandard<Unit::MemoryRate, NumericType>{
1616 {Unit::MemoryRate::BitPerSecond,
1617 Conversions<Unit::MemoryRate, Unit::MemoryRate::BitPerSecond>::ToStandard<NumericType> },
1618 {Unit::MemoryRate::BytePerSecond,
1619 Conversions<Unit::MemoryRate, Unit::MemoryRate::BytePerSecond>::ToStandard<NumericType> },
1620 {Unit::MemoryRate::KilobitPerSecond,
1621 Conversions<Unit::MemoryRate, Unit::MemoryRate::KilobitPerSecond>::ToStandard<NumericType> },
1622 {Unit::MemoryRate::KibibitPerSecond,
1623 Conversions<Unit::MemoryRate, Unit::MemoryRate::KibibitPerSecond>::ToStandard<NumericType> },
1624 {Unit::MemoryRate::KilobytePerSecond,
1625 Conversions<Unit::MemoryRate, Unit::MemoryRate::KilobytePerSecond>::ToStandard<NumericType>},
1626 {Unit::MemoryRate::KibibytePerSecond,
1627 Conversions<Unit::MemoryRate, Unit::MemoryRate::KibibytePerSecond>::ToStandard<NumericType>},
1628 {Unit::MemoryRate::MegabitPerSecond,
1629 Conversions<Unit::MemoryRate, Unit::MemoryRate::MegabitPerSecond>::ToStandard<NumericType> },
1630 {Unit::MemoryRate::MebibitPerSecond,
1631 Conversions<Unit::MemoryRate, Unit::MemoryRate::MebibitPerSecond>::ToStandard<NumericType> },
1632 {Unit::MemoryRate::MegabytePerSecond,
1633 Conversions<Unit::MemoryRate, Unit::MemoryRate::MegabytePerSecond>::ToStandard<NumericType>},
1634 {Unit::MemoryRate::MebibytePerSecond,
1635 Conversions<Unit::MemoryRate, Unit::MemoryRate::MebibytePerSecond>::ToStandard<NumericType>},
1636 {Unit::MemoryRate::GigabitPerSecond,
1637 Conversions<Unit::MemoryRate, Unit::MemoryRate::GigabitPerSecond>::ToStandard<NumericType> },
1638 {Unit::MemoryRate::GibibitPerSecond,
1639 Conversions<Unit::MemoryRate, Unit::MemoryRate::GibibitPerSecond>::ToStandard<NumericType> },
1640 {Unit::MemoryRate::GigabytePerSecond,
1641 Conversions<Unit::MemoryRate, Unit::MemoryRate::GigabytePerSecond>::ToStandard<NumericType>},
1642 {Unit::MemoryRate::GibibytePerSecond,
1643 Conversions<Unit::MemoryRate, Unit::MemoryRate::GibibytePerSecond>::ToStandard<NumericType>},
1644 {Unit::MemoryRate::TerabitPerSecond,
1645 Conversions<Unit::MemoryRate, Unit::MemoryRate::TerabitPerSecond>::ToStandard<NumericType> },
1646 {Unit::MemoryRate::TebibitPerSecond,
1647 Conversions<Unit::MemoryRate, Unit::MemoryRate::TebibitPerSecond>::ToStandard<NumericType> },
1648 {Unit::MemoryRate::TerabytePerSecond,
1649 Conversions<Unit::MemoryRate, Unit::MemoryRate::TerabytePerSecond>::ToStandard<NumericType>},
1650 {Unit::MemoryRate::TebibytePerSecond,
1651 Conversions<Unit::MemoryRate, Unit::MemoryRate::TebibytePerSecond>::ToStandard<NumericType>},
1652 {Unit::MemoryRate::PetabitPerSecond,
1653 Conversions<Unit::MemoryRate, Unit::MemoryRate::PetabitPerSecond>::ToStandard<NumericType> },
1654 {Unit::MemoryRate::PebibitPerSecond,
1655 Conversions<Unit::MemoryRate, Unit::MemoryRate::PebibitPerSecond>::ToStandard<NumericType> },
1656 {Unit::MemoryRate::PetabytePerSecond,
1657 Conversions<Unit::MemoryRate, Unit::MemoryRate::PetabytePerSecond>::ToStandard<NumericType>},
1658 {Unit::MemoryRate::PebibytePerSecond,
1659 Conversions<Unit::MemoryRate, Unit::MemoryRate::PebibytePerSecond>::ToStandard<NumericType>},
1660 {Unit::MemoryRate::BitPerMinute,
1661 Conversions<Unit::MemoryRate, Unit::MemoryRate::BitPerMinute>::ToStandard<NumericType> },
1662 {Unit::MemoryRate::BytePerMinute,
1663 Conversions<Unit::MemoryRate, Unit::MemoryRate::BytePerMinute>::ToStandard<NumericType> },
1664 {Unit::MemoryRate::KilobitPerMinute,
1665 Conversions<Unit::MemoryRate, Unit::MemoryRate::KilobitPerMinute>::ToStandard<NumericType> },
1666 {Unit::MemoryRate::KibibitPerMinute,
1667 Conversions<Unit::MemoryRate, Unit::MemoryRate::KibibitPerMinute>::ToStandard<NumericType> },
1668 {Unit::MemoryRate::KilobytePerMinute,
1669 Conversions<Unit::MemoryRate, Unit::MemoryRate::KilobytePerMinute>::ToStandard<NumericType>},
1670 {Unit::MemoryRate::KibibytePerMinute,
1671 Conversions<Unit::MemoryRate, Unit::MemoryRate::KibibytePerMinute>::ToStandard<NumericType>},
1672 {Unit::MemoryRate::MegabitPerMinute,
1673 Conversions<Unit::MemoryRate, Unit::MemoryRate::MegabitPerMinute>::ToStandard<NumericType> },
1674 {Unit::MemoryRate::MebibitPerMinute,
1675 Conversions<Unit::MemoryRate, Unit::MemoryRate::MebibitPerMinute>::ToStandard<NumericType> },
1676 {Unit::MemoryRate::MegabytePerMinute,
1677 Conversions<Unit::MemoryRate, Unit::MemoryRate::MegabytePerMinute>::ToStandard<NumericType>},
1678 {Unit::MemoryRate::MebibytePerMinute,
1679 Conversions<Unit::MemoryRate, Unit::MemoryRate::MebibytePerMinute>::ToStandard<NumericType>},
1680 {Unit::MemoryRate::GigabitPerMinute,
1681 Conversions<Unit::MemoryRate, Unit::MemoryRate::GigabitPerMinute>::ToStandard<NumericType> },
1682 {Unit::MemoryRate::GibibitPerMinute,
1683 Conversions<Unit::MemoryRate, Unit::MemoryRate::GibibitPerMinute>::ToStandard<NumericType> },
1684 {Unit::MemoryRate::GigabytePerMinute,
1685 Conversions<Unit::MemoryRate, Unit::MemoryRate::GigabytePerMinute>::ToStandard<NumericType>},
1686 {Unit::MemoryRate::GibibytePerMinute,
1687 Conversions<Unit::MemoryRate, Unit::MemoryRate::GibibytePerMinute>::ToStandard<NumericType>},
1688 {Unit::MemoryRate::TerabitPerMinute,
1689 Conversions<Unit::MemoryRate, Unit::MemoryRate::TerabitPerMinute>::ToStandard<NumericType> },
1690 {Unit::MemoryRate::TebibitPerMinute,
1691 Conversions<Unit::MemoryRate, Unit::MemoryRate::TebibitPerMinute>::ToStandard<NumericType> },
1692 {Unit::MemoryRate::TerabytePerMinute,
1693 Conversions<Unit::MemoryRate, Unit::MemoryRate::TerabytePerMinute>::ToStandard<NumericType>},
1694 {Unit::MemoryRate::TebibytePerMinute,
1695 Conversions<Unit::MemoryRate, Unit::MemoryRate::TebibytePerMinute>::ToStandard<NumericType>},
1696 {Unit::MemoryRate::PetabitPerMinute,
1697 Conversions<Unit::MemoryRate, Unit::MemoryRate::PetabitPerMinute>::ToStandard<NumericType> },
1698 {Unit::MemoryRate::PebibitPerMinute,
1699 Conversions<Unit::MemoryRate, Unit::MemoryRate::PebibitPerMinute>::ToStandard<NumericType> },
1700 {Unit::MemoryRate::PetabytePerMinute,
1701 Conversions<Unit::MemoryRate, Unit::MemoryRate::PetabytePerMinute>::ToStandard<NumericType>},
1702 {Unit::MemoryRate::PebibytePerMinute,
1703 Conversions<Unit::MemoryRate, Unit::MemoryRate::PebibytePerMinute>::ToStandard<NumericType>},
1704 {Unit::MemoryRate::BitPerHour,
1705 Conversions<Unit::MemoryRate, Unit::MemoryRate::BitPerHour>::ToStandard<NumericType> },
1706 {Unit::MemoryRate::BytePerHour,
1707 Conversions<Unit::MemoryRate, Unit::MemoryRate::BytePerHour>::ToStandard<NumericType> },
1708 {Unit::MemoryRate::KilobitPerHour,
1709 Conversions<Unit::MemoryRate, Unit::MemoryRate::KilobitPerHour>::ToStandard<NumericType> },
1710 {Unit::MemoryRate::KibibitPerHour,
1711 Conversions<Unit::MemoryRate, Unit::MemoryRate::KibibitPerHour>::ToStandard<NumericType> },
1712 {Unit::MemoryRate::KilobytePerHour,
1713 Conversions<Unit::MemoryRate, Unit::MemoryRate::KilobytePerHour>::ToStandard<NumericType> },
1714 {Unit::MemoryRate::KibibytePerHour,
1715 Conversions<Unit::MemoryRate, Unit::MemoryRate::KibibytePerHour>::ToStandard<NumericType> },
1716 {Unit::MemoryRate::MegabitPerHour,
1717 Conversions<Unit::MemoryRate, Unit::MemoryRate::MegabitPerHour>::ToStandard<NumericType> },
1718 {Unit::MemoryRate::MebibitPerHour,
1719 Conversions<Unit::MemoryRate, Unit::MemoryRate::MebibitPerHour>::ToStandard<NumericType> },
1720 {Unit::MemoryRate::MegabytePerHour,
1721 Conversions<Unit::MemoryRate, Unit::MemoryRate::MegabytePerHour>::ToStandard<NumericType> },
1722 {Unit::MemoryRate::MebibytePerHour,
1723 Conversions<Unit::MemoryRate, Unit::MemoryRate::MebibytePerHour>::ToStandard<NumericType> },
1724 {Unit::MemoryRate::GigabitPerHour,
1725 Conversions<Unit::MemoryRate, Unit::MemoryRate::GigabitPerHour>::ToStandard<NumericType> },
1726 {Unit::MemoryRate::GibibitPerHour,
1727 Conversions<Unit::MemoryRate, Unit::MemoryRate::GibibitPerHour>::ToStandard<NumericType> },
1728 {Unit::MemoryRate::GigabytePerHour,
1729 Conversions<Unit::MemoryRate, Unit::MemoryRate::GigabytePerHour>::ToStandard<NumericType> },
1730 {Unit::MemoryRate::GibibytePerHour,
1731 Conversions<Unit::MemoryRate, Unit::MemoryRate::GibibytePerHour>::ToStandard<NumericType> },
1732 {Unit::MemoryRate::TerabitPerHour,
1733 Conversions<Unit::MemoryRate, Unit::MemoryRate::TerabitPerHour>::ToStandard<NumericType> },
1734 {Unit::MemoryRate::TebibitPerHour,
1735 Conversions<Unit::MemoryRate, Unit::MemoryRate::TebibitPerHour>::ToStandard<NumericType> },
1736 {Unit::MemoryRate::TerabytePerHour,
1737 Conversions<Unit::MemoryRate, Unit::MemoryRate::TerabytePerHour>::ToStandard<NumericType> },
1738 {Unit::MemoryRate::TebibytePerHour,
1739 Conversions<Unit::MemoryRate, Unit::MemoryRate::TebibytePerHour>::ToStandard<NumericType> },
1740 {Unit::MemoryRate::PetabitPerHour,
1741 Conversions<Unit::MemoryRate, Unit::MemoryRate::PetabitPerHour>::ToStandard<NumericType> },
1742 {Unit::MemoryRate::PebibitPerHour,
1743 Conversions<Unit::MemoryRate, Unit::MemoryRate::PebibitPerHour>::ToStandard<NumericType> },
1744 {Unit::MemoryRate::PetabytePerHour,
1745 Conversions<Unit::MemoryRate, Unit::MemoryRate::PetabytePerHour>::ToStandard<NumericType> },
1746 {Unit::MemoryRate::PebibytePerHour,
1747 Conversions<Unit::MemoryRate, Unit::MemoryRate::PebibytePerHour>::ToStandard<NumericType> },
1748};
1749
1750} // namespace Internal
1751
1752} // namespace PhQ
1753
1754#endif // PHQ_UNIT_MEMORY_RATE_HPP
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
Namespace that encompasses all of the Physical Quantities library's content.
Definition Acceleration.hpp:44
PhQ::operator<<
std::ostream & operator<<(std::ostream &stream, const Acceleration< NumericType > &acceleration)
Definition Acceleration.hpp:265
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
Physical Quantities (PhQ): Git Repository | Documentation