Improve formatting of numbers, closes #20
This commit is contained in:
Kasper
parent
681e117453
commit
2ccf25affc
@ -1,5 +1,8 @@
|
||||
# Changelog
|
||||
|
||||
## Next
|
||||
- Improve formatting of numbers
|
||||
|
||||
## 1.9.0 - 2022 Dec 30
|
||||
- Add `marathon` unit
|
||||
- Add `aarch64` binaries
|
||||
|
||||
@ -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}")
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
10
src/lexer.rs
10
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<Token>| {
|
||||
@ -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)]);
|
||||
|
||||
18
src/lib.rs
18
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}")
|
||||
/// }
|
||||
/// }
|
||||
/// ```
|
||||
|
||||
@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
418
src/units.rs
418
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,
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user