ztr/CPC
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

Improve formatting of numbers, closes #20

Browse Source
This commit is contained in:
Kasper 2023-03-30 01:06:13 +02:00
parent 681e117453
commit 2ccf25affc
No known key found for this signature in database
GPG Key ID: 356D5C59EDCEC2D1
6 changed files with 241 additions and 216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG.md
View File

@ -1,5 +1,8 @@
# Changelog # Changelog
## Next
- Improve formatting of numbers
## 1.9.0 - 2022 Dec 30 ## 1.9.0 - 2022 Dec 30
- Add `marathon` unit - Add `marathon` unit
- Add `aarch64` binaries - Add `aarch64` binaries

2
README.md
View File

@ -39,7 +39,7 @@ match eval("3m + 1cm", true, Unit::Celsius, false) {
println!("Evaluated value: {} {:?}", answer.value, answer.unit) println!("Evaluated value: {} {:?}", answer.value, answer.unit)
}, },
Err(e) => { Err(e) => {
println!("{}", e) println!("{e}")
} }
} }
``` ```

10
src/lexer.rs
View File

@ -952,22 +952,22 @@ mod tests {
} }
}; };
let info_msg = format!("run_lex input: {}\nexpected: {:?}\nreceived: {:?}", input, expected_tokens, tokens); let info_msg = format!("run_lex input: {}\nexpected: {:?}\nreceived: {:?}", input, expected_tokens, tokens);
assert!(tokens == expected_tokens, "{}", info_msg); assert!(tokens == expected_tokens, "{info_msg}");
// Prove we can handle multiple spaces wherever we handle a single space // Prove we can handle multiple spaces wherever we handle a single space
let input_extra_spaces = input.replace(" ", " "); let input_extra_spaces = input.replace(" ", " ");
let tokens_extra_spaces = lex(&input_extra_spaces, false, Unit::Celsius).unwrap(); let tokens_extra_spaces = lex(&input_extra_spaces, false, Unit::Celsius).unwrap();
assert!(tokens_extra_spaces == expected_tokens, "{}", info_msg); assert!(tokens_extra_spaces == expected_tokens, "{info_msg}");
// Prove we don't need spaces around operators // Prove we don't need spaces around operators
let input_stripped_spaces = strip_operator_spacing.replace_all(input, "$1"); let input_stripped_spaces = strip_operator_spacing.replace_all(input, "$1");
let tokens_stripped_spaces = lex(&input_stripped_spaces, false, Unit::Celsius).unwrap(); let tokens_stripped_spaces = lex(&input_stripped_spaces, false, Unit::Celsius).unwrap();
assert!(tokens_stripped_spaces == expected_tokens, "{}", info_msg); assert!(tokens_stripped_spaces == expected_tokens, "{info_msg}");
// Prove we don't need a space after a digit // Prove we don't need a space after a digit
let input_afterdigit_stripped_spaces = strip_afterdigit_spacing.replace_all(input, "$1"); let input_afterdigit_stripped_spaces = strip_afterdigit_spacing.replace_all(input, "$1");
let tokens_afterdigit_stripped_spaces = lex(&input_afterdigit_stripped_spaces, false, Unit::Celsius).unwrap(); let tokens_afterdigit_stripped_spaces = lex(&input_afterdigit_stripped_spaces, false, Unit::Celsius).unwrap();
assert!(tokens_afterdigit_stripped_spaces == expected_tokens, "{}", info_msg); assert!(tokens_afterdigit_stripped_spaces == expected_tokens, "{info_msg}");
}; };
let run_datarate_lex = |input: &str, expected_tokens: Vec<Token>| { let run_datarate_lex = |input: &str, expected_tokens: Vec<Token>| {
@ -977,7 +977,7 @@ mod tests {
let input_nonplural_units = nonplural_data_units.replace_all(input, "$1"); let input_nonplural_units = nonplural_data_units.replace_all(input, "$1");
let tokens_nonplural_units = lex(&input_nonplural_units, false, Unit::Celsius).unwrap(); let tokens_nonplural_units = lex(&input_nonplural_units, false, Unit::Celsius).unwrap();
let info_msg = format!("run_datarate_lex input: {}\nexpected: {:?}\nreceived: {:?}", input, expected_tokens, tokens_nonplural_units); let info_msg = format!("run_datarate_lex input: {}\nexpected: {:?}\nreceived: {:?}", input, expected_tokens, tokens_nonplural_units);
assert!(tokens_nonplural_units == expected_tokens, "{}", info_msg); assert!(tokens_nonplural_units == expected_tokens, "{info_msg}");
}; };
run_lex("88 kilometres * 2", vec![numtok!(88), Token::Unit(Kilometer), Token::Operator(Multiply), numtok!(2)]); run_lex("88 kilometres * 2", vec![numtok!(88), Token::Unit(Kilometer), Token::Operator(Multiply), numtok!(2)]);

18
src/lib.rs
View File

@ -25,7 +25,7 @@
//! println!("Evaluated value: {} {:?}", answer.value, answer.unit) //! println!("Evaluated value: {} {:?}", answer.value, answer.unit)
//! }, //! },
//! Err(e) => { //! Err(e) => {
//! println!("{}", e) //! println!("{e}")
//! } //! }
//! } //! }
//! ``` //! ```
@ -77,12 +77,16 @@ impl Number {
impl Display for Number { impl Display for Number {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
// 0.2/0.01 results in 2E+1, but if we add zero it becomes 20 // 0.2/0.01 results in 2E+1, but if we add zero it becomes 20
let fixed_value = self.value + d128!(0); let value = self.value + d128!(0);
let output = match self.unit { let word = match self.value == d128!(1) {
Unit::NoUnit => format!("{}", fixed_value), true => self.unit.singular(),
unit => format!("{} {:?}", fixed_value, unit), false => self.unit.plural(),
}; };
write!(f, "{}", output) let output = match word {
"" => format!("{value}"),
_ => format!("{value} {word}"),
};
write!(f, "{output}")
} }
} }
@ -232,7 +236,7 @@ macro_rules! numtok {
/// println!("Evaluated value: {} {:?}", answer.value, answer.unit) /// println!("Evaluated value: {} {:?}", answer.value, answer.unit)
/// }, /// },
/// Err(e) => { /// Err(e) => {
/// println!("{}", e) /// println!("{e}")
/// } /// }
/// } /// }
/// ``` /// ```

6
src/main.rs
View File

@ -28,7 +28,7 @@ fn main() {
for arg in get_args() { for arg in get_args() {
match arg.as_str() { match arg.as_str() {
"--version" => { "--version" => {
println!("{}", VERSION); println!("{VERSION}");
exit(0); exit(0);
} }
"--help" => { "--help" => {
@ -64,11 +64,11 @@ fn main() {
match eval(&expression, true, Unit::Celsius, verbose) { match eval(&expression, true, Unit::Celsius, verbose) {
Ok(answer) => { Ok(answer) => {
if !verbose { if !verbose {
println!("{}", answer); println!("{answer}");
} }
} }
Err(e) => { Err(e) => {
eprintln!("{}", e); eprintln!("{e}");
exit(1); exit(1);
} }
} }

418
src/units.rs
View File

@ -69,235 +69,253 @@ macro_rules! create_units {
),* ),*
} }
} }
pub(crate) fn singular(&self) -> &str {
match self {
$(
Unit::$variant => $properties.2
),*
}
}
pub(crate) fn plural(&self) -> &str {
match self {
$(
Unit::$variant => $properties.3
),*
}
}
} }
} }
} }
create_units!( create_units!(
NoUnit: (NoType, d128!(1)), NoUnit: (NoType, d128!(1), "", ""),
Nanosecond: (Time, d128!(1)), Nanosecond: (Time, d128!(1), "nanosecond", "nanoseconds"),
Microsecond: (Time, d128!(1000)), Microsecond: (Time, d128!(1000), "microsecond", "microseconds"),
Millisecond: (Time, d128!(1000000)), Millisecond: (Time, d128!(1000000), "millisecond", "milliseconds"),
Second: (Time, d128!(1000000000)), Second: (Time, d128!(1000000000), "second", "seconds"),
Minute: (Time, d128!(60000000000)), Minute: (Time, d128!(60000000000), "minute", "minutes"),
Hour: (Time, d128!(3600000000000)), Hour: (Time, d128!(3600000000000), "hour", "hours"),
Day: (Time, d128!(86400000000000)), Day: (Time, d128!(86400000000000), "day", "days"),
Week: (Time, d128!(604800000000000)), Week: (Time, d128!(604800000000000), "week", "weeks"),
Month: (Time, d128!(2629746000000000)), Month: (Time, d128!(2629746000000000), "month", "months"),
Quarter: (Time, d128!(7889238000000000)), Quarter: (Time, d128!(7889238000000000), "quarter", "quarters"),
Year: (Time, d128!(31556952000000000)), Year: (Time, d128!(31556952000000000), "year", "years"),
Decade: (Time, d128!(315569520000000000)), Decade: (Time, d128!(315569520000000000), "decade", "decades"),
Century: (Time, d128!(3155695200000000000)), Century: (Time, d128!(3155695200000000000), "century", "centuries"),
Millenium: (Time, d128!(31556952000000000000)), Millenium: (Time, d128!(31556952000000000000), "millenium", "millenia"),
Millimeter: (Length, d128!(1)), Millimeter: (Length, d128!(1), "millimeter", "millimeters"),
Centimeter: (Length, d128!(10)), Centimeter: (Length, d128!(10), "centimeter", "centimeters"),
Decimeter: (Length, d128!(100)), Decimeter: (Length, d128!(100), "decimeter", "decimeters"),
Meter: (Length, d128!(1000)), Meter: (Length, d128!(1000), "meter", "meters"),
Kilometer: (Length, d128!(1000000)), Kilometer: (Length, d128!(1000000), "kilometer", "kilometers"),
Inch: (Length, d128!(25.4)), Inch: (Length, d128!(25.4), "inch", "inches"),
Foot: (Length, d128!(304.8)), Foot: (Length, d128!(304.8), "foot", "feet"),
Yard: (Length, d128!(914.4)), Yard: (Length, d128!(914.4), "yard", "yards"),
Mile: (Length, d128!(1609344)), Mile: (Length, d128!(1609344), "mile", "miles"),
// 1-dimensional only: // 1-dimensional only:
Marathon: (Length, d128!(42195000)), Marathon: (Length, d128!(42195000), "marathon", "marathons"),
NauticalMile: (Length, d128!(1852000)), NauticalMile: (Length, d128!(1852000), "nautical mile", "nautical miles"),
LightYear: (Length, d128!(9460730472580800000)), LightYear: (Length, d128!(9460730472580800000), "light year", "light years"),
LightSecond: (Length, d128!(299792458000)), LightSecond: (Length, d128!(299792458000), "light second", "light seconds"),
SquareMillimeter: (Area, d128!(1)), SquareMillimeter: (Area, d128!(1), "square millimeter", "square millimeters"),
SquareCentimeter: (Area, d128!(100)), SquareCentimeter: (Area, d128!(100), "square centimeter", "square centimeters"),
SquareDecimeter: (Area, d128!(10000)), SquareDecimeter: (Area, d128!(10000), "square decimeter", "square decimeters"),
SquareMeter: (Area, d128!(1000000)), SquareMeter: (Area, d128!(1000000), "square meter", "square meters"),
SquareKilometer: (Area, d128!(1000000000000)), SquareKilometer: (Area, d128!(1000000000000), "square kilometer", "square kilometers"),
SquareInch: (Area, d128!(645.16)), SquareInch: (Area, d128!(645.16), "square inch", "square inches"),
SquareFoot: (Area, d128!(92903.04)), SquareFoot: (Area, d128!(92903.04), "square foot", "square feet"),
SquareYard: (Area, d128!(836127.36)), SquareYard: (Area, d128!(836127.36), "square yard", "square yards"),
SquareMile: (Area, d128!(2589988110336.00)), SquareMile: (Area, d128!(2589988110336.00), "square mile", "square miles"),
// 2-dimensional only // 2-dimensional only
Are: (Area, d128!(100000000)), Are: (Area, d128!(100000000), "are", "ares"),
Decare: (Area, d128!(1000000000)), Decare: (Area, d128!(1000000000), "decare", "decare"),
Hectare: (Area, d128!(10000000000)), Hectare: (Area, d128!(10000000000), "hectare", "hectares"),
Acre: (Area, d128!(4046856422.40)), Acre: (Area, d128!(4046856422.40), "acre", "acres"),
CubicMillimeter: (Volume, d128!(1)), CubicMillimeter: (Volume, d128!(1), "cubic millimeter", "cubic millimeters"),
CubicCentimeter: (Volume, d128!(1000)), CubicCentimeter: (Volume, d128!(1000), "cubic centimeter", "cubic centimeters"),
CubicDecimeter: (Volume, d128!(1000000)), CubicDecimeter: (Volume, d128!(1000000), "cubic decimeter", "cubic decimeters"),
CubicMeter: (Volume, d128!(1000000000)), CubicMeter: (Volume, d128!(1000000000), "cubic meter", "cubic meters"),
CubicKilometer: (Volume, d128!(1000000000000000000)), CubicKilometer: (Volume, d128!(1000000000000000000), "cubic kilometer", "cubic kilometers"),
CubicInch: (Volume, d128!(16387.064)), CubicInch: (Volume, d128!(16387.064), "cubic inch", "cubic inches"),
CubicFoot: (Volume, d128!(28316846.592)), CubicFoot: (Volume, d128!(28316846.592), "cubic foot", "cubic feet"),
CubicYard: (Volume, d128!(764554857.984)), CubicYard: (Volume, d128!(764554857.984), "cubic yard", "cubic yards"),
CubicMile: (Volume, d128!(4168181825440579584)), CubicMile: (Volume, d128!(4168181825440579584), "cubic mile", "cubic miles"),
// 3-dimensional only // 3-dimensional only
Milliliter: (Volume, d128!(1000)), Milliliter: (Volume, d128!(1000), "milliliter", "milliliters"),
Centiliter: (Volume, d128!(10000)), Centiliter: (Volume, d128!(10000), "centiliter", "centiliters"),
Deciliter: (Volume, d128!(100000)), Deciliter: (Volume, d128!(100000), "deciliter", "deciliters"),
Liter: (Volume, d128!(1000000)), Liter: (Volume, d128!(1000000), "liter", "liters"),
Teaspoon: (Volume, d128!(4928.92159375)), Teaspoon: (Volume, d128!(4928.92159375), "teaspoon", "teaspoons"),
Tablespoon: (Volume, d128!(14786.76478125)), Tablespoon: (Volume, d128!(14786.76478125), "tablespoon", "tablespoons"),
FluidOunce: (Volume, d128!(29573.5295625)), FluidOunce: (Volume, d128!(29573.5295625), "fluid ounce", "fluid ounces"),
Cup: (Volume, d128!(236588.2365)), Cup: (Volume, d128!(236588.2365), "cup", "cups"),
Pint: (Volume, d128!(473176.473)), Pint: (Volume, d128!(473176.473), "pint", "pints"),
Quart: (Volume, d128!(946352.946)), Quart: (Volume, d128!(946352.946), "quart", "quarts"),
Gallon: (Volume, d128!(3785411.784)), Gallon: (Volume, d128!(3785411.784), "gallon", "gallons"),
OilBarrel: (Volume, d128!(158987294.928)), OilBarrel: (Volume, d128!(158987294.928), "oil barrel", "oil barrels"),
Milligram: (Mass, d128!(0.001)), Milligram: (Mass, d128!(0.001), "milligram", "milligrams"),
Gram: (Mass, d128!(1)), Gram: (Mass, d128!(1), "gram", "grams"),
Hectogram: (Mass, d128!(100)), Hectogram: (Mass, d128!(100), "hectogram", "hectograms"),
Kilogram: (Mass, d128!(1000)), Kilogram: (Mass, d128!(1000), "kilogram", "kilograms"),
MetricTon: (Mass, d128!(1000000)), MetricTon: (Mass, d128!(1000000), "metric ton", "metric tons"),
Ounce: (Mass, d128!(28.349523125)), Ounce: (Mass, d128!(28.349523125), "ounce", "ounces"),
Pound: (Mass, d128!(453.59237)), Pound: (Mass, d128!(453.59237), "pound", "pounds"),
Stone: (Mass, d128!(6350.29318)), Stone: (Mass, d128!(6350.29318), "stone", "stones"),
ShortTon: (Mass, d128!(907184.74)), ShortTon: (Mass, d128!(907184.74), "short ton", "short tons"),
LongTon: (Mass, d128!(1016046.9088)), LongTon: (Mass, d128!(1016046.9088), "long ton", "long tons"),
Bit: (DigitalStorage, d128!(1)), Bit: (DigitalStorage, d128!(1), "bit", "bits"),
Kilobit: (DigitalStorage, d128!(1000)), Kilobit: (DigitalStorage, d128!(1000), "kilobit", "kilobits"),
Megabit: (DigitalStorage, d128!(1000000)), Megabit: (DigitalStorage, d128!(1000000), "megabit", "megabits"),
Gigabit: (DigitalStorage, d128!(1000000000)), Gigabit: (DigitalStorage, d128!(1000000000), "gigabit", "gigabits"),
Terabit: (DigitalStorage, d128!(1000000000000)), Terabit: (DigitalStorage, d128!(1000000000000), "terabit", "terabits"),
Petabit: (DigitalStorage, d128!(1000000000000000)), Petabit: (DigitalStorage, d128!(1000000000000000), "petabit", "petabits"),
Exabit: (DigitalStorage, d128!(1000000000000000000)), Exabit: (DigitalStorage, d128!(1000000000000000000), "exabit", "exabits"),
Zettabit: (DigitalStorage, d128!(1000000000000000000000)), Zettabit: (DigitalStorage, d128!(1000000000000000000000), "zettabit", "zettabits"),
Yottabit: (DigitalStorage, d128!(1000000000000000000000000)), Yottabit: (DigitalStorage, d128!(1000000000000000000000000), "yottabit", "yottabits"),
Kibibit: (DigitalStorage, d128!(1024)), Kibibit: (DigitalStorage, d128!(1024), "kibibit", "kibibits"),
Mebibit: (DigitalStorage, d128!(1048576)), Mebibit: (DigitalStorage, d128!(1048576), "mebibit", "mebibits"),
Gibibit: (DigitalStorage, d128!(1073741824)), Gibibit: (DigitalStorage, d128!(1073741824), "gibibit", "gibibits"),
Tebibit: (DigitalStorage, d128!(1099511627776)), Tebibit: (DigitalStorage, d128!(1099511627776), "tebibit", "tebibits"),
Pebibit: (DigitalStorage, d128!(1125899906842624)), Pebibit: (DigitalStorage, d128!(1125899906842624), "pebibit", "pebibits"),
Exbibit: (DigitalStorage, d128!(1152921504606846976)), Exbibit: (DigitalStorage, d128!(1152921504606846976), "exbibit", "exbibits"),
Zebibit: (DigitalStorage, d128!(1180591620717411303424)), Zebibit: (DigitalStorage, d128!(1180591620717411303424), "zebibit", "zebibits"),
Yobibit: (DigitalStorage, d128!(1208925819614629174706176)), Yobibit: (DigitalStorage, d128!(1208925819614629174706176), "yobibit", "yobibits"),
Byte: (DigitalStorage, d128!(8)), Byte: (DigitalStorage, d128!(8), "byte", "bytes"),
Kilobyte: (DigitalStorage, d128!(8000)), Kilobyte: (DigitalStorage, d128!(8000), "kilobyte", "kilobytes"),
Megabyte: (DigitalStorage, d128!(8000000)), Megabyte: (DigitalStorage, d128!(8000000), "megabyte", "megabytes"),
Gigabyte: (DigitalStorage, d128!(8000000000)), Gigabyte: (DigitalStorage, d128!(8000000000), "gigabyte", "gigabytes"),
Terabyte: (DigitalStorage, d128!(8000000000000)), Terabyte: (DigitalStorage, d128!(8000000000000), "terabyte", "terabytes"),
Petabyte: (DigitalStorage, d128!(8000000000000000)), Petabyte: (DigitalStorage, d128!(8000000000000000), "petabyte", "petabytes"),
Exabyte: (DigitalStorage, d128!(8000000000000000000)), Exabyte: (DigitalStorage, d128!(8000000000000000000), "exabyte", "exabytes"),
Zettabyte: (DigitalStorage, d128!(8000000000000000000000)), Zettabyte: (DigitalStorage, d128!(8000000000000000000000), "zettabyte", "zettabytes"),
Yottabyte: (DigitalStorage, d128!(8000000000000000000000000)), Yottabyte: (DigitalStorage, d128!(8000000000000000000000000), "yottabyte", "yottabytes"),
Kibibyte: (DigitalStorage, d128!(8192)), Kibibyte: (DigitalStorage, d128!(8192), "kibibyte", "kibibytes"),
Mebibyte: (DigitalStorage, d128!(8388608)), Mebibyte: (DigitalStorage, d128!(8388608), "mebibyte", "mebibytes"),
Gibibyte: (DigitalStorage, d128!(8589934592)), Gibibyte: (DigitalStorage, d128!(8589934592), "gibibyte", "gibibytes"),
Tebibyte: (DigitalStorage, d128!(8796093022208)), Tebibyte: (DigitalStorage, d128!(8796093022208), "tebibyte", "tebibytes"),
Pebibyte: (DigitalStorage, d128!(9007199254740992)), Pebibyte: (DigitalStorage, d128!(9007199254740992), "pebibyte", "pebibytes"),
Exbibyte: (DigitalStorage, d128!(9223372036854775808)), Exbibyte: (DigitalStorage, d128!(9223372036854775808), "exbibyte", "exbibytes"),
Zebibyte: (DigitalStorage, d128!(9444732965739290427392)), Zebibyte: (DigitalStorage, d128!(9444732965739290427392), "zebibyte", "zebibytes"),
Yobibyte: (DigitalStorage, d128!(9671406556917033397649408)), Yobibyte: (DigitalStorage, d128!(9671406556917033397649408), "yobibyte", "yobibytes"),
BitsPerSecond: (DataTransferRate, d128!(1)), BitsPerSecond: (DataTransferRate, d128!(1), "bit per second", "bits per second"),
KilobitsPerSecond: (DataTransferRate, d128!(1000)), KilobitsPerSecond: (DataTransferRate, d128!(1000), "kilobit per second", "kilobits per second"),
MegabitsPerSecond: (DataTransferRate, d128!(1000000)), MegabitsPerSecond: (DataTransferRate, d128!(1000000), "megabit per second", "megabits per second"),
GigabitsPerSecond: (DataTransferRate, d128!(1000000000)), GigabitsPerSecond: (DataTransferRate, d128!(1000000000), "gigabit per second", "gigabits per second"),
TerabitsPerSecond: (DataTransferRate, d128!(1000000000000)), TerabitsPerSecond: (DataTransferRate, d128!(1000000000000), "terabit per second", "terabits per second"),
PetabitsPerSecond: (DataTransferRate, d128!(1000000000000000)), PetabitsPerSecond: (DataTransferRate, d128!(1000000000000000), "petabit per second", "petabits per second"),
ExabitsPerSecond: (DataTransferRate, d128!(1000000000000000000)), ExabitsPerSecond: (DataTransferRate, d128!(1000000000000000000), "exabit per second", "exabits per second"),
ZettabitsPerSecond: (DataTransferRate, d128!(1000000000000000000000)), ZettabitsPerSecond: (DataTransferRate, d128!(1000000000000000000000), "zettabit per second", "zettabits per second"),
YottabitsPerSecond: (DataTransferRate, d128!(1000000000000000000000000)), YottabitsPerSecond: (DataTransferRate, d128!(1000000000000000000000000), "yottabit per second", "yottabits per second"),
KibibitsPerSecond: (DataTransferRate, d128!(1024)), KibibitsPerSecond: (DataTransferRate, d128!(1024), "kibibit per second", "kibibits per second"),
MebibitsPerSecond: (DataTransferRate, d128!(1048576)), MebibitsPerSecond: (DataTransferRate, d128!(1048576), "mebibit per second", "mebibits per second"),
GibibitsPerSecond: (DataTransferRate, d128!(1073741824)), GibibitsPerSecond: (DataTransferRate, d128!(1073741824), "gibibit per second", "gibibits per second"),
TebibitsPerSecond: (DataTransferRate, d128!(1099511627776)), TebibitsPerSecond: (DataTransferRate, d128!(1099511627776), "tebibit per second", "tebibits per second"),
PebibitsPerSecond: (DataTransferRate, d128!(1125899906842624)), PebibitsPerSecond: (DataTransferRate, d128!(1125899906842624), "pebibit per second", "pebibits per second"),
ExbibitsPerSecond: (DataTransferRate, d128!(1152921504606846976)), ExbibitsPerSecond: (DataTransferRate, d128!(1152921504606846976), "exbibit per second", "exbibits per second"),
ZebibitsPerSecond: (DataTransferRate, d128!(1180591620717411303424)), ZebibitsPerSecond: (DataTransferRate, d128!(1180591620717411303424), "zebibit per second", "zebibits per second"),
YobibitsPerSecond: (DataTransferRate, d128!(1208925819614629174706176)), YobibitsPerSecond: (DataTransferRate, d128!(1208925819614629174706176), "yobibit per second", "yobibits per second"),
BytesPerSecond: (DataTransferRate, d128!(8)), BytesPerSecond: (DataTransferRate, d128!(8), "byte per second", "bytes per second"),
KilobytesPerSecond: (DataTransferRate, d128!(8000)), KilobytesPerSecond: (DataTransferRate, d128!(8000), "kilobyte per second", "kilobytes per second"),
MegabytesPerSecond: (DataTransferRate, d128!(8000000)), MegabytesPerSecond: (DataTransferRate, d128!(8000000), "megabyte per second", "megabytes per second"),
GigabytesPerSecond: (DataTransferRate, d128!(8000000000)), GigabytesPerSecond: (DataTransferRate, d128!(8000000000), "gigabyte per second", "gigabytes per second"),
TerabytesPerSecond: (DataTransferRate, d128!(8000000000000)), TerabytesPerSecond: (DataTransferRate, d128!(8000000000000), "terabyte per second", "terabytes per second"),
PetabytesPerSecond: (DataTransferRate, d128!(8000000000000000)), PetabytesPerSecond: (DataTransferRate, d128!(8000000000000000), "petabyte per second", "petabytes per second"),
ExabytesPerSecond: (DataTransferRate, d128!(8000000000000000000)), ExabytesPerSecond: (DataTransferRate, d128!(8000000000000000000), "exabyte per second", "exabytes per second"),
ZettabytesPerSecond: (DataTransferRate, d128!(8000000000000000000000)), ZettabytesPerSecond: (DataTransferRate, d128!(8000000000000000000000), "zettabyte per second", "zettabytes per second"),
YottabytesPerSecond: (DataTransferRate, d128!(8000000000000000000000000)), YottabytesPerSecond: (DataTransferRate, d128!(8000000000000000000000000), "yottabyte per second", "yottabytes per second"),
KibibytesPerSecond: (DataTransferRate, d128!(8192)), KibibytesPerSecond: (DataTransferRate, d128!(8192), "kibibyte per second", "kibibytes per second"),
MebibytesPerSecond: (DataTransferRate, d128!(8388608)), MebibytesPerSecond: (DataTransferRate, d128!(8388608), "mebibyte per second", "mebibytes per second"),
GibibytesPerSecond: (DataTransferRate, d128!(8589934592)), GibibytesPerSecond: (DataTransferRate, d128!(8589934592), "gibibyte per second", "gibibytes per second"),
TebibytesPerSecond: (DataTransferRate, d128!(8796093022208)), TebibytesPerSecond: (DataTransferRate, d128!(8796093022208), "tebibyte per second", "tebibytes per second"),
PebibytesPerSecond: (DataTransferRate, d128!(9007199254740992)), PebibytesPerSecond: (DataTransferRate, d128!(9007199254740992), "pebibyte per second", "pebibytes per second"),
ExbibytesPerSecond: (DataTransferRate, d128!(9223372036854775808)), ExbibytesPerSecond: (DataTransferRate, d128!(9223372036854775808), "exbibyte per second", "exbibytes per second"),
ZebibytesPerSecond: (DataTransferRate, d128!(9444732965739290427392)), ZebibytesPerSecond: (DataTransferRate, d128!(9444732965739290427392), "zebibyte per second", "zebibytes per second"),
YobibytesPerSecond: (DataTransferRate, d128!(9671406556917033397649408)), YobibytesPerSecond: (DataTransferRate, d128!(9671406556917033397649408), "yobibyte per second", "yobibytes per second"),
// ! If updating Millijoule, also update get_inverted_millijoule_weight() // ! If updating Millijoule, also update get_inverted_millijoule_weight()
Millijoule: (Energy, d128!(0.001)), Millijoule: (Energy, d128!(0.001), "millijoule", "millijoules"),
Joule: (Energy, d128!(1)), Joule: (Energy, d128!(1), "joule", "joules"),
NewtonMeter: (Energy, d128!(1)), NewtonMeter: (Energy, d128!(1), "newton meter", "newton meters"),
Kilojoule: (Energy, d128!(1000)), Kilojoule: (Energy, d128!(1000), "kilojoule", "kilojoules"),
Megajoule: (Energy, d128!(1000000)), Megajoule: (Energy, d128!(1000000), "megajoule", "megajoules"),
Gigajoule: (Energy, d128!(1000000000)), Gigajoule: (Energy, d128!(1000000000), "gigajoule", "gigajoules"),
Terajoule: (Energy, d128!(1000000000000)), Terajoule: (Energy, d128!(1000000000000), "terajoule", "terajoules"),
Calorie: (Energy, d128!(4.1868)), Calorie: (Energy, d128!(4.1868), "calorie", "calories"),
KiloCalorie: (Energy, d128!(4186.8)), KiloCalorie: (Energy, d128!(4186.8), "kilocalorie", "kilocalories"),
BritishThermalUnit: (Energy, d128!(1055.05585262)), BritishThermalUnit: (Energy, d128!(1055.05585262), "British thermal unit", "British thermal units"),
WattHour: (Energy, d128!(3600)), WattHour: (Energy, d128!(3600), "watt-hour", "watt-hours"),
KilowattHour: (Energy, d128!(3600000)), KilowattHour: (Energy, d128!(3600000), "kilowatt-hour", "kilowatt-hours"),
MegawattHour: (Energy, d128!(3600000000)), MegawattHour: (Energy, d128!(3600000000), "megawatt-hour", "megawatt-hours"),
GigawattHour: (Energy, d128!(3600000000000)), GigawattHour: (Energy, d128!(3600000000000), "gigawatt-hour", "gigawatt-hours"),
TerawattHour: (Energy, d128!(3600000000000000)), TerawattHour: (Energy, d128!(3600000000000000), "terawatt-hour", "terawatt-hours"),
PetawattHour: (Energy, d128!(3600000000000000000)), PetawattHour: (Energy, d128!(3600000000000000000), "petawatt-hour", "petawatt-hours"),
// ! If updating Milliwatt, also update get_inverted_milliwatt_weight() // ! If updating Milliwatt, also update get_inverted_milliwatt_weight()
Milliwatt: (Power, d128!(0.001)), Milliwatt: (Power, d128!(0.001), "milliwatt", "milliwatts"),
Watt: (Power, d128!(1)), Watt: (Power, d128!(1), "watt", "watts"),
Kilowatt: (Power, d128!(1000)), Kilowatt: (Power, d128!(1000), "kilowatt", "kilowatts"),
Megawatt: (Power, d128!(1000000)), Megawatt: (Power, d128!(1000000), "megawatt", "megawatts"),
Gigawatt: (Power, d128!(1000000000)), Gigawatt: (Power, d128!(1000000000), "gigawatt", "gigawatts"),
Terawatt: (Power, d128!(1000000000000)), Terawatt: (Power, d128!(1000000000000), "terawatt", "terawatts"),
Petawatt: (Power, d128!(1000000000000000)), Petawatt: (Power, d128!(1000000000000000), "petawatt", "petawatts"),
BritishThermalUnitsPerMinute: (Power, d128!(0.0568690272188)), // probably inexact // probably inexact:
BritishThermalUnitsPerHour: (Power, d128!(3.412141633128)), // probably inexact BritishThermalUnitsPerMinute: (Power, d128!(0.0568690272188), "british thermal unit per minute", "british thermal units per minute"),
Horsepower: (Power, d128!(745.69987158227022)), // exact according to wikipedia // probably inexact:
MetricHorsepower: (Power, d128!(735.49875)), BritishThermalUnitsPerHour: (Power, d128!(3.412141633128), "british thermal unit per hour", "british thermal units per hour"),
// exact according to wikipedia:
Horsepower: (Power, d128!(745.69987158227022), "horsepower", "horsepower"),
MetricHorsepower: (Power, d128!(735.49875), "metric horsepower", "metric horsepower"),
// ! If updating Milliampere, also update get_inverted_milliampere_weight() // ! If updating Milliampere, also update get_inverted_milliampere_weight()
Milliampere: (ElectricCurrent, d128!(0.001)), Milliampere: (ElectricCurrent, d128!(0.001), "milliampere", "milliamperes"),
Ampere: (ElectricCurrent, d128!(1)), Ampere: (ElectricCurrent, d128!(1), "ampere", "amperes"),
Kiloampere: (ElectricCurrent, d128!(1000)), Kiloampere: (ElectricCurrent, d128!(1000), "kiloampere", "kiloamperes"),
Abampere: (ElectricCurrent, d128!(10)), Abampere: (ElectricCurrent, d128!(10), "abampere", "abamperes"),
// ! If updating Milliohm, also update get_inverted_milliohm_weight() // ! If updating Milliohm, also update get_inverted_milliohm_weight()
Milliohm: (Resistance, d128!(0.001)), Milliohm: (Resistance, d128!(0.001), "milliohm", "milliohms"),
Ohm: (Resistance, d128!(1)), Ohm: (Resistance, d128!(1), "ohm", "ohms"),
Kiloohm: (Resistance, d128!(1000)), Kiloohm: (Resistance, d128!(1000), "kiloohm", "kiloohms"),
// ! If updating Millivolt, also update get_inverted_millivolt_weight() // ! If updating Millivolt, also update get_inverted_millivolt_weight()
Millivolt: (Voltage, d128!(0.001)), Millivolt: (Voltage, d128!(0.001), "millivolt", "millivolts"),
Volt: (Voltage, d128!(1)), Volt: (Voltage, d128!(1), "volt", "volts"),
Kilovolt: (Voltage, d128!(1000)), Kilovolt: (Voltage, d128!(1000), "kilovolt", "kilovolts"),
Pascal: (Pressure, d128!(1)), Pascal: (Pressure, d128!(1), "pascal", "pascals"),
Kilopascal: (Pressure, d128!(1000)), Kilopascal: (Pressure, d128!(1000), "kilopascal", "kilopascals"),
Atmosphere: (Pressure, d128!(101325)), Atmosphere: (Pressure, d128!(101325), "atmosphere", "atmospheres"),
Millibar: (Pressure, d128!(100)), Millibar: (Pressure, d128!(100), "millibar", "millibars"),
Bar: (Pressure, d128!(100000)), Bar: (Pressure, d128!(100000), "bar", "bars"),
InchOfMercury: (Pressure, d128!(3386.389)), InchOfMercury: (Pressure, d128!(3386.389), "inch of mercury", "inches of mercury"),
PoundsPerSquareInch: (Pressure, d128!(6894.757293168361)), // inexact // inexact:
Torr: (Pressure, d128!(162.12)), PoundsPerSquareInch: (Pressure, d128!(6894.757293168361), "pound per square inch", "pounds per square inch"),
Torr: (Pressure, d128!(162.12), "torr", "torr"),
Hertz: (Frequency, d128!(1)), Hertz: (Frequency, d128!(1), "hertz", "hertz"),
Kilohertz: (Frequency, d128!(1000)), Kilohertz: (Frequency, d128!(1000), "kilohertz", "kilohertz"),
Megahertz: (Frequency, d128!(1000000)), Megahertz: (Frequency, d128!(1000000), "megahertz", "megahertz"),
Gigahertz: (Frequency, d128!(1000000000)), Gigahertz: (Frequency, d128!(1000000000), "gigahertz", "gigahertz"),
Terahertz: (Frequency, d128!(1000000000000)), Terahertz: (Frequency, d128!(1000000000000), "terahertz", "terahertz"),
Petahertz: (Frequency, d128!(1000000000000000)), Petahertz: (Frequency, d128!(1000000000000000), "petahertz", "petahertz"),
RevolutionsPerMinute: (Frequency, d128!(60)), RevolutionsPerMinute: (Frequency, d128!(60), "revolution per minute", "revolutions per minute"),
KilometersPerHour: (Speed, d128!(1)), KilometersPerHour: (Speed, d128!(1), "kilometer per hour", "kilometers per hour"),
MetersPerSecond: (Speed, d128!(3.6)), MetersPerSecond: (Speed, d128!(3.6), "meter per second", "meters per second"),
MilesPerHour: (Speed, d128!(1.609344)), MilesPerHour: (Speed, d128!(1.609344), "mile per hour", "miles per hour"),
FeetPerSecond: (Speed, d128!(1.09728)), FeetPerSecond: (Speed, d128!(1.09728), "foot per second", "feet per second"),
Knot: (Speed, d128!(1.852)), Knot: (Speed, d128!(1.852), "knot", "knots"),
Kelvin: (Temperature, d128!(0)), Kelvin: (Temperature, d128!(0), "kelvin", "kelvin"),
Celsius: (Temperature, d128!(0)), Celsius: (Temperature, d128!(0), "celsius", "celsius"),
Fahrenheit: (Temperature, d128!(0)), Fahrenheit: (Temperature, d128!(0), "fahrenheit", "fahrenheit"),
); );
// These functions are here to avoid dividing by small numbers like 0.01, // These functions are here to avoid dividing by small numbers like 0.01,