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