+3

CHANGELOG.md

Reviewed

··· 1 1 # Changelog 2 2 3 3 ## Next 4 4 + - Rewrite units to be exponent-based, making units much more powerful 5 5 + - Add generic unit multiplication/division, such as `1kg/1m` or `1m*1kg`. 6 6 + - Add generic unit simplification. For example, `1kg*1sqm/1s/1s/1s/1a` now becomes `1 volt` 4 7 - Fix `^` allowing numbers to be raised to the power of units 5 8 6 9 ## 3.1.0 - 2025 Jun 20

+88 -58

src/evaluator.rs

Reviewed

··· 1 1 - use crate::lookup::{lookup_factorial, lookup_named_number}; 2 2 - use crate::parser::AstNode; 3 3 - use crate::units::{add, convert, divide, modulo, multiply, pow, subtract, Unit, UnitType}; 4 4 - use crate::Constant::{Pi, E}; 1 1 + use crate::Constant::{E, Pi}; 5 2 use crate::FunctionIdentifier::*; 6 3 use crate::Operator::{Caret, Divide, Minus, Modulo, Multiply, Plus}; 7 4 use crate::TextOperator::{Of, To}; 8 5 use crate::UnaryOperator::{Factorial, Percent}; 6 6 + use crate::lookup::{lookup_factorial, lookup_named_number}; 7 7 + use crate::parser::AstNode; 8 8 + use crate::units::{add, convert, divide, modulo, multiply, pow, subtract}; 9 9 use crate::{Number, Token}; 10 10 - use fastnum::{dec128 as d, decimal::RoundingMode, D128}; 10 10 + use fastnum::{D128, dec128 as d, decimal::RoundingMode}; 11 11 12 12 /// Evaluate an [`AstNode`] into a [`Number`] 13 13 pub fn evaluate(ast: &AstNode) -> Result<Number, String> { ··· 61 61 let token = &ast_node.token; 62 62 let children = &ast_node.children; 63 63 match token { 64 64 - Token::Number(number) => Ok(Number::new(*number, Unit::NoUnit)), 64 64 + Token::Number(number) => Ok(Number::new_unitless(*number)), 65 65 Token::Constant(constant) => match constant { 66 66 - Pi => Ok(Number::new( 67 67 - D128::PI, 68 68 - Unit::NoUnit, 69 69 - )), 70 70 - E => Ok(Number::new( 71 71 - D128::E, 72 72 - Unit::NoUnit, 73 73 - )), 66 66 + Pi => Ok(Number::new_unitless(D128::PI)), 67 67 + E => Ok(Number::new_unitless(D128::E)), 74 68 }, 75 69 Token::FunctionIdentifier(function) => { 76 70 let child_node = children.get(0).ok_or("Paren has no child[0]")?; 77 71 let child_answer = evaluate_node(child_node)?; 78 72 match function { 79 73 Cbrt => { 80 80 - if child_answer.unit.category() == UnitType::NoType { 74 74 + if child_answer.is_unitless() { 81 75 let result = cbrt(child_answer.value); 82 82 - Ok(Number::new(result, child_answer.unit)) 76 76 + Ok(Number::with_unit(result, child_answer.unit)) 83 77 } else { 84 84 - Err("log() only accepts UnitType::NoType".to_string()) 78 78 + Err("cbrt() only accepts unitless numbers".to_string()) 85 79 } 86 80 } 87 81 Sqrt => { 88 88 - if child_answer.unit.category() == UnitType::NoType { 82 82 + if child_answer.is_unitless() { 89 83 let result = sqrt(child_answer.value); 90 90 - Ok(Number::new(result, child_answer.unit)) 84 84 + Ok(Number::with_unit(result, child_answer.unit)) 91 85 } else { 92 92 - Err("log() only accepts UnitType::NoType".to_string()) 86 86 + Err("sqrt() only accepts unitless numbers".to_string()) 93 87 } 94 88 } 95 89 Log => { 96 96 - if child_answer.unit.category() == UnitType::NoType { 90 90 + if child_answer.is_unitless() { 97 91 let result = child_answer.value.log10(); 98 98 - Ok(Number::new(result, child_answer.unit)) 92 92 + Ok(Number::with_unit(result, child_answer.unit)) 99 93 } else { 100 100 - Err("log() only accepts UnitType::NoType".to_string()) 94 94 + Err("log() only accepts unitless numbers".to_string()) 101 95 } 102 96 } 103 97 Ln => { 104 104 - if child_answer.unit.category() == UnitType::NoType { 98 98 + if child_answer.is_unitless() { 105 99 let result = child_answer.value.ln(); 106 106 - Ok(Number::new(result, child_answer.unit)) 100 100 + Ok(Number::with_unit(result, child_answer.unit)) 107 101 } else { 108 108 - Err("ln() only accepts UnitType::NoType".to_string()) 102 102 + Err("ln() only accepts unitless numbers".to_string()) 109 103 } 110 104 } 111 105 Exp => { 112 112 - if child_answer.unit.category() == UnitType::NoType { 106 106 + if child_answer.is_unitless() { 113 107 let result = child_answer.value.exp(); 114 114 - Ok(Number::new(result, child_answer.unit)) 108 108 + Ok(Number::with_unit(result, child_answer.unit)) 115 109 } else { 116 116 - Err("exp() only accepts UnitType::NoType".to_string()) 110 110 + Err("exp() only accepts unitless numbers".to_string()) 117 111 } 118 112 } 119 113 Round => { ··· 122 116 .value 123 117 .with_rounding_mode(RoundingMode::HalfUp) 124 118 .round(0); 125 125 - Ok(Number::new(result, child_answer.unit)) 119 119 + Ok(Number::with_unit(result, child_answer.unit)) 126 120 } 127 121 Ceil => { 128 122 let result = child_answer.value.ceil(); 129 129 - Ok(Number::new(result, child_answer.unit)) 123 123 + Ok(Number::with_unit(result, child_answer.unit)) 130 124 } 131 125 Floor => { 132 126 let result = child_answer.value.floor(); 133 133 - Ok(Number::new(result, child_answer.unit)) 127 127 + Ok(Number::with_unit(result, child_answer.unit)) 134 128 } 135 129 Abs => { 136 130 let result = child_answer.value.abs(); 137 137 - Ok(Number::new(result, child_answer.unit)) 131 131 + Ok(Number::with_unit(result, child_answer.unit)) 138 132 } 139 133 Sin => { 140 134 let result = sin(child_answer.value); 141 141 - Ok(Number::new(result, child_answer.unit)) 135 135 + Ok(Number::with_unit(result, child_answer.unit)) 142 136 } 143 137 Cos => { 144 138 let result = cos(child_answer.value); 145 145 - Ok(Number::new(result, child_answer.unit)) 139 139 + Ok(Number::with_unit(result, child_answer.unit)) 146 140 } 147 141 Tan => { 148 142 let result = tan(child_answer.value); 149 149 - Ok(Number::new(result, child_answer.unit)) 143 143 + Ok(Number::with_unit(result, child_answer.unit)) 150 144 } 151 145 } 152 146 } 153 147 Token::Unit(unit) => { 154 148 let child_node = children.get(0).ok_or("Unit has no child[0]")?; 155 149 let child_answer = evaluate_node(child_node)?; 156 156 - Ok(Number::new(child_answer.value, *unit)) 150 150 + Ok(Number::with_basic_unit(child_answer.value, *unit)) 157 151 } 158 152 Token::Negative => { 159 153 let child_node = children.get(0).ok_or("Negative has no child[0]")?; 160 154 let child_answer = evaluate_node(child_node)?; 161 161 - Ok(Number::new(-child_answer.value, child_answer.unit)) 155 155 + Ok(Number::with_unit(-child_answer.value, child_answer.unit)) 162 156 } 163 157 Token::Paren => { 164 158 let child_node = children.get(0).ok_or("Paren has no child[0]")?; ··· 170 164 .ok_or(format!("Token {:?} has no child[0]", token))?; 171 165 let child_answer = evaluate_node(child_node)?; 172 166 match operator { 173 173 - Percent => Ok(Number::new( 167 167 + Percent => Ok(Number::with_unit( 174 168 child_answer.value / d!(100), 175 169 child_answer.unit, 176 170 )), ··· 181 175 "Can only perform factorial on integers from 0 to 1000".to_string() 182 176 ); 183 177 } 184 184 - Ok(Number::new(result, child_answer.unit)) 178 178 + Ok(Number::with_unit(result, child_answer.unit)) 185 179 } 186 180 } 187 181 } ··· 198 192 } 199 193 let child_answer = evaluate_node(child_node)?; 200 194 let result = child_answer.value * named_number_value; 201 201 - Ok(Number::new(result, child_answer.unit)) 195 195 + Ok(Number::with_unit(result, child_answer.unit)) 202 196 } 203 197 Token::TextOperator(operator) => { 204 198 let left_child = children ··· 212 206 To => { 213 207 if let Token::Unit(right_unit) = right_child.token { 214 208 let left = evaluate_node(left_child)?; 215 215 - let result = convert(left, right_unit)?; 209 209 + let result = convert(left, vec![(right_unit, 1)])?; 216 210 Ok(result) 217 211 } else { 218 212 Err("Right side of To operator needs to be a unit".to_string()) ··· 221 215 Of => { 222 216 let left = evaluate_node(left_child)?; 223 217 let right = evaluate_node(right_child)?; 224 224 - if left.unit == Unit::NoUnit { 225 225 - Ok(Number::new(left.value * right.value, right.unit)) 218 218 + if left.is_unitless() { 219 219 + Ok(Number::with_unit(left.value * right.value, right.unit)) 226 220 } else { 227 221 Err("Left side of the Of operator must be NoUnit".to_string()) 228 222 } ··· 254 248 255 249 #[cfg(test)] 256 250 mod tests { 257 257 - use crate::eval; 258 251 use super::*; 252 252 + use crate::{eval, units::Unit::*}; 259 253 260 254 fn eval_default<'a>(input: &'a str) -> Number { 261 255 let result = eval(input, true, false).unwrap(); ··· 263 257 } 264 258 fn eval_num<'a>(input: &'a str) -> String { 265 259 let result = eval(input, true, false).unwrap(); 266 266 - assert_eq!(result.unit, Unit::NoUnit); 260 260 + assert!(result.is_unitless()); 267 261 268 262 result.to_string() 269 263 } ··· 273 267 assert_eq!(eval_num("-2(-3)"), "6"); 274 268 assert_eq!(eval_num("-2(3)"), "-6"); 275 269 assert_eq!(eval_num("(3)-2"), "1"); 276 276 - assert_eq!(eval_default("-1km to m"), Number::new(d!(-1000), Unit::Meter)); 270 270 + assert_eq!( 271 271 + eval_default("-1km to m"), 272 272 + Number::with_basic_unit(d!(-1000), Meter) 273 273 + ); 277 274 assert_eq!(eval_num("2*-3*0.5"), "-3"); 278 275 assert_eq!(eval_num("-3^2"), "-9"); 279 276 assert_eq!(eval_num("e^2"), "7.3890560989306502272304274605750078132"); 280 280 - assert_eq!(eval_num("e^2.5"), "12.1824939607034734380701759511679661832"); 277 277 + assert_eq!( 278 278 + eval_num("e^2.5"), 279 279 + "12.1824939607034734380701759511679661832" 280 280 + ); 281 281 assert_eq!(eval_num("-1+2"), "1"); 282 282 } 283 283 284 284 #[test] 285 285 fn test_functions() { 286 286 assert_eq!(eval_num("cbrt(125)"), "5"); 287 287 - assert_eq!(eval_num("cbrt(2)"), "1.25992104989487316476721060727822835057"); 287 287 + assert_eq!( 288 288 + eval_num("cbrt(2)"), 289 289 + "1.25992104989487316476721060727822835057" 290 290 + ); 288 291 289 292 assert_eq!(eval_num("sqrt(25)"), "5"); 290 290 - assert_eq!(eval_num("sqrt(2)"), "1.41421356237309504880168872420969807857"); 293 293 + assert_eq!( 294 294 + eval_num("sqrt(2)"), 295 295 + "1.41421356237309504880168872420969807857" 296 296 + ); 291 297 292 298 assert_eq!(eval_num("log(100)"), "2"); 293 293 - assert_eq!(eval_num("log(2)"), "0.301029995663981195213738894724493026768"); 299 299 + assert_eq!( 300 300 + eval_num("log(2)"), 301 301 + "0.301029995663981195213738894724493026768" 302 302 + ); 294 303 295 304 assert_eq!(eval_num("ln(1)"), "0"); 296 296 - assert_eq!(eval_num("ln(2)"), "0.69314718055994530941723212145817656808"); 305 305 + assert_eq!( 306 306 + eval_num("ln(2)"), 307 307 + "0.69314718055994530941723212145817656808" 308 308 + ); 297 309 assert_eq!(eval_num("ln(e)"), "1"); 298 310 assert_eq!(eval_num("ln(e^2)"), "2"); 299 311 300 300 - assert_eq!(eval_num("exp(1)"), "2.71828182845904523536028747135266249776"); 312 312 + assert_eq!( 313 313 + eval_num("exp(1)"), 314 314 + "2.71828182845904523536028747135266249776" 315 315 + ); 301 316 302 317 assert_eq!(eval_num("round(1.4)"), "1"); 303 318 assert_eq!(eval_num("round(1.6)"), "2"); ··· 312 327 313 328 assert_eq!(eval_num("abs(-3)"), "3"); 314 329 315 315 - assert_eq!(eval_num("sin(2)"), "0.9092974268256816953960198659117448427"); 316 316 - assert_eq!(eval_num("sin(-2)"), "-0.9092974268256816953960198659117448427"); 330 330 + assert_eq!( 331 331 + eval_num("sin(2)"), 332 332 + "0.9092974268256816953960198659117448427" 333 333 + ); 334 334 + assert_eq!( 335 335 + eval_num("sin(-2)"), 336 336 + "-0.9092974268256816953960198659117448427" 337 337 + ); 317 338 318 318 - assert_eq!(eval_num("cos(2)"), "-0.41614683654714238699756822950076218977"); 319 319 - assert_eq!(eval_num("cos(-2)"), "-0.41614683654714238699756822950076218977"); 320 320 - assert_eq!(eval_num("tan(2)"), "-2.18503986326151899164330610231368254343"); 339 339 + assert_eq!( 340 340 + eval_num("cos(2)"), 341 341 + "-0.41614683654714238699756822950076218977" 342 342 + ); 343 343 + assert_eq!( 344 344 + eval_num("cos(-2)"), 345 345 + "-0.41614683654714238699756822950076218977" 346 346 + ); 347 347 + assert_eq!( 348 348 + eval_num("tan(2)"), 349 349 + "-2.18503986326151899164330610231368254343" 350 350 + ); 321 351 } 322 352 }

+1457 -532

src/lexer.rs

Reviewed

··· 1 1 - use std::iter::Peekable; 2 2 - use fastnum::decimal::Context; 3 3 - use fastnum::D128; 4 4 - use crate::Token; 1 1 + use crate::Constant::{E, Pi}; 2 2 + use crate::FunctionIdentifier::{Abs, Cbrt, Ceil, Cos, Exp, Floor, Ln, Log, Round, Sin, Sqrt, Tan}; 3 3 + use crate::LexerKeyword::{ 4 4 + DoubleQuotes, Force, Hg, In, Mercury, Per, PercentChar, PoundForce, Revolution, 5 5 + }; 6 6 + use crate::NamedNumber::*; 5 7 use crate::Operator::{Caret, Divide, LeftParen, Minus, Modulo, Multiply, Plus, RightParen}; 6 6 - use crate::UnaryOperator::{Percent, Factorial}; 7 8 use crate::TextOperator::{Of, To}; 8 8 - use crate::NamedNumber::*; 9 9 - use crate::Constant::{E, Pi}; 10 10 - use crate::LexerKeyword::{In, PercentChar, Per, Mercury, Hg, PoundForce, Force, DoubleQuotes, Revolution}; 11 11 - use crate::FunctionIdentifier::{Cbrt, Ceil, Cos, Exp, Abs, Floor, Ln, Log, Round, Sin, Sqrt, Tan}; 9 9 + use crate::Token; 10 10 + use crate::UnaryOperator::{Factorial, Percent}; 12 11 use crate::units::Unit::*; 12 12 + use fastnum::D128; 13 13 + use fastnum::decimal::Context; 14 14 + use std::iter::Peekable; 13 15 use unicode_segmentation::{Graphemes, UnicodeSegmentation}; 14 16 15 17 fn is_word_char_str(input: &str) -> bool { 16 18 match input { 17 17 - "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" 18 18 - | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" 19 19 - | "Y" | "Z" => true, 20 20 - "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" 21 21 - | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" 22 22 - | "y" | "z" => true, 19 19 + "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" 20 20 + | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z" => true, 21 21 + "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" 22 22 + | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" => true, 23 23 "Ω" | "Ω" | "µ" | "μ" => true, 24 24 _ => false, 25 25 } 26 26 } 27 27 28 28 fn is_numeric_str(input: &str) -> bool { 29 29 - matches!(input, "." | "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9") 29 29 + matches!( 30 30 + input, 31 31 + "." | "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" 32 32 + ) 30 33 } 31 34 32 35 /// Read next characters as a word, otherwise return empty string. ··· 70 73 "2" | "²" => { 71 74 word += "2"; 72 75 chars.next(); 73 73 - }, 76 76 + } 74 77 "3" | "³" => { 75 78 word += "3"; 76 79 chars.next(); 77 77 - }, 78 78 - _ => {}, 80 80 + } 81 81 + _ => {} 79 82 } 80 83 } 81 84 word ··· 84 87 fn parse_token(c: &str, lexer: &mut Lexer) -> Result<(), String> { 85 88 let tokens = &mut lexer.tokens; 86 89 match c { 87 87 - value if value.trim().is_empty() => {}, 90 90 + value if value.trim().is_empty() => {} 88 91 value if is_word_char_str(value) => { 89 92 parse_word(read_word(c, lexer).as_str(), lexer)?; 90 90 - }, 93 93 + } 91 94 value if is_numeric_str(value) => { 92 95 let mut number_string = value.to_owned(); 93 96 while let Some(number_char) = lexer.chars.peek() { ··· 101 104 match D128::from_str(&number_string, Context::default()) { 102 105 Ok(number) => { 103 106 tokens.push(Token::Number(number)); 104 104 - }, 107 107 + } 105 108 Err(_e) => { 106 109 return Err(format!("Error lexing d128 number: {}", number_string)); 107 110 } 108 111 }; 109 109 - }, 112 112 + } 110 113 "+" => tokens.push(Token::Operator(Plus)), 111 114 "-" => tokens.push(Token::Operator(Minus)), 112 115 "*" => tokens.push(Token::Operator(Multiply)), ··· 117 120 "(" => { 118 121 lexer.left_paren_count += 1; 119 122 tokens.push(Token::Operator(LeftParen)); 120 120 - }, 123 123 + } 121 124 ")" => { 122 125 lexer.right_paren_count += 1; 123 126 tokens.push(Token::Operator(RightParen)); 124 124 - }, 127 127 + } 125 128 "π" => tokens.push(Token::Constant(Pi)), 126 129 "'" => tokens.push(Token::Unit(Foot)), 127 130 "\"" | "“" | "”" | "″" => tokens.push(Token::LexerKeyword(DoubleQuotes)), 128 131 _ => { 129 132 return Err(format!("Invalid character: {}", c)); 130 130 - }, 133 133 + } 131 134 } 132 135 Ok(()) 133 136 } ··· 135 138 fn parse_word_if_non_empty(word: &str, lexer: &mut Lexer) -> Result<(), String> { 136 139 match word { 137 140 "" => Ok(()), 138 138 - _ => parse_word(word, lexer) 141 141 + _ => parse_word(word, lexer), 139 142 } 140 143 } 141 144 ··· 175 178 "plus" => Token::Operator(Plus), 176 179 "minus" => Token::Operator(Minus), 177 180 "times" => Token::Operator(Multiply), 178 178 - "multiplied" => { 179 179 - match read_word("", lexer).as_str() { 180 180 - "by" => Token::Operator(Multiply), 181 181 - string => return Err(format!("Invalid string: {}", string)), 182 182 - } 181 181 + "multiplied" => match read_word("", lexer).as_str() { 182 182 + "by" => Token::Operator(Multiply), 183 183 + string => return Err(format!("Invalid string: {}", string)), 183 184 }, 184 184 - "divided" => { 185 185 - match read_word("", lexer).as_str() { 186 186 - "by" => Token::Operator(Divide), 187 187 - string => return Err(format!("Invalid string: {}", string)), 188 188 - } 185 185 + "divided" => match read_word("", lexer).as_str() { 186 186 + "by" => Token::Operator(Divide), 187 187 + string => return Err(format!("Invalid string: {}", string)), 189 188 }, 190 189 "mod" => Token::Operator(Modulo), 191 190 ··· 210 209 211 210 "ns" | "nanosec" | "nanosecs" | "nanosecond" | "nanoseconds" => Token::Unit(Nanosecond), 212 211 // µ and μ are two different characters 213 213 - "µs" | "μs" | "microsec" | "microsecs" | "microsecond" | "microseconds" => Token::Unit(Microsecond), 214 214 - "ms" | "millisec" | "millisecs" | "millisecond" | "milliseconds" => Token::Unit(Millisecond), 212 212 + "µs" | "μs" | "microsec" | "microsecs" | "microsecond" | "microseconds" => { 213 213 + Token::Unit(Microsecond) 214 214 + } 215 215 + "ms" | "millisec" | "millisecs" | "millisecond" | "milliseconds" => { 216 216 + Token::Unit(Millisecond) 217 217 + } 215 218 "s" | "sec" | "secs" | "second" | "seconds" => Token::Unit(Second), 216 219 "min" | "mins" | "minute" | "minutes" => Token::Unit(Minute), 217 220 "h" | "hr" | "hrs" | "hour" | "hours" => Token::Unit(Hour), ··· 224 227 "century" | "centuries" => Token::Unit(Century), 225 228 "millenium" | "millenia" | "milleniums" => Token::Unit(Millennium), 226 229 227 227 - "mm" | "millimeter" | "millimeters" | "millimetre" | "millimetres" => Token::Unit(Millimeter), 228 228 - "cm" | "centimeter" | "centimeters" | "centimetre" | "centimetres" => Token::Unit(Centimeter), 230 230 + "mm" | "millimeter" | "millimeters" | "millimetre" | "millimetres" => { 231 231 + Token::Unit(Millimeter) 232 232 + } 233 233 + "cm" | "centimeter" | "centimeters" | "centimetre" | "centimetres" => { 234 234 + Token::Unit(Centimeter) 235 235 + } 229 236 "dm" | "decimeter" | "decimeters" | "decimetre" | "decimetres" => Token::Unit(Decimeter), 230 237 "m" | "meter" | "meters" | "metre" | "metres" => Token::Unit(Meter), 231 238 "km" | "kilometer" | "kilometers" | "kilometre" | "kilometres" => Token::Unit(Kilometer), ··· 236 243 "mi" | "mile" | "miles" => Token::Unit(Mile), 237 244 "marathon" | "marathons" => Token::Unit(Marathon), 238 245 "nmi" => Token::Unit(NauticalMile), 239 239 - "nautical" => { 240 240 - match read_word("", lexer).as_str() { 241 241 - "mile" | "miles" => Token::Unit(NauticalMile), 242 242 - string => return Err(format!("Invalid string: {}", string)), 243 243 - } 246 246 + "nautical" => match read_word("", lexer).as_str() { 247 247 + "mile" | "miles" => Token::Unit(NauticalMile), 248 248 + string => return Err(format!("Invalid string: {}", string)), 244 249 }, 245 250 "ly" | "lightyear" | "lightyears" => Token::Unit(LightYear), 246 251 "lightsec" | "lightsecs" | "lightsecond" | "lightseconds" => Token::Unit(LightSecond), 247 247 - "light" => { 248 248 - match read_word("", lexer).as_str() { 249 249 - "yr" | "yrs" | "year" | "years" => Token::Unit(LightYear), 250 250 - "sec" | "secs" | "second" | "seconds" => Token::Unit(LightSecond), 251 251 - string => return Err(format!("Invalid string: {}", string)), 252 252 - } 252 252 + "light" => match read_word("", lexer).as_str() { 253 253 + "yr" | "yrs" | "year" | "years" => Token::Unit(LightYear), 254 254 + "sec" | "secs" | "second" | "seconds" => Token::Unit(LightSecond), 255 255 + string => return Err(format!("Invalid string: {}", string)), 256 256 + }, 257 257 + 258 258 + "sqmm" | "mm2" | "millimeter2" | "millimeters2" | "millimetre2" | "millimetres2" => { 259 259 + Token::Unit(SquareMillimeter) 260 260 + } 261 261 + "sqcm" | "cm2" | "centimeter2" | "centimeters2" | "centimetre2" | "centimetres2" => { 262 262 + Token::Unit(SquareCentimeter) 263 263 + } 264 264 + "sqdm" | "dm2" | "decimeter2" | "decimeters2" | "decimetre2" | "decimetres2" => { 265 265 + Token::Unit(SquareDecimeter) 253 266 } 254 254 - 255 255 - "sqmm" | "mm2" | "millimeter2" | "millimeters2" | "millimetre2" | "millimetres2" => Token::Unit(SquareMillimeter), 256 256 - "sqcm" | "cm2" | "centimeter2" | "centimeters2" | "centimetre2" | "centimetres2" => Token::Unit(SquareCentimeter), 257 257 - "sqdm" | "dm2" | "decimeter2" | "decimeters2" | "decimetre2" | "decimetres2" => Token::Unit(SquareDecimeter), 258 267 "sqm" | "m2" | "meter2" | "meters2" | "metre2" | "metres2" => Token::Unit(SquareMeter), 259 259 - "sqkm" | "km2" | "kilometer2" | "kilometers2" | "kilometre2" | "kilometres2" => Token::Unit(SquareKilometer), 268 268 + "sqkm" | "km2" | "kilometer2" | "kilometers2" | "kilometre2" | "kilometres2" => { 269 269 + Token::Unit(SquareKilometer) 270 270 + } 260 271 "sqin" | "in2" | "inch2" | "inches2" => Token::Unit(SquareInch), 261 272 "sqft" | "ft2" | "foot2" | "feet2" => Token::Unit(SquareFoot), 262 273 "sqyd" | "yd2" | "yard2" | "yards2" => Token::Unit(SquareYard), 263 274 "sqmi" | "mi2" | "mile2" | "miles2" => Token::Unit(SquareMile), 264 264 - "sq" | "square" => { 265 265 - match read_word("", lexer).as_str() { 266 266 - "mm" | "millimeter" | "millimeters" | "millimetre" | "millimetres" => Token::Unit(SquareMillimeter), 267 267 - "cm" | "centimeter" | "centimeters" | "centimetre" | "centimetres" => Token::Unit(SquareCentimeter), 268 268 - "dm" | "decimeter" | "decimeters" | "decimetre" | "decimetres" => Token::Unit(SquareDecimeter), 269 269 - "m" | "meter" | "meters" | "metre" | "metres" => Token::Unit(SquareMeter), 270 270 - "km" | "kilometer" | "kilometers" | "kilometre" | "kilometres" => Token::Unit(SquareKilometer), 271 271 - "in" | "inch" | "inches" => Token::Unit(SquareInch), 272 272 - "ft" | "foot" | "feet" => Token::Unit(SquareFoot), 273 273 - "yd" | "yard" | "yards" => Token::Unit(SquareYard), 274 274 - "mi" | "mile" | "miles" => Token::Unit(SquareMile), 275 275 - string => return Err(format!("Invalid string: {}", string)), 275 275 + "sq" | "square" => match read_word("", lexer).as_str() { 276 276 + "mm" | "millimeter" | "millimeters" | "millimetre" | "millimetres" => { 277 277 + Token::Unit(SquareMillimeter) 278 278 + } 279 279 + "cm" | "centimeter" | "centimeters" | "centimetre" | "centimetres" => { 280 280 + Token::Unit(SquareCentimeter) 281 281 + } 282 282 + "dm" | "decimeter" | "decimeters" | "decimetre" | "decimetres" => { 283 283 + Token::Unit(SquareDecimeter) 284 284 + } 285 285 + "m" | "meter" | "meters" | "metre" | "metres" => Token::Unit(SquareMeter), 286 286 + "km" | "kilometer" | "kilometers" | "kilometre" | "kilometres" => { 287 287 + Token::Unit(SquareKilometer) 276 288 } 277 277 - } 289 289 + "in" | "inch" | "inches" => Token::Unit(SquareInch), 290 290 + "ft" | "foot" | "feet" => Token::Unit(SquareFoot), 291 291 + "yd" | "yard" | "yards" => Token::Unit(SquareYard), 292 292 + "mi" | "mile" | "miles" => Token::Unit(SquareMile), 293 293 + string => return Err(format!("Invalid string: {}", string)), 294 294 + }, 278 295 "are" | "ares" => Token::Unit(Are), 279 296 "decare" | "decares" => Token::Unit(Decare), 280 297 "ha" | "hectare" | "hectares" => Token::Unit(Hectare), 281 298 "acre" | "acres" => Token::Unit(Acre), 282 299 283 283 - "mm3" | "millimeter3" | "millimeters3" | "millimetre3" | "millimetres3" => Token::Unit(CubicMillimeter), 284 284 - "cm3" | "centimeter3" | "centimeters3" | "centimetre3" | "centimetres3" => Token::Unit(CubicCentimeter), 285 285 - "dm3" | "decimeter3" | "decimeters3" | "decimetre3" | "decimetres3" => Token::Unit(CubicDecimeter), 300 300 + "mm3" | "millimeter3" | "millimeters3" | "millimetre3" | "millimetres3" => { 301 301 + Token::Unit(CubicMillimeter) 302 302 + } 303 303 + "cm3" | "centimeter3" | "centimeters3" | "centimetre3" | "centimetres3" => { 304 304 + Token::Unit(CubicCentimeter) 305 305 + } 306 306 + "dm3" | "decimeter3" | "decimeters3" | "decimetre3" | "decimetres3" => { 307 307 + Token::Unit(CubicDecimeter) 308 308 + } 286 309 "m3" | "meter3" | "meters3" | "metre3" | "metres3" => Token::Unit(CubicMeter), 287 287 - "km3" | "kilometer3" | "kilometers3" | "kilometre3" | "kilometres3" => Token::Unit(CubicKilometer), 310 310 + "km3" | "kilometer3" | "kilometers3" | "kilometre3" | "kilometres3" => { 311 311 + Token::Unit(CubicKilometer) 312 312 + } 288 313 "inc3" | "inch3" | "inches3" => Token::Unit(CubicInch), 289 314 "ft3" | "foot3" | "feet3" => Token::Unit(CubicFoot), 290 315 "yd3" | "yard3" | "yards3" => Token::Unit(CubicYard), 291 316 "mi3" | "mile3" | "miles3" => Token::Unit(CubicMile), 292 292 - "cubic" => { 293 293 - match read_word("", lexer).as_str() { 294 294 - "mm" | "millimeter" | "millimeters" | "millimetre" | "millimetres" => Token::Unit(CubicMillimeter), 295 295 - "cm" | "centimeter" | "centimeters" | "centimetre" | "centimetres" => Token::Unit(CubicCentimeter), 296 296 - "dm" | "decimeter" | "decimeters" | "decimetre" | "decimetres" => Token::Unit(CubicDecimeter), 297 297 - "m" | "meter" | "meters" | "metre" | "metres" => Token::Unit(CubicMeter), 298 298 - "km" | "kilometer" | "kilometers" | "kilometre" | "kilometres" => Token::Unit(CubicKilometer), 299 299 - "in" | "inch" | "inches" => Token::Unit(CubicInch), 300 300 - "ft" | "foot" | "feet" => Token::Unit(CubicFoot), 301 301 - "yd" | "yard" | "yards" => Token::Unit(CubicYard), 302 302 - "mi" | "mile" | "miles" => Token::Unit(CubicMile), 303 303 - string => return Err(format!("Invalid string: {}", string)), 317 317 + "cubic" => match read_word("", lexer).as_str() { 318 318 + "mm" | "millimeter" | "millimeters" | "millimetre" | "millimetres" => { 319 319 + Token::Unit(CubicMillimeter) 304 320 } 321 321 + "cm" | "centimeter" | "centimeters" | "centimetre" | "centimetres" => { 322 322 + Token::Unit(CubicCentimeter) 323 323 + } 324 324 + "dm" | "decimeter" | "decimeters" | "decimetre" | "decimetres" => { 325 325 + Token::Unit(CubicDecimeter) 326 326 + } 327 327 + "m" | "meter" | "meters" | "metre" | "metres" => Token::Unit(CubicMeter), 328 328 + "km" | "kilometer" | "kilometers" | "kilometre" | "kilometres" => { 329 329 + Token::Unit(CubicKilometer) 330 330 + } 331 331 + "in" | "inch" | "inches" => Token::Unit(CubicInch), 332 332 + "ft" | "foot" | "feet" => Token::Unit(CubicFoot), 333 333 + "yd" | "yard" | "yards" => Token::Unit(CubicYard), 334 334 + "mi" | "mile" | "miles" => Token::Unit(CubicMile), 335 335 + string => return Err(format!("Invalid string: {}", string)), 305 336 }, 306 306 - "ml" | "milliliter" | "milliliters" | "millilitre" | "millilitres" => Token::Unit(Milliliter), 307 307 - "cl" | "centiliter" | "centiliters" | "centilitre" | "centilitres" => Token::Unit(Centiliter), 337 337 + "ml" | "milliliter" | "milliliters" | "millilitre" | "millilitres" => { 338 338 + Token::Unit(Milliliter) 339 339 + } 340 340 + "cl" | "centiliter" | "centiliters" | "centilitre" | "centilitres" => { 341 341 + Token::Unit(Centiliter) 342 342 + } 308 343 "dl" | "deciliter" | "deciliters" | "decilitre" | "decilitres" => Token::Unit(Deciliter), 309 344 "l" | "liter" | "liters" | "litre" | "litres" => Token::Unit(Liter), 310 345 "ts" | "tsp" | "tspn" | "tspns" | "teaspoon" | "teaspoons" => Token::Unit(Teaspoon), 311 346 "tbs" | "tbsp" | "tablespoon" | "tablespoons" => Token::Unit(Tablespoon), 312 347 "floz" => Token::Unit(FluidOunce), 313 313 - "fl" | "fluid" => { 314 314 - match read_word("", lexer).as_str() { 315 315 - "oz" | "ounce" | "ounces" => Token::Unit(FluidOunce), 316 316 - string => return Err(format!("Invalid string: {}", string)), 317 317 - } 348 348 + "fl" | "fluid" => match read_word("", lexer).as_str() { 349 349 + "oz" | "ounce" | "ounces" => Token::Unit(FluidOunce), 350 350 + string => return Err(format!("Invalid string: {}", string)), 318 351 }, 319 352 "cup" | "cups" => Token::Unit(Cup), 320 353 "pt" | "pint" | "pints" => Token::Unit(Pint), 321 354 "qt" | "quart" | "quarts" => Token::Unit(Quart), 322 355 "gal" | "gallon" | "gallons" => Token::Unit(Gallon), 323 356 "bbl" => Token::Unit(OilBarrel), 324 324 - "oil" => { 325 325 - match read_word("", lexer).as_str() { 326 326 - "barrel" | "barrels" => Token::Unit(OilBarrel), 327 327 - string => return Err(format!("Invalid string: {}", string)), 328 328 - } 357 357 + "oil" => match read_word("", lexer).as_str() { 358 358 + "barrel" | "barrels" => Token::Unit(OilBarrel), 359 359 + string => return Err(format!("Invalid string: {}", string)), 329 360 }, 330 361 331 331 - "metric" => { 332 332 - match read_word("", lexer).as_str() { 333 333 - "ton" | "tons" | "tonne" | "tonnes" => Token::Unit(MetricTon), 334 334 - "hp" | "hps" | "horsepower" | "horsepowers" => Token::Unit(MetricHorsepower), 335 335 - string => return Err(format!("Invalid string: {}", string)), 336 336 - } 362 362 + "metric" => match read_word("", lexer).as_str() { 363 363 + "ton" | "tons" | "tonne" | "tonnes" => Token::Unit(MetricTon), 364 364 + "hp" | "hps" | "horsepower" | "horsepowers" => Token::Unit(MetricHorsepower), 365 365 + string => return Err(format!("Invalid string: {}", string)), 337 366 }, 338 367 339 368 "mg" | "milligram" | "milligrams" => Token::Unit(Milligram), ··· 343 372 "t" | "tonne" | "tonnes" => Token::Unit(MetricTon), 344 373 "oz" | "ounces" => Token::Unit(Ounce), 345 374 "lb" | "lbs" => Token::Unit(Pound), 346 346 - "pound" | "pounds" => { 347 347 - match lexer.chars.next() { 348 348 - Some("-") => { 349 349 - match read_word_plain(&mut lexer.chars).as_str() { 350 350 - "force" => Token::LexerKeyword(PoundForce), 351 351 - other => { 352 352 - lexer.tokens.push(Token::Unit(Pound)); 353 353 - lexer.tokens.push(Token::Operator(Minus)); 354 354 - parse_word_if_non_empty(other, lexer)?; 355 355 - return Ok(()); 356 356 - } 357 357 - } 358 358 - }, 359 359 - Some(c) => { 360 360 - lexer.tokens.push(Token::Unit(Pound)); 361 361 - parse_token(c, lexer)?; 362 362 - return Ok(()); 363 363 - }, 364 364 - None => { 375 375 + "pound" | "pounds" => match lexer.chars.next() { 376 376 + Some("-") => match read_word_plain(&mut lexer.chars).as_str() { 377 377 + "force" => Token::LexerKeyword(PoundForce), 378 378 + other => { 365 379 lexer.tokens.push(Token::Unit(Pound)); 380 380 + lexer.tokens.push(Token::Operator(Minus)); 381 381 + parse_word_if_non_empty(other, lexer)?; 366 382 return Ok(()); 367 367 - }, 383 383 + } 384 384 + }, 385 385 + Some(c) => { 386 386 + lexer.tokens.push(Token::Unit(Pound)); 387 387 + parse_token(c, lexer)?; 388 388 + return Ok(()); 389 389 + } 390 390 + None => { 391 391 + lexer.tokens.push(Token::Unit(Pound)); 392 392 + return Ok(()); 368 393 } 369 394 }, 370 395 "stone" | "stones" => Token::Unit(Stone), 371 396 "st" | "ton" | "tons" => Token::Unit(ShortTon), 372 372 - "short" => { 373 373 - match read_word("", lexer).as_str() { 374 374 - "ton" | "tons" | "tonne" | "tonnes" => Token::Unit(ShortTon), 375 375 - string => return Err(format!("Invalid string: {}", string)), 376 376 - } 397 397 + "short" => match read_word("", lexer).as_str() { 398 398 + "ton" | "tons" | "tonne" | "tonnes" => Token::Unit(ShortTon), 399 399 + string => return Err(format!("Invalid string: {}", string)), 377 400 }, 378 401 "lt" => Token::Unit(LongTon), 379 379 - "long" => { 380 380 - match read_word("", lexer).as_str() { 381 381 - "ton" | "tons" | "tonne" | "tonnes" => Token::Unit(LongTon), 382 382 - string => return Err(format!("Invalid string: {}", string)), 383 383 - } 402 402 + "long" => match read_word("", lexer).as_str() { 403 403 + "ton" | "tons" | "tonne" | "tonnes" => Token::Unit(LongTon), 404 404 + string => return Err(format!("Invalid string: {}", string)), 384 405 }, 385 406 386 407 "bit" | "bits" => Token::Unit(Bit), ··· 453 474 "qflops" | "quettaflops" => Token::Unit(QuettaFlopPerSecond), 454 475 455 476 "millijoule" | "millijoules" => Token::Unit(Millijoule), 456 456 - "j"| "joule" | "joules" => Token::Unit(Joule), 477 477 + "j" | "joule" | "joules" => Token::Unit(Joule), 457 478 "nm" => Token::Unit(NewtonMeter), 458 458 - "newton" => { 459 459 - match lexer.chars.next() { 460 460 - Some("-") => { 461 461 - match read_word_plain(&mut lexer.chars).as_str() { 462 462 - "meter" | "meters" | "metre" | "metres" => Token::Unit(NewtonMeter), 463 463 - string => return Err(format!("Invalid string: {}", string)), 464 464 - } 465 465 - }, 466 466 - Some(c) => { 467 467 - match read_word(c, lexer).as_str() { 468 468 - "meter" | "meters" | "metre" | "metres" => Token::Unit(NewtonMeter), 469 469 - string => return Err(format!("Invalid string: {}", string)), 470 470 - } 471 471 - }, 472 472 - None => return Err(format!("Invalid string: {}", word)), 473 473 - } 479 479 + "newton" => match lexer.chars.next() { 480 480 + Some("-") => match read_word_plain(&mut lexer.chars).as_str() { 481 481 + "meter" | "meters" | "metre" | "metres" => Token::Unit(NewtonMeter), 482 482 + string => return Err(format!("Invalid string: {}", string)), 483 483 + }, 484 484 + Some(c) => match read_word(c, lexer).as_str() { 485 485 + "meter" | "meters" | "metre" | "metres" => Token::Unit(NewtonMeter), 486 486 + string => return Err(format!("Invalid string: {}", string)), 487 487 + }, 488 488 + None => return Err(format!("Invalid string: {}", word)), 474 489 }, 475 490 "kj" | "kilojoule" | "kilojoules" => Token::Unit(Kilojoule), 476 491 "mj" | "megajoule" | "megajoules" => Token::Unit(Megajoule), ··· 479 494 "cal" | "calorie" | "calories" => Token::Unit(Calorie), 480 495 "kcal" | "kilocalorie" | "kilocalories" => Token::Unit(KiloCalorie), 481 496 "btu" => Token::Unit(BritishThermalUnit), 482 482 - "british" => { 483 483 - match read_word("", lexer).as_str() { 484 484 - "thermal" => { 485 485 - match read_word("", lexer).as_str() { 486 486 - "unit" | "units" => Token::Unit(BritishThermalUnit), 487 487 - string => return Err(format!("Invalid string: {}", string)), 488 488 - } 489 489 - }, 497 497 + "british" => match read_word("", lexer).as_str() { 498 498 + "thermal" => match read_word("", lexer).as_str() { 499 499 + "unit" | "units" => Token::Unit(BritishThermalUnit), 490 500 string => return Err(format!("Invalid string: {}", string)), 491 491 - } 501 501 + }, 502 502 + string => return Err(format!("Invalid string: {}", string)), 492 503 }, 493 504 "wh" => Token::Unit(WattHour), 494 505 "kwh" => Token::Unit(KilowattHour), ··· 507 518 "hp" | "hps" | "horsepower" | "horsepowers" => Token::Unit(Horsepower), 508 519 "mhp" | "hpm" => Token::Unit(MetricHorsepower), 509 520 510 510 - "watt" => { 511 511 - match read_word("", lexer).as_str() { 512 512 - "hr" | "hrs" | "hour" | "hours" => Token::Unit(WattHour), 513 513 - other => { 514 514 - lexer.tokens.push(Token::Unit(Watt)); 515 515 - parse_word_if_non_empty(other, lexer)?; 516 516 - return Ok(()); 517 517 - }, 521 521 + "watt" => match read_word("", lexer).as_str() { 522 522 + "hr" | "hrs" | "hour" | "hours" => Token::Unit(WattHour), 523 523 + other => { 524 524 + lexer.tokens.push(Token::Unit(Watt)); 525 525 + parse_word_if_non_empty(other, lexer)?; 526 526 + return Ok(()); 518 527 } 519 519 - } 520 520 - "kilowatt" => { 521 521 - match read_word("", lexer).as_str() { 522 522 - "hr" | "hrs" | "hour" | "hours" => Token::Unit(KilowattHour), 523 523 - other => { 524 524 - lexer.tokens.push(Token::Unit(Kilowatt)); 525 525 - parse_word_if_non_empty(other, lexer)?; 526 526 - return Ok(()); 527 527 - }, 528 528 + }, 529 529 + "kilowatt" => match read_word("", lexer).as_str() { 530 530 + "hr" | "hrs" | "hour" | "hours" => Token::Unit(KilowattHour), 531 531 + other => { 532 532 + lexer.tokens.push(Token::Unit(Kilowatt)); 533 533 + parse_word_if_non_empty(other, lexer)?; 534 534 + return Ok(()); 528 535 } 529 529 - } 530 530 - "megawatt" => { 531 531 - match read_word("", lexer).as_str() { 532 532 - "hr" | "hrs" | "hour" | "hours" => Token::Unit(MegawattHour), 533 533 - other => { 534 534 - lexer.tokens.push(Token::Unit(Megawatt)); 535 535 - parse_word_if_non_empty(other, lexer)?; 536 536 - return Ok(()); 537 537 - }, 536 536 + }, 537 537 + "megawatt" => match read_word("", lexer).as_str() { 538 538 + "hr" | "hrs" | "hour" | "hours" => Token::Unit(MegawattHour), 539 539 + other => { 540 540 + lexer.tokens.push(Token::Unit(Megawatt)); 541 541 + parse_word_if_non_empty(other, lexer)?; 542 542 + return Ok(()); 538 543 } 539 539 - } 540 540 - "gigawatt" => { 541 541 - match read_word("", lexer).as_str() { 542 542 - "hr" | "hrs" | "hour" | "hours" => Token::Unit(GigawattHour), 543 543 - other => { 544 544 - lexer.tokens.push(Token::Unit(Gigawatt)); 545 545 - parse_word_if_non_empty(other, lexer)?; 546 546 - return Ok(()); 547 547 - }, 544 544 + }, 545 545 + "gigawatt" => match read_word("", lexer).as_str() { 546 546 + "hr" | "hrs" | "hour" | "hours" => Token::Unit(GigawattHour), 547 547 + other => { 548 548 + lexer.tokens.push(Token::Unit(Gigawatt)); 549 549 + parse_word_if_non_empty(other, lexer)?; 550 550 + return Ok(()); 548 551 } 549 549 - } 550 550 - "terawatt" => { 551 551 - match read_word("", lexer).as_str() { 552 552 - "hr" | "hrs" | "hour" | "hours" => Token::Unit(TerawattHour), 553 553 - other => { 554 554 - lexer.tokens.push(Token::Unit(Terawatt)); 555 555 - parse_word_if_non_empty(other, lexer)?; 556 556 - return Ok(()); 557 557 - }, 552 552 + }, 553 553 + "terawatt" => match read_word("", lexer).as_str() { 554 554 + "hr" | "hrs" | "hour" | "hours" => Token::Unit(TerawattHour), 555 555 + other => { 556 556 + lexer.tokens.push(Token::Unit(Terawatt)); 557 557 + parse_word_if_non_empty(other, lexer)?; 558 558 + return Ok(()); 558 559 } 559 559 - } 560 560 - "petawatt" => { 561 561 - match read_word("", lexer).as_str() { 562 562 - "hr" | "hrs" | "hour" | "hours" => Token::Unit(PetawattHour), 563 563 - other => { 564 564 - lexer.tokens.push(Token::Unit(Petawatt)); 565 565 - parse_word_if_non_empty(other, lexer)?; 566 566 - return Ok(()); 567 567 - }, 560 560 + }, 561 561 + "petawatt" => match read_word("", lexer).as_str() { 562 562 + "hr" | "hrs" | "hour" | "hours" => Token::Unit(PetawattHour), 563 563 + other => { 564 564 + lexer.tokens.push(Token::Unit(Petawatt)); 565 565 + parse_word_if_non_empty(other, lexer)?; 566 566 + return Ok(()); 568 567 } 569 569 - } 568 568 + }, 570 569 571 571 - "ma" | "milliamp" | "milliamps" | "milliampere" | "milliamperes" => Token::Unit(Milliampere), 570 570 + "ma" | "milliamp" | "milliamps" | "milliampere" | "milliamperes" => { 571 571 + Token::Unit(Milliampere) 572 572 + } 572 573 "a" | "amp" | "amps" | "ampere" | "amperes" => Token::Unit(Ampere), 573 574 "ka" | "kiloamp" | "kiloamps" | "kiloampere" | "kiloamperes" => Token::Unit(Kiloampere), 574 575 "bi" | "biot" | "biots" | "aba" | "abampere" | "abamperes" => Token::Unit(Abampere), ··· 637 638 match &input.chars().last().unwrap_or('x') { 638 639 '+' | '-' | '*' | '/' | '^' | '(' => { 639 640 input.pop(); 640 640 - }, 641 641 - _ => {}, 641 641 + } 642 642 + _ => {} 642 643 } 643 644 } 644 645 ··· 679 680 Some(Token::TextOperator(Of)) => { 680 681 // "10% of 1km" should be percentage 681 682 tokens[token_index] = Token::UnaryOperator(Percent); 682 682 - }, 683 683 + } 683 684 Some(Token::Operator(operator)) => { 684 685 match operator { 685 686 LeftParen => { 686 687 // "10%(2)" should be modulo 687 688 tokens[token_index] = Token::Operator(Modulo); 688 688 - }, 689 689 + } 689 690 _ => { 690 691 // "10%*2" should be a percentage 691 692 tokens[token_index] = Token::UnaryOperator(Percent); 692 693 } 693 694 } 694 694 - }, 695 695 + } 695 696 Some(Token::UnaryOperator(_)) => { 696 697 // "10%!" should be a percentage 697 698 tokens[token_index] = Token::UnaryOperator(Percent); 698 698 - }, 699 699 + } 699 700 Some(Token::LexerKeyword(PercentChar)) => { 700 701 // "10%%" should be a percentage 701 702 tokens[token_index] = Token::UnaryOperator(Percent); 702 702 - }, 703 703 + } 703 704 None => { 704 705 // percent if there's no element afterwards 705 706 tokens[token_index] = Token::UnaryOperator(Percent); 706 706 - }, 707 707 + } 707 708 _ => { 708 709 // everything else should be modulo, for example if the % is 709 710 // before a number, function or constants 710 711 tokens[token_index] = Token::Operator(Modulo); 711 711 - }, 712 712 + } 712 713 } 713 713 - }, 714 714 + } 714 715 // decide if " is 'inch' or 'inch of mercury' 715 716 Token::LexerKeyword(DoubleQuotes) => { 716 717 match tokens.get(token_index + 1) { ··· 718 719 // "hg should be inch of mercury 719 720 tokens[token_index] = Token::Unit(InchOfMercury); 720 721 tokens.remove(token_index + 1); 721 721 - }, 722 722 + } 722 723 _ => { 723 724 // otherwise, Inch 724 725 tokens[token_index] = Token::Unit(Inch); 725 725 - }, 726 726 + } 726 727 } 727 727 - }, 728 728 + } 728 729 // if hg wasn't already turned into inch of mercury, it's hectogram 729 730 Token::LexerKeyword(Hg) => { 730 731 tokens[token_index] = Token::Unit(Hectogram); 731 731 - }, 732 732 + } 732 733 // decide if "in" is Inch or To 733 734 Token::LexerKeyword(In) => { 734 735 match tokens.get(token_index + 1) { 735 736 Some(Token::Unit(_)) => { 736 737 // "in" should be To 737 738 tokens[token_index] = Token::TextOperator(To); 738 738 - }, 739 739 + } 739 740 _ => { 740 741 // otherwise, Inch 741 742 tokens[token_index] = Token::Unit(Inch); 742 742 - }, 743 743 + } 743 744 } 744 744 - }, 745 745 - _ => {}, 745 745 + } 746 746 + _ => {} 746 747 } 747 748 // parse units like km/h, lbf per square inch 748 749 if token_index >= 2 { 749 749 - let token1 = &tokens[token_index-2]; 750 750 - let token2 = match &tokens[token_index-1] { 750 750 + let token1 = &tokens[token_index - 2]; 751 751 + let token2 = match &tokens[token_index - 1] { 751 752 // treat km/h the same as km per h 752 753 Token::Operator(Divide) => &Token::LexerKeyword(Per), 753 753 - _ => &tokens[token_index-1], 754 754 + _ => &tokens[token_index - 1], 754 755 }; 755 756 let token3 = &tokens[token_index]; 756 757 let mut replaced = true; 757 758 match (token1, token2, token3) { 758 759 // km/h 759 760 (Token::Unit(Kilometer), Token::LexerKeyword(Per), Token::Unit(Hour)) => { 760 760 - tokens[token_index-2] = Token::Unit(KilometersPerHour); 761 761 - }, 761 761 + tokens[token_index - 2] = Token::Unit(KilometersPerHour); 762 762 + } 762 763 // mi/h 763 764 (Token::Unit(Mile), Token::LexerKeyword(Per), Token::Unit(Hour)) => { 764 764 - tokens[token_index-2] = Token::Unit(MilesPerHour); 765 765 - }, 765 765 + tokens[token_index - 2] = Token::Unit(MilesPerHour); 766 766 + } 766 767 // m/s 767 768 (Token::Unit(Meter), Token::LexerKeyword(Per), Token::Unit(Second)) => { 768 768 - tokens[token_index-2] = Token::Unit(MetersPerSecond); 769 769 - }, 769 769 + tokens[token_index - 2] = Token::Unit(MetersPerSecond); 770 770 + } 770 771 // ft/s 771 772 (Token::Unit(Foot), Token::LexerKeyword(Per), Token::Unit(Second)) => { 772 772 - tokens[token_index-2] = Token::Unit(FeetPerSecond); 773 773 - }, 773 773 + tokens[token_index - 2] = Token::Unit(FeetPerSecond); 774 774 + } 774 775 // bits per second 775 776 (Token::Unit(Bit), Token::LexerKeyword(Per), Token::Unit(Second)) => { 776 776 - tokens[token_index-2] = Token::Unit(BitsPerSecond); 777 777 - }, 777 777 + tokens[token_index - 2] = Token::Unit(BitsPerSecond); 778 778 + } 778 779 // kilobits per second 779 780 (Token::Unit(Kilobit), Token::LexerKeyword(Per), Token::Unit(Second)) => { 780 780 - tokens[token_index-2] = Token::Unit(KilobitsPerSecond); 781 781 - }, 781 781 + tokens[token_index - 2] = Token::Unit(KilobitsPerSecond); 782 782 + } 782 783 // megabits per second 783 784 (Token::Unit(Megabit), Token::LexerKeyword(Per), Token::Unit(Second)) => { 784 784 - tokens[token_index-2] = Token::Unit(MegabitsPerSecond); 785 785 - }, 785 785 + tokens[token_index - 2] = Token::Unit(MegabitsPerSecond); 786 786 + } 786 787 // gigabits per second 787 788 (Token::Unit(Gigabit), Token::LexerKeyword(Per), Token::Unit(Second)) => { 788 788 - tokens[token_index-2] = Token::Unit(GigabitsPerSecond); 789 789 - }, 789 789 + tokens[token_index - 2] = Token::Unit(GigabitsPerSecond); 790 790 + } 790 791 // terabits per second 791 792 (Token::Unit(Terabit), Token::LexerKeyword(Per), Token::Unit(Second)) => { 792 792 - tokens[token_index-2] = Token::Unit(TerabitsPerSecond); 793 793 - }, 793 793 + tokens[token_index - 2] = Token::Unit(TerabitsPerSecond); 794 794 + } 794 795 // petabits per second 795 796 (Token::Unit(Petabit), Token::LexerKeyword(Per), Token::Unit(Second)) => { 796 796 - tokens[token_index-2] = Token::Unit(PetabitsPerSecond); 797 797 - }, 797 797 + tokens[token_index - 2] = Token::Unit(PetabitsPerSecond); 798 798 + } 798 799 // exabits per second 799 800 (Token::Unit(Exabit), Token::LexerKeyword(Per), Token::Unit(Second)) => { 800 800 - tokens[token_index-2] = Token::Unit(ExabitsPerSecond); 801 801 - }, 801 801 + tokens[token_index - 2] = Token::Unit(ExabitsPerSecond); 802 802 + } 802 803 // zettabits per second 803 804 (Token::Unit(Zettabit), Token::LexerKeyword(Per), Token::Unit(Second)) => { 804 804 - tokens[token_index-2] = Token::Unit(ZettabitsPerSecond); 805 805 - }, 805 805 + tokens[token_index - 2] = Token::Unit(ZettabitsPerSecond); 806 806 + } 806 807 // yottabits per second 807 808 (Token::Unit(Yottabit), Token::LexerKeyword(Per), Token::Unit(Second)) => { 808 808 - tokens[token_index-2] = Token::Unit(YottabitsPerSecond); 809 809 - }, 809 809 + tokens[token_index - 2] = Token::Unit(YottabitsPerSecond); 810 810 + } 810 811 // kibibits per second 811 812 (Token::Unit(Kibibit), Token::LexerKeyword(Per), Token::Unit(Second)) => { 812 812 - tokens[token_index-2] = Token::Unit(KibibitsPerSecond); 813 813 - }, 813 813 + tokens[token_index - 2] = Token::Unit(KibibitsPerSecond); 814 814 + } 814 815 // mebibits per second 815 816 (Token::Unit(Mebibit), Token::LexerKeyword(Per), Token::Unit(Second)) => { 816 816 - tokens[token_index-2] = Token::Unit(MebibitsPerSecond); 817 817 - }, 817 817 + tokens[token_index - 2] = Token::Unit(MebibitsPerSecond); 818 818 + } 818 819 // gibibits per second 819 820 (Token::Unit(Gibibit), Token::LexerKeyword(Per), Token::Unit(Second)) => { 820 820 - tokens[token_index-2] = Token::Unit(GibibitsPerSecond); 821 821 - }, 821 821 + tokens[token_index - 2] = Token::Unit(GibibitsPerSecond); 822 822 + } 822 823 // tebibits per second 823 824 (Token::Unit(Tebibit), Token::LexerKeyword(Per), Token::Unit(Second)) => { 824 824 - tokens[token_index-2] = Token::Unit(TebibitsPerSecond); 825 825 - }, 825 825 + tokens[token_index - 2] = Token::Unit(TebibitsPerSecond); 826 826 + } 826 827 // pebibits per second 827 828 (Token::Unit(Pebibit), Token::LexerKeyword(Per), Token::Unit(Second)) => { 828 828 - tokens[token_index-2] = Token::Unit(PebibitsPerSecond); 829 829 - }, 829 829 + tokens[token_index - 2] = Token::Unit(PebibitsPerSecond); 830 830 + } 830 831 // exbibits per second 831 832 (Token::Unit(Exbibit), Token::LexerKeyword(Per), Token::Unit(Second)) => { 832 832 - tokens[token_index-2] = Token::Unit(ExbibitsPerSecond); 833 833 - }, 833 833 + tokens[token_index - 2] = Token::Unit(ExbibitsPerSecond); 834 834 + } 834 835 // zebibits per second 835 836 (Token::Unit(Zebibit), Token::LexerKeyword(Per), Token::Unit(Second)) => { 836 836 - tokens[token_index-2] = Token::Unit(ZebibitsPerSecond); 837 837 - }, 837 837 + tokens[token_index - 2] = Token::Unit(ZebibitsPerSecond); 838 838 + } 838 839 // yobibits per second 839 840 (Token::Unit(Yobibit), Token::LexerKeyword(Per), Token::Unit(Second)) => { 840 840 - tokens[token_index-2] = Token::Unit(YobibitsPerSecond); 841 841 - }, 841 841 + tokens[token_index - 2] = Token::Unit(YobibitsPerSecond); 842 842 + } 842 843 // bytes per second 843 844 (Token::Unit(Byte), Token::LexerKeyword(Per), Token::Unit(Second)) => { 844 844 - tokens[token_index-2] = Token::Unit(BytesPerSecond); 845 845 - }, 845 845 + tokens[token_index - 2] = Token::Unit(BytesPerSecond); 846 846 + } 846 847 // kilobytes per second 847 848 (Token::Unit(Kilobyte), Token::LexerKeyword(Per), Token::Unit(Second)) => { 848 848 - tokens[token_index-2] = Token::Unit(KilobytesPerSecond); 849 849 - }, 849 849 + tokens[token_index - 2] = Token::Unit(KilobytesPerSecond); 850 850 + } 850 851 // megabytes per second 851 852 (Token::Unit(Megabyte), Token::LexerKeyword(Per), Token::Unit(Second)) => { 852 852 - tokens[token_index-2] = Token::Unit(MegabytesPerSecond); 853 853 - }, 853 853 + tokens[token_index - 2] = Token::Unit(MegabytesPerSecond); 854 854 + } 854 855 // gigabytes per second 855 856 (Token::Unit(Gigabyte), Token::LexerKeyword(Per), Token::Unit(Second)) => { 856 856 - tokens[token_index-2] = Token::Unit(GigabytesPerSecond); 857 857 - }, 857 857 + tokens[token_index - 2] = Token::Unit(GigabytesPerSecond); 858 858 + } 858 859 // terabytes per second 859 860 (Token::Unit(Terabyte), Token::LexerKeyword(Per), Token::Unit(Second)) => { 860 860 - tokens[token_index-2] = Token::Unit(TerabytesPerSecond); 861 861 - }, 861 861 + tokens[token_index - 2] = Token::Unit(TerabytesPerSecond); 862 862 + } 862 863 // petabytes per second 863 864 (Token::Unit(Petabyte), Token::LexerKeyword(Per), Token::Unit(Second)) => { 864 864 - tokens[token_index-2] = Token::Unit(PetabytesPerSecond); 865 865 - }, 865 865 + tokens[token_index - 2] = Token::Unit(PetabytesPerSecond); 866 866 + } 866 867 // exabytes per second 867 868 (Token::Unit(Exabyte), Token::LexerKeyword(Per), Token::Unit(Second)) => { 868 868 - tokens[token_index-2] = Token::Unit(ExabytesPerSecond); 869 869 - }, 869 869 + tokens[token_index - 2] = Token::Unit(ExabytesPerSecond); 870 870 + } 870 871 // zettabytes per second 871 872 (Token::Unit(Zettabyte), Token::LexerKeyword(Per), Token::Unit(Second)) => { 872 872 - tokens[token_index-2] = Token::Unit(ZettabytesPerSecond); 873 873 - }, 873 873 + tokens[token_index - 2] = Token::Unit(ZettabytesPerSecond); 874 874 + } 874 875 // yottabytes per second 875 876 (Token::Unit(Yottabyte), Token::LexerKeyword(Per), Token::Unit(Second)) => { 876 876 - tokens[token_index-2] = Token::Unit(YottabytesPerSecond); 877 877 - }, 877 877 + tokens[token_index - 2] = Token::Unit(YottabytesPerSecond); 878 878 + } 878 879 // kibibytes per second 879 880 (Token::Unit(Kibibyte), Token::LexerKeyword(Per), Token::Unit(Second)) => { 880 880 - tokens[token_index-2] = Token::Unit(KibibytesPerSecond); 881 881 - }, 881 881 + tokens[token_index - 2] = Token::Unit(KibibytesPerSecond); 882 882 + } 882 883 // mebibytes per second 883 884 (Token::Unit(Mebibyte), Token::LexerKeyword(Per), Token::Unit(Second)) => { 884 884 - tokens[token_index-2] = Token::Unit(MebibytesPerSecond); 885 885 - }, 885 885 + tokens[token_index - 2] = Token::Unit(MebibytesPerSecond); 886 886 + } 886 887 // gibibytes per second 887 888 (Token::Unit(Gibibyte), Token::LexerKeyword(Per), Token::Unit(Second)) => { 888 888 - tokens[token_index-2] = Token::Unit(GibibytesPerSecond); 889 889 - }, 889 889 + tokens[token_index - 2] = Token::Unit(GibibytesPerSecond); 890 890 + } 890 891 // tebibytes per second 891 892 (Token::Unit(Tebibyte), Token::LexerKeyword(Per), Token::Unit(Second)) => { 892 892 - tokens[token_index-2] = Token::Unit(TebibytesPerSecond); 893 893 - }, 893 893 + tokens[token_index - 2] = Token::Unit(TebibytesPerSecond); 894 894 + } 894 895 // pebibytes per second 895 896 (Token::Unit(Pebibyte), Token::LexerKeyword(Per), Token::Unit(Second)) => { 896 896 - tokens[token_index-2] = Token::Unit(PebibytesPerSecond); 897 897 - }, 897 897 + tokens[token_index - 2] = Token::Unit(PebibytesPerSecond); 898 898 + } 898 899 // exbibytes per second 899 900 (Token::Unit(Exbibyte), Token::LexerKeyword(Per), Token::Unit(Second)) => { 900 900 - tokens[token_index-2] = Token::Unit(ExbibytesPerSecond); 901 901 - }, 901 901 + tokens[token_index - 2] = Token::Unit(ExbibytesPerSecond); 902 902 + } 902 903 // zebibytes per second 903 904 (Token::Unit(Zebibyte), Token::LexerKeyword(Per), Token::Unit(Second)) => { 904 904 - tokens[token_index-2] = Token::Unit(ZebibytesPerSecond); 905 905 - }, 905 905 + tokens[token_index - 2] = Token::Unit(ZebibytesPerSecond); 906 906 + } 906 907 // yobibytes per second 907 908 (Token::Unit(Yobibyte), Token::LexerKeyword(Per), Token::Unit(Second)) => { 908 908 - tokens[token_index-2] = Token::Unit(YobibytesPerSecond); 909 909 - }, 909 909 + tokens[token_index - 2] = Token::Unit(YobibytesPerSecond); 910 910 + } 910 911 // FLOP per second 911 912 (Token::Unit(Flop), Token::LexerKeyword(Per), Token::Unit(Second)) => { 912 912 - tokens[token_index-2] = Token::Unit(FlopPerSecond); 913 913 - }, 913 913 + tokens[token_index - 2] = Token::Unit(FlopPerSecond); 914 914 + } 914 915 // kiloFLOP per second 915 916 (Token::Unit(KiloFlop), Token::LexerKeyword(Per), Token::Unit(Second)) => { 916 916 - tokens[token_index-2] = Token::Unit(KiloFlopPerSecond); 917 917 - }, 917 917 + tokens[token_index - 2] = Token::Unit(KiloFlopPerSecond); 918 918 + } 918 919 // megaFLOP per second 919 920 (Token::Unit(MegaFlop), Token::LexerKeyword(Per), Token::Unit(Second)) => { 920 920 - tokens[token_index-2] = Token::Unit(MegaFlopPerSecond); 921 921 - }, 921 921 + tokens[token_index - 2] = Token::Unit(MegaFlopPerSecond); 922 922 + } 922 923 // gigaFLOP per second 923 924 (Token::Unit(GigaFlop), Token::LexerKeyword(Per), Token::Unit(Second)) => { 924 924 - tokens[token_index-2] = Token::Unit(GigaFlopPerSecond); 925 925 - }, 925 925 + tokens[token_index - 2] = Token::Unit(GigaFlopPerSecond); 926 926 + } 926 927 // teraFLOP per second 927 928 (Token::Unit(TeraFlop), Token::LexerKeyword(Per), Token::Unit(Second)) => { 928 928 - tokens[token_index-2] = Token::Unit(TeraFlopPerSecond); 929 929 - }, 929 929 + tokens[token_index - 2] = Token::Unit(TeraFlopPerSecond); 930 930 + } 930 931 // petaFLOP per second 931 932 (Token::Unit(PetaFlop), Token::LexerKeyword(Per), Token::Unit(Second)) => { 932 932 - tokens[token_index-2] = Token::Unit(PetaFlopPerSecond); 933 933 - }, 933 933 + tokens[token_index - 2] = Token::Unit(PetaFlopPerSecond); 934 934 + } 934 935 // exaFLOP per second 935 936 (Token::Unit(ExaFlop), Token::LexerKeyword(Per), Token::Unit(Second)) => { 936 936 - tokens[token_index-2] = Token::Unit(ExaFlopPerSecond); 937 937 - }, 937 937 + tokens[token_index - 2] = Token::Unit(ExaFlopPerSecond); 938 938 + } 938 939 // zettaFLOP per second 939 940 (Token::Unit(ZettaFlop), Token::LexerKeyword(Per), Token::Unit(Second)) => { 940 940 - tokens[token_index-2] = Token::Unit(ZettaFlopPerSecond); 941 941 - }, 941 941 + tokens[token_index - 2] = Token::Unit(ZettaFlopPerSecond); 942 942 + } 942 943 // yottaFLOP per second 943 944 (Token::Unit(YottaFlop), Token::LexerKeyword(Per), Token::Unit(Second)) => { 944 944 - tokens[token_index-2] = Token::Unit(YottaFlopPerSecond); 945 945 - }, 945 945 + tokens[token_index - 2] = Token::Unit(YottaFlopPerSecond); 946 946 + } 946 947 // ronnaFLOP per second 947 948 (Token::Unit(RonnaFlop), Token::LexerKeyword(Per), Token::Unit(Second)) => { 948 948 - tokens[token_index-2] = Token::Unit(RonnaFlopPerSecond); 949 949 - }, 949 949 + tokens[token_index - 2] = Token::Unit(RonnaFlopPerSecond); 950 950 + } 950 951 // quettaFLOP per second 951 952 (Token::Unit(QuettaFlop), Token::LexerKeyword(Per), Token::Unit(Second)) => { 952 952 - tokens[token_index-2] = Token::Unit(QuettaFlopPerSecond); 953 953 - }, 953 953 + tokens[token_index - 2] = Token::Unit(QuettaFlopPerSecond); 954 954 + } 954 955 // btu/min 955 955 - (Token::Unit(BritishThermalUnit), Token::LexerKeyword(Per), Token::Unit(Minute)) => { 956 956 - tokens[token_index-2] = Token::Unit(BritishThermalUnitsPerMinute); 957 957 - }, 956 956 + ( 957 957 + Token::Unit(BritishThermalUnit), 958 958 + Token::LexerKeyword(Per), 959 959 + Token::Unit(Minute), 960 960 + ) => { 961 961 + tokens[token_index - 2] = Token::Unit(BritishThermalUnitsPerMinute); 962 962 + } 958 963 // btu/h 959 964 (Token::Unit(BritishThermalUnit), Token::LexerKeyword(Per), Token::Unit(Hour)) => { 960 960 - tokens[token_index-2] = Token::Unit(BritishThermalUnitsPerHour); 961 961 - }, 965 965 + tokens[token_index - 2] = Token::Unit(BritishThermalUnitsPerHour); 966 966 + } 962 967 // lbs/sqin 963 963 - (Token::LexerKeyword(PoundForce), Token::LexerKeyword(Per), Token::Unit(SquareInch)) => { 964 964 - tokens[token_index-2] = Token::Unit(PoundsPerSquareInch); 965 965 - }, 968 968 + ( 969 969 + Token::LexerKeyword(PoundForce), 970 970 + Token::LexerKeyword(Per), 971 971 + Token::Unit(SquareInch), 972 972 + ) => { 973 973 + tokens[token_index - 2] = Token::Unit(PoundsPerSquareInch); 974 974 + } 966 975 // inch of mercury 967 976 (Token::Unit(Inch), Token::TextOperator(Of), Token::LexerKeyword(Mercury)) => { 968 968 - tokens[token_index-2] = Token::Unit(InchOfMercury); 969 969 - }, 977 977 + tokens[token_index - 2] = Token::Unit(InchOfMercury); 978 978 + } 970 979 // revolutions per minute 971 971 - (Token::LexerKeyword(Revolution), Token::LexerKeyword(Per), Token::Unit(Minute)) => { 972 972 - tokens[token_index-2] = Token::Unit(RevolutionsPerMinute); 973 973 - }, 980 980 + ( 981 981 + Token::LexerKeyword(Revolution), 982 982 + Token::LexerKeyword(Per), 983 983 + Token::Unit(Minute), 984 984 + ) => { 985 985 + tokens[token_index - 2] = Token::Unit(RevolutionsPerMinute); 986 986 + } 974 987 _ => { 975 988 replaced = false; 976 976 - }, 989 989 + } 977 990 } 978 991 if replaced { 979 992 tokens.remove(token_index); 980 980 - tokens.remove(token_index-1); 993 993 + tokens.remove(token_index - 1); 981 994 token_index -= 2; 982 995 } 983 996 } 984 984 - if token_index == tokens.len()-1 { 997 997 + if token_index == tokens.len() - 1 { 985 998 break; 986 999 } else { 987 1000 token_index += 1; ··· 1010 1023 panic!("lex error: {}\nrun_lex input: {}", e, input); 1011 1024 } 1012 1025 }; 1013 1013 - let info_msg = format!("run_lex input: {}\nexpected: {:?}\nreceived: {:?}", input, expected_tokens, tokens); 1026 1026 + let info_msg = format!( 1027 1027 + "run_lex input: {}\nexpected: {:?}\nreceived: {:?}", 1028 1028 + input, expected_tokens, tokens 1029 1029 + ); 1014 1030 assert!(tokens == expected_tokens, "{info_msg}"); 1015 1031 1016 1032 // Prove we can handle multiple spaces wherever we handle a single space ··· 1024 1040 assert!(tokens_stripped_spaces == expected_tokens, "{info_msg}"); 1025 1041 1026 1042 // Prove we don't need a space after a digit 1027 1027 - let input_afterdigit_stripped_spaces = strip_afterdigit_spacing.replace_all(input, "$1"); 1028 1028 - let tokens_afterdigit_stripped_spaces = lex(&input_afterdigit_stripped_spaces, false).unwrap(); 1029 1029 - assert!(tokens_afterdigit_stripped_spaces == expected_tokens, "{info_msg}"); 1043 1043 + let input_afterdigit_stripped_spaces = 1044 1044 + strip_afterdigit_spacing.replace_all(input, "$1"); 1045 1045 + let tokens_afterdigit_stripped_spaces = 1046 1046 + lex(&input_afterdigit_stripped_spaces, false).unwrap(); 1047 1047 + assert!( 1048 1048 + tokens_afterdigit_stripped_spaces == expected_tokens, 1049 1049 + "{info_msg}" 1050 1050 + ); 1030 1051 }; 1031 1052 1032 1053 let run_datarate_lex = |input: &str, expected_tokens: Vec<Token>| { ··· 1035 1056 // Prove plural and non-plural data units behave identically 1036 1057 let input_nonplural_units = nonplural_data_units.replace_all(input, "$1"); 1037 1058 let tokens_nonplural_units = lex(&input_nonplural_units, false).unwrap(); 1038 1038 - let info_msg = format!("run_datarate_lex input: {}\nexpected: {:?}\nreceived: {:?}", input, expected_tokens, tokens_nonplural_units); 1059 1059 + let info_msg = format!( 1060 1060 + "run_datarate_lex input: {}\nexpected: {:?}\nreceived: {:?}", 1061 1061 + input, expected_tokens, tokens_nonplural_units 1062 1062 + ); 1039 1063 assert!(tokens_nonplural_units == expected_tokens, "{info_msg}"); 1040 1064 }; 1041 1065 1042 1042 - run_lex("88 kilometres * 2", vec![numtok!(88), Token::Unit(Kilometer), Token::Operator(Multiply), numtok!(2)]); 1066 1066 + run_lex( 1067 1067 + "88 kilometres * 2", 1068 1068 + vec![ 1069 1069 + numtok!(88), 1070 1070 + Token::Unit(Kilometer), 1071 1071 + Token::Operator(Multiply), 1072 1072 + numtok!(2), 1073 1073 + ], 1074 1074 + ); 1043 1075 run_lex("0.5 marathon", vec![numtok!(0.5), Token::Unit(Marathon)]); 1044 1076 run_lex("100 nmi", vec![numtok!(100), Token::Unit(NauticalMile)]); 1045 1045 - run_lex("101 nautical miles", vec![numtok!(101), Token::Unit(NauticalMile)]); 1077 1077 + run_lex( 1078 1078 + "101 nautical miles", 1079 1079 + vec![numtok!(101), Token::Unit(NauticalMile)], 1080 1080 + ); 1046 1081 run_lex("2 lightyears", vec![numtok!(2), Token::Unit(LightYear)]); 1047 1082 run_lex("1 light year", vec![numtok!(1), Token::Unit(LightYear)]); 1048 1083 run_lex("10 lightsec", vec![numtok!(10), Token::Unit(LightSecond)]); 1049 1084 run_lex("12 light secs", vec![numtok!(12), Token::Unit(LightSecond)]); 1050 1050 - run_lex("33.3 square meters", vec![numtok!(33.3), Token::Unit(SquareMeter)]); 1085 1085 + run_lex( 1086 1086 + "33.3 square meters", 1087 1087 + vec![numtok!(33.3), Token::Unit(SquareMeter)], 1088 1088 + ); 1051 1089 run_lex("54 m2", vec![numtok!(54), Token::Unit(SquareMeter)]); 1052 1090 run_lex("87 sq miles", vec![numtok!(87), Token::Unit(SquareMile)]); 1053 1091 run_lex("500 feet2", vec![numtok!(500), Token::Unit(SquareFoot)]); 1054 1092 run_lex("500 feet²", vec![numtok!(500), Token::Unit(SquareFoot)]); 1055 1093 run_lex("4 cubic metres", vec![numtok!(4), Token::Unit(CubicMeter)]); 1056 1056 - run_lex("34 cubic feet + 23 cubic yards", vec![numtok!(34), Token::Unit(CubicFoot), Token::Operator(Plus), numtok!(23), Token::Unit(CubicYard)]); 1057 1057 - run_lex("66 inches3 + 65 millimetre³", vec![numtok!(66), Token::Unit(CubicInch), Token::Operator(Plus), numtok!(65), Token::Unit(CubicMillimeter)]); 1058 1058 - run_lex("66 inches³ + 65 millimetre3", vec![numtok!(66), Token::Unit(CubicInch), Token::Operator(Plus), numtok!(65), Token::Unit(CubicMillimeter)]); 1094 1094 + run_lex( 1095 1095 + "34 cubic feet + 23 cubic yards", 1096 1096 + vec![ 1097 1097 + numtok!(34), 1098 1098 + Token::Unit(CubicFoot), 1099 1099 + Token::Operator(Plus), 1100 1100 + numtok!(23), 1101 1101 + Token::Unit(CubicYard), 1102 1102 + ], 1103 1103 + ); 1104 1104 + run_lex( 1105 1105 + "66 inches3 + 65 millimetre³", 1106 1106 + vec![ 1107 1107 + numtok!(66), 1108 1108 + Token::Unit(CubicInch), 1109 1109 + Token::Operator(Plus), 1110 1110 + numtok!(65), 1111 1111 + Token::Unit(CubicMillimeter), 1112 1112 + ], 1113 1113 + ); 1114 1114 + run_lex( 1115 1115 + "66 inches³ + 65 millimetre3", 1116 1116 + vec![ 1117 1117 + numtok!(66), 1118 1118 + Token::Unit(CubicInch), 1119 1119 + Token::Operator(Plus), 1120 1120 + numtok!(65), 1121 1121 + Token::Unit(CubicMillimeter), 1122 1122 + ], 1123 1123 + ); 1059 1124 run_lex("42 millilitres", vec![numtok!(42), Token::Unit(Milliliter)]); 1060 1125 run_lex("3 tbs", vec![numtok!(3), Token::Unit(Tablespoon)]); 1061 1126 run_lex("6 floz", vec![numtok!(6), Token::Unit(FluidOunce)]); ··· 1069 1134 run_lex("210 lbs", vec![numtok!(210), Token::Unit(Pound)]); 1070 1135 run_lex("210 pound", vec![numtok!(210), Token::Unit(Pound)]); 1071 1136 run_lex("210 pounds", vec![numtok!(210), Token::Unit(Pound)]); 1072 1072 - run_lex("210 pounds-force", vec![numtok!(210), Token::LexerKeyword(PoundForce)]); 1137 1137 + run_lex( 1138 1138 + "210 pounds-force", 1139 1139 + vec![numtok!(210), Token::LexerKeyword(PoundForce)], 1140 1140 + ); 1073 1141 run_lex("3 ton", vec![numtok!(3), Token::Unit(ShortTon)]); 1074 1142 run_lex("3 short tons", vec![numtok!(3), Token::Unit(ShortTon)]); 1075 1143 run_lex("4 lt", vec![numtok!(4), Token::Unit(LongTon)]); ··· 1100 1168 run_datarate_lex("2.1 terabytes", vec![numtok!(2.1), Token::Unit(Terabyte)]); 1101 1169 run_datarate_lex("1.08 petabytes", vec![numtok!(1.08), Token::Unit(Petabyte)]); 1102 1170 run_datarate_lex("0.73 exabytes", vec![numtok!(0.73), Token::Unit(Exabyte)]); 1103 1103 - run_datarate_lex("0.49 zettabytes", vec![numtok!(0.49), Token::Unit(Zettabyte)]); 1104 1104 - run_datarate_lex("0.23 yottabytes", vec![numtok!(0.23), Token::Unit(Yottabyte)]); 1171 1171 + run_datarate_lex( 1172 1172 + "0.49 zettabytes", 1173 1173 + vec![numtok!(0.49), Token::Unit(Zettabyte)], 1174 1174 + ); 1175 1175 + run_datarate_lex( 1176 1176 + "0.23 yottabytes", 1177 1177 + vec![numtok!(0.23), Token::Unit(Yottabyte)], 1178 1178 + ); 1105 1179 run_datarate_lex("63 kibibytes", vec![numtok!(63), Token::Unit(Kibibyte)]); 1106 1180 run_datarate_lex("32 mebibytes", vec![numtok!(32), Token::Unit(Mebibyte)]); 1107 1181 run_datarate_lex("3.5 gibibytes", vec![numtok!(3.5), Token::Unit(Gibibyte)]); ··· 1113 1187 run_lex("432 bps", vec![numtok!(432), Token::Unit(BitsPerSecond)]); 1114 1188 run_lex("56 kbps", vec![numtok!(56), Token::Unit(KilobitsPerSecond)]); 1115 1189 run_lex("12 mbps", vec![numtok!(12), Token::Unit(MegabitsPerSecond)]); 1116 1116 - run_lex("4.2 gbps", vec![numtok!(4.2), Token::Unit(GigabitsPerSecond)]); 1117 1117 - run_lex("2.2 tbps", vec![numtok!(2.2), Token::Unit(TerabitsPerSecond)]); 1118 1118 - run_lex("1.7 pbps", vec![numtok!(1.7), Token::Unit(PetabitsPerSecond)]); 1119 1119 - run_lex("0.99 ebps", vec![numtok!(0.99), Token::Unit(ExabitsPerSecond)]); 1120 1120 - run_lex("0.64 zbps", vec![numtok!(0.64), Token::Unit(ZettabitsPerSecond)]); 1121 1121 - run_lex("0.278 ybps", vec![numtok!(0.278), Token::Unit(YottabitsPerSecond)]); 1122 1122 - run_datarate_lex("4 bits per second", vec![numtok!(4), Token::Unit(BitsPerSecond)]); 1123 1123 - run_datarate_lex("5 kilobits per second", vec![numtok!(5), Token::Unit(KilobitsPerSecond)]); 1124 1124 - run_datarate_lex("6 megabits per second", vec![numtok!(6), Token::Unit(MegabitsPerSecond)]); 1125 1125 - run_datarate_lex("7 gigabits per second", vec![numtok!(7), Token::Unit(GigabitsPerSecond)]); 1126 1126 - run_datarate_lex("8 terabits per second", vec![numtok!(8), Token::Unit(TerabitsPerSecond)]); 1127 1127 - run_datarate_lex("9 petabits per second", vec![numtok!(9), Token::Unit(PetabitsPerSecond)]); 1128 1128 - run_datarate_lex("10 exabits per second", vec![numtok!(10), Token::Unit(ExabitsPerSecond)]); 1129 1129 - run_datarate_lex("11 zettabits per second", vec![numtok!(11), Token::Unit(ZettabitsPerSecond)]); 1130 1130 - run_datarate_lex("12 yottabits per second", vec![numtok!(12), Token::Unit(YottabitsPerSecond)]); 1131 1131 - run_datarate_lex("13 kibibits per second", vec![numtok!(13), Token::Unit(KibibitsPerSecond)]); 1132 1132 - run_datarate_lex("14 mebibits per second", vec![numtok!(14), Token::Unit(MebibitsPerSecond)]); 1133 1133 - run_datarate_lex("15 gibibits per second", vec![numtok!(15), Token::Unit(GibibitsPerSecond)]); 1134 1134 - run_datarate_lex("16 tebibits per second", vec![numtok!(16), Token::Unit(TebibitsPerSecond)]); 1135 1135 - run_datarate_lex("17 pebibits per second", vec![numtok!(17), Token::Unit(PebibitsPerSecond)]); 1136 1136 - run_datarate_lex("18 exbibits per second", vec![numtok!(18), Token::Unit(ExbibitsPerSecond)]); 1137 1137 - run_datarate_lex("19 zebibits per second", vec![numtok!(19), Token::Unit(ZebibitsPerSecond)]); 1138 1138 - run_datarate_lex("20 yobibits per second", vec![numtok!(20), Token::Unit(YobibitsPerSecond)]); 1139 1139 - run_datarate_lex("4 bytes per second", vec![numtok!(4), Token::Unit(BytesPerSecond)]); 1140 1140 - run_datarate_lex("5 kilobytes per second", vec![numtok!(5), Token::Unit(KilobytesPerSecond)]); 1141 1141 - run_datarate_lex("6 megabytes per second", vec![numtok!(6), Token::Unit(MegabytesPerSecond)]); 1142 1142 - run_datarate_lex("7 gigabytes per second", vec![numtok!(7), Token::Unit(GigabytesPerSecond)]); 1143 1143 - run_datarate_lex("8 terabytes per second", vec![numtok!(8), Token::Unit(TerabytesPerSecond)]); 1144 1144 - run_datarate_lex("9 petabytes per second", vec![numtok!(9), Token::Unit(PetabytesPerSecond)]); 1145 1145 - run_datarate_lex("10 exabytes per second", vec![numtok!(10), Token::Unit(ExabytesPerSecond)]); 1146 1146 - run_datarate_lex("11 zettabytes per second", vec![numtok!(11), Token::Unit(ZettabytesPerSecond)]); 1147 1147 - run_datarate_lex("12 yottabytes per second", vec![numtok!(12), Token::Unit(YottabytesPerSecond)]); 1148 1148 - run_datarate_lex("13 kibibytes per second", vec![numtok!(13), Token::Unit(KibibytesPerSecond)]); 1149 1149 - run_datarate_lex("14 mebibytes per second", vec![numtok!(14), Token::Unit(MebibytesPerSecond)]); 1150 1150 - run_datarate_lex("15 gibibytes per second", vec![numtok!(15), Token::Unit(GibibytesPerSecond)]); 1151 1151 - run_datarate_lex("16 tebibytes per second", vec![numtok!(16), Token::Unit(TebibytesPerSecond)]); 1152 1152 - run_datarate_lex("17 pebibytes per second", vec![numtok!(17), Token::Unit(PebibytesPerSecond)]); 1153 1153 - run_datarate_lex("18 exbibytes per second", vec![numtok!(18), Token::Unit(ExbibytesPerSecond)]); 1154 1154 - run_datarate_lex("19 zebibytes per second", vec![numtok!(19), Token::Unit(ZebibytesPerSecond)]); 1155 1155 - run_datarate_lex("20 yobibytes per second", vec![numtok!(20), Token::Unit(YobibytesPerSecond)]); 1190 1190 + run_lex( 1191 1191 + "4.2 gbps", 1192 1192 + vec![numtok!(4.2), Token::Unit(GigabitsPerSecond)], 1193 1193 + ); 1194 1194 + run_lex( 1195 1195 + "2.2 tbps", 1196 1196 + vec![numtok!(2.2), Token::Unit(TerabitsPerSecond)], 1197 1197 + ); 1198 1198 + run_lex( 1199 1199 + "1.7 pbps", 1200 1200 + vec![numtok!(1.7), Token::Unit(PetabitsPerSecond)], 1201 1201 + ); 1202 1202 + run_lex( 1203 1203 + "0.99 ebps", 1204 1204 + vec![numtok!(0.99), Token::Unit(ExabitsPerSecond)], 1205 1205 + ); 1206 1206 + run_lex( 1207 1207 + "0.64 zbps", 1208 1208 + vec![numtok!(0.64), Token::Unit(ZettabitsPerSecond)], 1209 1209 + ); 1210 1210 + run_lex( 1211 1211 + "0.278 ybps", 1212 1212 + vec![numtok!(0.278), Token::Unit(YottabitsPerSecond)], 1213 1213 + ); 1214 1214 + run_datarate_lex( 1215 1215 + "4 bits per second", 1216 1216 + vec![numtok!(4), Token::Unit(BitsPerSecond)], 1217 1217 + ); 1218 1218 + run_datarate_lex( 1219 1219 + "5 kilobits per second", 1220 1220 + vec![numtok!(5), Token::Unit(KilobitsPerSecond)], 1221 1221 + ); 1222 1222 + run_datarate_lex( 1223 1223 + "6 megabits per second", 1224 1224 + vec![numtok!(6), Token::Unit(MegabitsPerSecond)], 1225 1225 + ); 1226 1226 + run_datarate_lex( 1227 1227 + "7 gigabits per second", 1228 1228 + vec![numtok!(7), Token::Unit(GigabitsPerSecond)], 1229 1229 + ); 1230 1230 + run_datarate_lex( 1231 1231 + "8 terabits per second", 1232 1232 + vec![numtok!(8), Token::Unit(TerabitsPerSecond)], 1233 1233 + ); 1234 1234 + run_datarate_lex( 1235 1235 + "9 petabits per second", 1236 1236 + vec![numtok!(9), Token::Unit(PetabitsPerSecond)], 1237 1237 + ); 1238 1238 + run_datarate_lex( 1239 1239 + "10 exabits per second", 1240 1240 + vec![numtok!(10), Token::Unit(ExabitsPerSecond)], 1241 1241 + ); 1242 1242 + run_datarate_lex( 1243 1243 + "11 zettabits per second", 1244 1244 + vec![numtok!(11), Token::Unit(ZettabitsPerSecond)], 1245 1245 + ); 1246 1246 + run_datarate_lex( 1247 1247 + "12 yottabits per second", 1248 1248 + vec![numtok!(12), Token::Unit(YottabitsPerSecond)], 1249 1249 + ); 1250 1250 + run_datarate_lex( 1251 1251 + "13 kibibits per second", 1252 1252 + vec![numtok!(13), Token::Unit(KibibitsPerSecond)], 1253 1253 + ); 1254 1254 + run_datarate_lex( 1255 1255 + "14 mebibits per second", 1256 1256 + vec![numtok!(14), Token::Unit(MebibitsPerSecond)], 1257 1257 + ); 1258 1258 + run_datarate_lex( 1259 1259 + "15 gibibits per second", 1260 1260 + vec![numtok!(15), Token::Unit(GibibitsPerSecond)], 1261 1261 + ); 1262 1262 + run_datarate_lex( 1263 1263 + "16 tebibits per second", 1264 1264 + vec![numtok!(16), Token::Unit(TebibitsPerSecond)], 1265 1265 + ); 1266 1266 + run_datarate_lex( 1267 1267 + "17 pebibits per second", 1268 1268 + vec![numtok!(17), Token::Unit(PebibitsPerSecond)], 1269 1269 + ); 1270 1270 + run_datarate_lex( 1271 1271 + "18 exbibits per second", 1272 1272 + vec![numtok!(18), Token::Unit(ExbibitsPerSecond)], 1273 1273 + ); 1274 1274 + run_datarate_lex( 1275 1275 + "19 zebibits per second", 1276 1276 + vec![numtok!(19), Token::Unit(ZebibitsPerSecond)], 1277 1277 + ); 1278 1278 + run_datarate_lex( 1279 1279 + "20 yobibits per second", 1280 1280 + vec![numtok!(20), Token::Unit(YobibitsPerSecond)], 1281 1281 + ); 1282 1282 + run_datarate_lex( 1283 1283 + "4 bytes per second", 1284 1284 + vec![numtok!(4), Token::Unit(BytesPerSecond)], 1285 1285 + ); 1286 1286 + run_datarate_lex( 1287 1287 + "5 kilobytes per second", 1288 1288 + vec![numtok!(5), Token::Unit(KilobytesPerSecond)], 1289 1289 + ); 1290 1290 + run_datarate_lex( 1291 1291 + "6 megabytes per second", 1292 1292 + vec![numtok!(6), Token::Unit(MegabytesPerSecond)], 1293 1293 + ); 1294 1294 + run_datarate_lex( 1295 1295 + "7 gigabytes per second", 1296 1296 + vec![numtok!(7), Token::Unit(GigabytesPerSecond)], 1297 1297 + ); 1298 1298 + run_datarate_lex( 1299 1299 + "8 terabytes per second", 1300 1300 + vec![numtok!(8), Token::Unit(TerabytesPerSecond)], 1301 1301 + ); 1302 1302 + run_datarate_lex( 1303 1303 + "9 petabytes per second", 1304 1304 + vec![numtok!(9), Token::Unit(PetabytesPerSecond)], 1305 1305 + ); 1306 1306 + run_datarate_lex( 1307 1307 + "10 exabytes per second", 1308 1308 + vec![numtok!(10), Token::Unit(ExabytesPerSecond)], 1309 1309 + ); 1310 1310 + run_datarate_lex( 1311 1311 + "11 zettabytes per second", 1312 1312 + vec![numtok!(11), Token::Unit(ZettabytesPerSecond)], 1313 1313 + ); 1314 1314 + run_datarate_lex( 1315 1315 + "12 yottabytes per second", 1316 1316 + vec![numtok!(12), Token::Unit(YottabytesPerSecond)], 1317 1317 + ); 1318 1318 + run_datarate_lex( 1319 1319 + "13 kibibytes per second", 1320 1320 + vec![numtok!(13), Token::Unit(KibibytesPerSecond)], 1321 1321 + ); 1322 1322 + run_datarate_lex( 1323 1323 + "14 mebibytes per second", 1324 1324 + vec![numtok!(14), Token::Unit(MebibytesPerSecond)], 1325 1325 + ); 1326 1326 + run_datarate_lex( 1327 1327 + "15 gibibytes per second", 1328 1328 + vec![numtok!(15), Token::Unit(GibibytesPerSecond)], 1329 1329 + ); 1330 1330 + run_datarate_lex( 1331 1331 + "16 tebibytes per second", 1332 1332 + vec![numtok!(16), Token::Unit(TebibytesPerSecond)], 1333 1333 + ); 1334 1334 + run_datarate_lex( 1335 1335 + "17 pebibytes per second", 1336 1336 + vec![numtok!(17), Token::Unit(PebibytesPerSecond)], 1337 1337 + ); 1338 1338 + run_datarate_lex( 1339 1339 + "18 exbibytes per second", 1340 1340 + vec![numtok!(18), Token::Unit(ExbibytesPerSecond)], 1341 1341 + ); 1342 1342 + run_datarate_lex( 1343 1343 + "19 zebibytes per second", 1344 1344 + vec![numtok!(19), Token::Unit(ZebibytesPerSecond)], 1345 1345 + ); 1346 1346 + run_datarate_lex( 1347 1347 + "20 yobibytes per second", 1348 1348 + vec![numtok!(20), Token::Unit(YobibytesPerSecond)], 1349 1349 + ); 1156 1350 run_lex("1 flop", vec![numtok!(1), Token::Unit(Flop)]); 1157 1351 run_lex("2 kflop", vec![numtok!(2), Token::Unit(KiloFlop)]); 1158 1352 run_lex("3 mflop", vec![numtok!(3), Token::Unit(MegaFlop)]); ··· 1165 1359 run_lex("10 rflop", vec![numtok!(10), Token::Unit(RonnaFlop)]); 1166 1360 run_lex("11 qflop", vec![numtok!(11), Token::Unit(QuettaFlop)]); 1167 1361 run_lex("1 flop/s", vec![numtok!(1), Token::Unit(FlopPerSecond)]); 1168 1168 - run_lex("2 kflop/s", vec![numtok!(2), Token::Unit(KiloFlopPerSecond)]); 1169 1169 - run_lex("3 mflop/s", vec![numtok!(3), Token::Unit(MegaFlopPerSecond)]); 1170 1170 - run_lex("4 gflop/s", vec![numtok!(4), Token::Unit(GigaFlopPerSecond)]); 1171 1171 - run_lex("5 tflop/s", vec![numtok!(5), Token::Unit(TeraFlopPerSecond)]); 1172 1172 - run_lex("6 pflop/s", vec![numtok!(6), Token::Unit(PetaFlopPerSecond)]); 1362 1362 + run_lex( 1363 1363 + "2 kflop/s", 1364 1364 + vec![numtok!(2), Token::Unit(KiloFlopPerSecond)], 1365 1365 + ); 1366 1366 + run_lex( 1367 1367 + "3 mflop/s", 1368 1368 + vec![numtok!(3), Token::Unit(MegaFlopPerSecond)], 1369 1369 + ); 1370 1370 + run_lex( 1371 1371 + "4 gflop/s", 1372 1372 + vec![numtok!(4), Token::Unit(GigaFlopPerSecond)], 1373 1373 + ); 1374 1374 + run_lex( 1375 1375 + "5 tflop/s", 1376 1376 + vec![numtok!(5), Token::Unit(TeraFlopPerSecond)], 1377 1377 + ); 1378 1378 + run_lex( 1379 1379 + "6 pflop/s", 1380 1380 + vec![numtok!(6), Token::Unit(PetaFlopPerSecond)], 1381 1381 + ); 1173 1382 run_lex("7 eflop/s", vec![numtok!(7), Token::Unit(ExaFlopPerSecond)]); 1174 1174 - run_lex("8 zflop/s", vec![numtok!(8), Token::Unit(ZettaFlopPerSecond)]); 1175 1175 - run_lex("9 yflop/s", vec![numtok!(9), Token::Unit(YottaFlopPerSecond)]); 1176 1176 - run_lex("10 rflop/s", vec![numtok!(10), Token::Unit(RonnaFlopPerSecond)]); 1177 1177 - run_lex("11 qflop/s", vec![numtok!(11), Token::Unit(QuettaFlopPerSecond)]); 1178 1178 - run_lex("1 flop per second", vec![numtok!(1), Token::Unit(FlopPerSecond)]); 1179 1179 - run_lex("2 kflop per second", vec![numtok!(2), Token::Unit(KiloFlopPerSecond)]); 1180 1180 - run_lex("3 mflop per second", vec![numtok!(3), Token::Unit(MegaFlopPerSecond)]); 1181 1181 - run_lex("4 gflop per second", vec![numtok!(4), Token::Unit(GigaFlopPerSecond)]); 1182 1182 - run_lex("5 tflop per second", vec![numtok!(5), Token::Unit(TeraFlopPerSecond)]); 1183 1183 - run_lex("6 pflop per second", vec![numtok!(6), Token::Unit(PetaFlopPerSecond)]); 1184 1184 - run_lex("7 eflop per second", vec![numtok!(7), Token::Unit(ExaFlopPerSecond)]); 1185 1185 - run_lex("8 zflop per second", vec![numtok!(8), Token::Unit(ZettaFlopPerSecond)]); 1186 1186 - run_lex("9 yflop per second", vec![numtok!(9), Token::Unit(YottaFlopPerSecond)]); 1187 1187 - run_lex("10 rflop per second", vec![numtok!(10), Token::Unit(RonnaFlopPerSecond)]); 1188 1188 - run_lex("11 qflop per second", vec![numtok!(11), Token::Unit(QuettaFlopPerSecond)]); 1383 1383 + run_lex( 1384 1384 + "8 zflop/s", 1385 1385 + vec![numtok!(8), Token::Unit(ZettaFlopPerSecond)], 1386 1386 + ); 1387 1387 + run_lex( 1388 1388 + "9 yflop/s", 1389 1389 + vec![numtok!(9), Token::Unit(YottaFlopPerSecond)], 1390 1390 + ); 1391 1391 + run_lex( 1392 1392 + "10 rflop/s", 1393 1393 + vec![numtok!(10), Token::Unit(RonnaFlopPerSecond)], 1394 1394 + ); 1395 1395 + run_lex( 1396 1396 + "11 qflop/s", 1397 1397 + vec![numtok!(11), Token::Unit(QuettaFlopPerSecond)], 1398 1398 + ); 1399 1399 + run_lex( 1400 1400 + "1 flop per second", 1401 1401 + vec![numtok!(1), Token::Unit(FlopPerSecond)], 1402 1402 + ); 1403 1403 + run_lex( 1404 1404 + "2 kflop per second", 1405 1405 + vec![numtok!(2), Token::Unit(KiloFlopPerSecond)], 1406 1406 + ); 1407 1407 + run_lex( 1408 1408 + "3 mflop per second", 1409 1409 + vec![numtok!(3), Token::Unit(MegaFlopPerSecond)], 1410 1410 + ); 1411 1411 + run_lex( 1412 1412 + "4 gflop per second", 1413 1413 + vec![numtok!(4), Token::Unit(GigaFlopPerSecond)], 1414 1414 + ); 1415 1415 + run_lex( 1416 1416 + "5 tflop per second", 1417 1417 + vec![numtok!(5), Token::Unit(TeraFlopPerSecond)], 1418 1418 + ); 1419 1419 + run_lex( 1420 1420 + "6 pflop per second", 1421 1421 + vec![numtok!(6), Token::Unit(PetaFlopPerSecond)], 1422 1422 + ); 1423 1423 + run_lex( 1424 1424 + "7 eflop per second", 1425 1425 + vec![numtok!(7), Token::Unit(ExaFlopPerSecond)], 1426 1426 + ); 1427 1427 + run_lex( 1428 1428 + "8 zflop per second", 1429 1429 + vec![numtok!(8), Token::Unit(ZettaFlopPerSecond)], 1430 1430 + ); 1431 1431 + run_lex( 1432 1432 + "9 yflop per second", 1433 1433 + vec![numtok!(9), Token::Unit(YottaFlopPerSecond)], 1434 1434 + ); 1435 1435 + run_lex( 1436 1436 + "10 rflop per second", 1437 1437 + vec![numtok!(10), Token::Unit(RonnaFlopPerSecond)], 1438 1438 + ); 1439 1439 + run_lex( 1440 1440 + "11 qflop per second", 1441 1441 + vec![numtok!(11), Token::Unit(QuettaFlopPerSecond)], 1442 1442 + ); 1189 1443 run_lex("1 flops", vec![numtok!(1), Token::Unit(FlopPerSecond)]); 1190 1444 run_lex("2 kflops", vec![numtok!(2), Token::Unit(KiloFlopPerSecond)]); 1191 1445 run_lex("3 mflops", vec![numtok!(3), Token::Unit(MegaFlopPerSecond)]); ··· 1193 1447 run_lex("5 tflops", vec![numtok!(5), Token::Unit(TeraFlopPerSecond)]); 1194 1448 run_lex("6 pflops", vec![numtok!(6), Token::Unit(PetaFlopPerSecond)]); 1195 1449 run_lex("7 eflops", vec![numtok!(7), Token::Unit(ExaFlopPerSecond)]); 1196 1196 - run_lex("8 zflops", vec![numtok!(8), Token::Unit(ZettaFlopPerSecond)]); 1197 1197 - run_lex("9 yflops", vec![numtok!(9), Token::Unit(YottaFlopPerSecond)]); 1198 1198 - run_lex("10 rflops", vec![numtok!(10), Token::Unit(RonnaFlopPerSecond)]); 1199 1199 - run_lex("11 qflops", vec![numtok!(11), Token::Unit(QuettaFlopPerSecond)]); 1450 1450 + run_lex( 1451 1451 + "8 zflops", 1452 1452 + vec![numtok!(8), Token::Unit(ZettaFlopPerSecond)], 1453 1453 + ); 1454 1454 + run_lex( 1455 1455 + "9 yflops", 1456 1456 + vec![numtok!(9), Token::Unit(YottaFlopPerSecond)], 1457 1457 + ); 1458 1458 + run_lex( 1459 1459 + "10 rflops", 1460 1460 + vec![numtok!(10), Token::Unit(RonnaFlopPerSecond)], 1461 1461 + ); 1462 1462 + run_lex( 1463 1463 + "11 qflops", 1464 1464 + vec![numtok!(11), Token::Unit(QuettaFlopPerSecond)], 1465 1465 + ); 1200 1466 run_lex("234 wh", vec![numtok!(234), Token::Unit(WattHour)]); 1201 1467 run_lex("1 w", vec![numtok!(1), Token::Unit(Watt)]); 1202 1468 run_lex("1 watt", vec![numtok!(1), Token::Unit(Watt)]); 1203 1469 run_lex("1 watts", vec![numtok!(1), Token::Unit(Watt)]); 1204 1470 run_lex("1 watt hour", vec![numtok!(1), Token::Unit(WattHour)]); 1205 1205 - run_lex("0 watt + 1 watts", vec![numtok!(0), Token::Unit(Watt), Token::Operator(Plus), numtok!(1), Token::Unit(Watt)]); 1206 1206 - run_lex("0 watt * 1", vec![numtok!(0), Token::Unit(Watt), Token::Operator(Multiply), numtok!(1)]); 1207 1207 - run_lex("2 watts + 3 watts", vec![numtok!(2), Token::Unit(Watt), Token::Operator(Plus), numtok!(3), Token::Unit(Watt)]); 1208 1208 - run_lex("2 watts * 3", vec![numtok!(2), Token::Unit(Watt), Token::Operator(Multiply), numtok!(3)]); 1209 1209 - run_lex("4 watt plus 5 watts", vec![numtok!(4), Token::Unit(Watt), Token::Operator(Plus), numtok!(5), Token::Unit(Watt)]); 1210 1210 - run_lex("4 watt times 5", vec![numtok!(4), Token::Unit(Watt), Token::Operator(Multiply), numtok!(5)]); 1211 1211 - run_lex("6 watts plus 7 watts", vec![numtok!(6), Token::Unit(Watt), Token::Operator(Plus), numtok!(7), Token::Unit(Watt)]); 1212 1212 - run_lex("6 watts times 7", vec![numtok!(6), Token::Unit(Watt), Token::Operator(Multiply), numtok!(7)]); 1471 1471 + run_lex( 1472 1472 + "0 watt + 1 watts", 1473 1473 + vec![ 1474 1474 + numtok!(0), 1475 1475 + Token::Unit(Watt), 1476 1476 + Token::Operator(Plus), 1477 1477 + numtok!(1), 1478 1478 + Token::Unit(Watt), 1479 1479 + ], 1480 1480 + ); 1481 1481 + run_lex( 1482 1482 + "0 watt * 1", 1483 1483 + vec![ 1484 1484 + numtok!(0), 1485 1485 + Token::Unit(Watt), 1486 1486 + Token::Operator(Multiply), 1487 1487 + numtok!(1), 1488 1488 + ], 1489 1489 + ); 1490 1490 + run_lex( 1491 1491 + "2 watts + 3 watts", 1492 1492 + vec![ 1493 1493 + numtok!(2), 1494 1494 + Token::Unit(Watt), 1495 1495 + Token::Operator(Plus), 1496 1496 + numtok!(3), 1497 1497 + Token::Unit(Watt), 1498 1498 + ], 1499 1499 + ); 1500 1500 + run_lex( 1501 1501 + "2 watts * 3", 1502 1502 + vec![ 1503 1503 + numtok!(2), 1504 1504 + Token::Unit(Watt), 1505 1505 + Token::Operator(Multiply), 1506 1506 + numtok!(3), 1507 1507 + ], 1508 1508 + ); 1509 1509 + run_lex( 1510 1510 + "4 watt plus 5 watts", 1511 1511 + vec![ 1512 1512 + numtok!(4), 1513 1513 + Token::Unit(Watt), 1514 1514 + Token::Operator(Plus), 1515 1515 + numtok!(5), 1516 1516 + Token::Unit(Watt), 1517 1517 + ], 1518 1518 + ); 1519 1519 + run_lex( 1520 1520 + "4 watt times 5", 1521 1521 + vec![ 1522 1522 + numtok!(4), 1523 1523 + Token::Unit(Watt), 1524 1524 + Token::Operator(Multiply), 1525 1525 + numtok!(5), 1526 1526 + ], 1527 1527 + ); 1528 1528 + run_lex( 1529 1529 + "6 watts plus 7 watts", 1530 1530 + vec![ 1531 1531 + numtok!(6), 1532 1532 + Token::Unit(Watt), 1533 1533 + Token::Operator(Plus), 1534 1534 + numtok!(7), 1535 1535 + Token::Unit(Watt), 1536 1536 + ], 1537 1537 + ); 1538 1538 + run_lex( 1539 1539 + "6 watts times 7", 1540 1540 + vec![ 1541 1541 + numtok!(6), 1542 1542 + Token::Unit(Watt), 1543 1543 + Token::Operator(Multiply), 1544 1544 + numtok!(7), 1545 1545 + ], 1546 1546 + ); 1213 1547 run_lex("2.3 kwh", vec![numtok!(2.3), Token::Unit(KilowattHour)]); 1214 1548 run_lex("1 kw", vec![numtok!(1), Token::Unit(Kilowatt)]); 1215 1549 run_lex("1 kilowatt", vec![numtok!(1), Token::Unit(Kilowatt)]); 1216 1550 run_lex("1 kilowatts", vec![numtok!(1), Token::Unit(Kilowatt)]); 1217 1217 - run_lex("1 kilowatt hour", vec![numtok!(1), Token::Unit(KilowattHour)]); 1218 1218 - run_lex("2 kilowatt + 3 watt", vec![numtok!(2), Token::Unit(Kilowatt), Token::Operator(Plus), numtok!(3), Token::Unit(Watt)]); 1219 1219 - run_lex("2 kilowatt * 4", vec![numtok!(2), Token::Unit(Kilowatt), Token::Operator(Multiply), numtok!(4)]); 1220 1220 - run_lex("2 kilowatt times 4", vec![numtok!(2), Token::Unit(Kilowatt), Token::Operator(Multiply), numtok!(4)]); 1221 1221 - run_lex("2 kilowatt + 3 watts", vec![numtok!(2), Token::Unit(Kilowatt), Token::Operator(Plus), numtok!(3), Token::Unit(Watt)]); 1222 1222 - run_lex("2 kilowatts + 3 watt", vec![numtok!(2), Token::Unit(Kilowatt), Token::Operator(Plus), numtok!(3), Token::Unit(Watt)]); 1223 1223 - run_lex("2 kilowatts + 3 watts", vec![numtok!(2), Token::Unit(Kilowatt), Token::Operator(Plus), numtok!(3), Token::Unit(Watt)]); 1224 1224 - run_lex("2 kilowatt plus 3 watt", vec![numtok!(2), Token::Unit(Kilowatt), Token::Operator(Plus), numtok!(3), Token::Unit(Watt)]); 1225 1225 - run_lex("2 kilowatt plus 3 watts", vec![numtok!(2), Token::Unit(Kilowatt), Token::Operator(Plus), numtok!(3), Token::Unit(Watt)]); 1226 1226 - run_lex("2 kilowatts plus 3 watt", vec![numtok!(2), Token::Unit(Kilowatt), Token::Operator(Plus), numtok!(3), Token::Unit(Watt)]); 1227 1227 - run_lex("2 kilowatts plus 3 watts", vec![numtok!(2), Token::Unit(Kilowatt), Token::Operator(Plus), numtok!(3), Token::Unit(Watt)]); 1228 1228 - run_lex("6.6 watts + 4 kilowatts", vec![numtok!(6.6), Token::Unit(Watt), Token::Operator(Plus), numtok!(4), Token::Unit(Kilowatt)]); 1229 1229 - run_lex("6.6 watts plus 4 kilowatts", vec![numtok!(6.6), Token::Unit(Watt), Token::Operator(Plus), numtok!(4), Token::Unit(Kilowatt)]); 1551 1551 + run_lex( 1552 1552 + "1 kilowatt hour", 1553 1553 + vec![numtok!(1), Token::Unit(KilowattHour)], 1554 1554 + ); 1555 1555 + run_lex( 1556 1556 + "2 kilowatt + 3 watt", 1557 1557 + vec![ 1558 1558 + numtok!(2), 1559 1559 + Token::Unit(Kilowatt), 1560 1560 + Token::Operator(Plus), 1561 1561 + numtok!(3), 1562 1562 + Token::Unit(Watt), 1563 1563 + ], 1564 1564 + ); 1565 1565 + run_lex( 1566 1566 + "2 kilowatt * 4", 1567 1567 + vec![ 1568 1568 + numtok!(2), 1569 1569 + Token::Unit(Kilowatt), 1570 1570 + Token::Operator(Multiply), 1571 1571 + numtok!(4), 1572 1572 + ], 1573 1573 + ); 1574 1574 + run_lex( 1575 1575 + "2 kilowatt times 4", 1576 1576 + vec![ 1577 1577 + numtok!(2), 1578 1578 + Token::Unit(Kilowatt), 1579 1579 + Token::Operator(Multiply), 1580 1580 + numtok!(4), 1581 1581 + ], 1582 1582 + ); 1583 1583 + run_lex( 1584 1584 + "2 kilowatt + 3 watts", 1585 1585 + vec![ 1586 1586 + numtok!(2), 1587 1587 + Token::Unit(Kilowatt), 1588 1588 + Token::Operator(Plus), 1589 1589 + numtok!(3), 1590 1590 + Token::Unit(Watt), 1591 1591 + ], 1592 1592 + ); 1593 1593 + run_lex( 1594 1594 + "2 kilowatts + 3 watt", 1595 1595 + vec![ 1596 1596 + numtok!(2), 1597 1597 + Token::Unit(Kilowatt), 1598 1598 + Token::Operator(Plus), 1599 1599 + numtok!(3), 1600 1600 + Token::Unit(Watt), 1601 1601 + ], 1602 1602 + ); 1603 1603 + run_lex( 1604 1604 + "2 kilowatts + 3 watts", 1605 1605 + vec![ 1606 1606 + numtok!(2), 1607 1607 + Token::Unit(Kilowatt), 1608 1608 + Token::Operator(Plus), 1609 1609 + numtok!(3), 1610 1610 + Token::Unit(Watt), 1611 1611 + ], 1612 1612 + ); 1613 1613 + run_lex( 1614 1614 + "2 kilowatt plus 3 watt", 1615 1615 + vec![ 1616 1616 + numtok!(2), 1617 1617 + Token::Unit(Kilowatt), 1618 1618 + Token::Operator(Plus), 1619 1619 + numtok!(3), 1620 1620 + Token::Unit(Watt), 1621 1621 + ], 1622 1622 + ); 1623 1623 + run_lex( 1624 1624 + "2 kilowatt plus 3 watts", 1625 1625 + vec![ 1626 1626 + numtok!(2), 1627 1627 + Token::Unit(Kilowatt), 1628 1628 + Token::Operator(Plus), 1629 1629 + numtok!(3), 1630 1630 + Token::Unit(Watt), 1631 1631 + ], 1632 1632 + ); 1633 1633 + run_lex( 1634 1634 + "2 kilowatts plus 3 watt", 1635 1635 + vec![ 1636 1636 + numtok!(2), 1637 1637 + Token::Unit(Kilowatt), 1638 1638 + Token::Operator(Plus), 1639 1639 + numtok!(3), 1640 1640 + Token::Unit(Watt), 1641 1641 + ], 1642 1642 + ); 1643 1643 + run_lex( 1644 1644 + "2 kilowatts plus 3 watts", 1645 1645 + vec![ 1646 1646 + numtok!(2), 1647 1647 + Token::Unit(Kilowatt), 1648 1648 + Token::Operator(Plus), 1649 1649 + numtok!(3), 1650 1650 + Token::Unit(Watt), 1651 1651 + ], 1652 1652 + ); 1653 1653 + run_lex( 1654 1654 + "6.6 watts + 4 kilowatts", 1655 1655 + vec![ 1656 1656 + numtok!(6.6), 1657 1657 + Token::Unit(Watt), 1658 1658 + Token::Operator(Plus), 1659 1659 + numtok!(4), 1660 1660 + Token::Unit(Kilowatt), 1661 1661 + ], 1662 1662 + ); 1663 1663 + run_lex( 1664 1664 + "6.6 watts plus 4 kilowatts", 1665 1665 + vec![ 1666 1666 + numtok!(6.6), 1667 1667 + Token::Unit(Watt), 1668 1668 + Token::Operator(Plus), 1669 1669 + numtok!(4), 1670 1670 + Token::Unit(Kilowatt), 1671 1671 + ], 1672 1672 + ); 1230 1673 run_lex("2.3 mwh", vec![numtok!(2.3), Token::Unit(MegawattHour)]); 1231 1674 run_lex("1 mw", vec![numtok!(1), Token::Unit(Megawatt)]); 1232 1675 run_lex("1 megawatt", vec![numtok!(1), Token::Unit(Megawatt)]); 1233 1233 - run_lex("1 megawatt hour", vec![numtok!(1), Token::Unit(MegawattHour)]); 1234 1234 - run_lex("2 megawatt + 3 watt", vec![numtok!(2), Token::Unit(Megawatt), Token::Operator(Plus), numtok!(3), Token::Unit(Watt)]); 1235 1235 - run_lex("2 megawatt * 6", vec![numtok!(2), Token::Unit(Megawatt), Token::Operator(Multiply), numtok!(6)]); 1236 1236 - run_lex("2 megawatt times 6", vec![numtok!(2), Token::Unit(Megawatt), Token::Operator(Multiply), numtok!(6)]); 1237 1237 - run_lex("2 megawatt + 3 watts", vec![numtok!(2), Token::Unit(Megawatt), Token::Operator(Plus), numtok!(3), Token::Unit(Watt)]); 1238 1238 - run_lex("2 megawatts + 3 watt", vec![numtok!(2), Token::Unit(Megawatt), Token::Operator(Plus), numtok!(3), Token::Unit(Watt)]); 1239 1239 - run_lex("2 megawatts + 3 watts", vec![numtok!(2), Token::Unit(Megawatt), Token::Operator(Plus), numtok!(3), Token::Unit(Watt)]); 1240 1240 - run_lex("2 megawatt plus 3 watt", vec![numtok!(2), Token::Unit(Megawatt), Token::Operator(Plus), numtok!(3), Token::Unit(Watt)]); 1241 1241 - run_lex("2 megawatt plus 3 watts", vec![numtok!(2), Token::Unit(Megawatt), Token::Operator(Plus), numtok!(3), Token::Unit(Watt)]); 1242 1242 - run_lex("2 megawatts plus 3 watt", vec![numtok!(2), Token::Unit(Megawatt), Token::Operator(Plus), numtok!(3), Token::Unit(Watt)]); 1243 1243 - run_lex("2 megawatts plus 3 watts", vec![numtok!(2), Token::Unit(Megawatt), Token::Operator(Plus), numtok!(3), Token::Unit(Watt)]); 1244 1244 - run_lex("6.6 watts + 4 megawatts", vec![numtok!(6.6), Token::Unit(Watt), Token::Operator(Plus), numtok!(4), Token::Unit(Megawatt)]); 1245 1245 - run_lex("6.6 watts plus 4 megawatts", vec![numtok!(6.6), Token::Unit(Watt), Token::Operator(Plus), numtok!(4), Token::Unit(Megawatt)]); 1676 1676 + run_lex( 1677 1677 + "1 megawatt hour", 1678 1678 + vec![numtok!(1), Token::Unit(MegawattHour)], 1679 1679 + ); 1680 1680 + run_lex( 1681 1681 + "2 megawatt + 3 watt", 1682 1682 + vec![ 1683 1683 + numtok!(2), 1684 1684 + Token::Unit(Megawatt), 1685 1685 + Token::Operator(Plus), 1686 1686 + numtok!(3), 1687 1687 + Token::Unit(Watt), 1688 1688 + ], 1689 1689 + ); 1690 1690 + run_lex( 1691 1691 + "2 megawatt * 6", 1692 1692 + vec![ 1693 1693 + numtok!(2), 1694 1694 + Token::Unit(Megawatt), 1695 1695 + Token::Operator(Multiply), 1696 1696 + numtok!(6), 1697 1697 + ], 1698 1698 + ); 1699 1699 + run_lex( 1700 1700 + "2 megawatt times 6", 1701 1701 + vec![ 1702 1702 + numtok!(2), 1703 1703 + Token::Unit(Megawatt), 1704 1704 + Token::Operator(Multiply), 1705 1705 + numtok!(6), 1706 1706 + ], 1707 1707 + ); 1708 1708 + run_lex( 1709 1709 + "2 megawatt + 3 watts", 1710 1710 + vec![ 1711 1711 + numtok!(2), 1712 1712 + Token::Unit(Megawatt), 1713 1713 + Token::Operator(Plus), 1714 1714 + numtok!(3), 1715 1715 + Token::Unit(Watt), 1716 1716 + ], 1717 1717 + ); 1718 1718 + run_lex( 1719 1719 + "2 megawatts + 3 watt", 1720 1720 + vec![ 1721 1721 + numtok!(2), 1722 1722 + Token::Unit(Megawatt), 1723 1723 + Token::Operator(Plus), 1724 1724 + numtok!(3), 1725 1725 + Token::Unit(Watt), 1726 1726 + ], 1727 1727 + ); 1728 1728 + run_lex( 1729 1729 + "2 megawatts + 3 watts", 1730 1730 + vec![ 1731 1731 + numtok!(2), 1732 1732 + Token::Unit(Megawatt), 1733 1733 + Token::Operator(Plus), 1734 1734 + numtok!(3), 1735 1735 + Token::Unit(Watt), 1736 1736 + ], 1737 1737 + ); 1738 1738 + run_lex( 1739 1739 + "2 megawatt plus 3 watt", 1740 1740 + vec![ 1741 1741 + numtok!(2), 1742 1742 + Token::Unit(Megawatt), 1743 1743 + Token::Operator(Plus), 1744 1744 + numtok!(3), 1745 1745 + Token::Unit(Watt), 1746 1746 + ], 1747 1747 + ); 1748 1748 + run_lex( 1749 1749 + "2 megawatt plus 3 watts", 1750 1750 + vec![ 1751 1751 + numtok!(2), 1752 1752 + Token::Unit(Megawatt), 1753 1753 + Token::Operator(Plus), 1754 1754 + numtok!(3), 1755 1755 + Token::Unit(Watt), 1756 1756 + ], 1757 1757 + ); 1758 1758 + run_lex( 1759 1759 + "2 megawatts plus 3 watt", 1760 1760 + vec![ 1761 1761 + numtok!(2), 1762 1762 + Token::Unit(Megawatt), 1763 1763 + Token::Operator(Plus), 1764 1764 + numtok!(3), 1765 1765 + Token::Unit(Watt), 1766 1766 + ], 1767 1767 + ); 1768 1768 + run_lex( 1769 1769 + "2 megawatts plus 3 watts", 1770 1770 + vec![ 1771 1771 + numtok!(2), 1772 1772 + Token::Unit(Megawatt), 1773 1773 + Token::Operator(Plus), 1774 1774 + numtok!(3), 1775 1775 + Token::Unit(Watt), 1776 1776 + ], 1777 1777 + ); 1778 1778 + run_lex( 1779 1779 + "6.6 watts + 4 megawatts", 1780 1780 + vec![ 1781 1781 + numtok!(6.6), 1782 1782 + Token::Unit(Watt), 1783 1783 + Token::Operator(Plus), 1784 1784 + numtok!(4), 1785 1785 + Token::Unit(Megawatt), 1786 1786 + ], 1787 1787 + ); 1788 1788 + run_lex( 1789 1789 + "6.6 watts plus 4 megawatts", 1790 1790 + vec![ 1791 1791 + numtok!(6.6), 1792 1792 + Token::Unit(Watt), 1793 1793 + Token::Operator(Plus), 1794 1794 + numtok!(4), 1795 1795 + Token::Unit(Megawatt), 1796 1796 + ], 1797 1797 + ); 1246 1798 run_lex("234 gwh", vec![numtok!(234), Token::Unit(GigawattHour)]); 1247 1799 run_lex("1 gw", vec![numtok!(1), Token::Unit(Gigawatt)]); 1248 1800 run_lex("1 gigawatt", vec![numtok!(1), Token::Unit(Gigawatt)]); 1249 1801 run_lex("1 gigawatts", vec![numtok!(1), Token::Unit(Gigawatt)]); 1250 1250 - run_lex("1 gigawatt hour", vec![numtok!(1), Token::Unit(GigawattHour)]); 1251 1251 - run_lex("0 gigawatt + 1 gigawatts", vec![numtok!(0), Token::Unit(Gigawatt), Token::Operator(Plus), numtok!(1), Token::Unit(Gigawatt)]); 1252 1252 - run_lex("0 gigawatt * 1", vec![numtok!(0), Token::Unit(Gigawatt), Token::Operator(Multiply), numtok!(1)]); 1253 1253 - run_lex("2 gigawatts + 3 gigawatts", vec![numtok!(2), Token::Unit(Gigawatt), Token::Operator(Plus), numtok!(3), Token::Unit(Gigawatt)]); 1254 1254 - run_lex("2 gigawatts * 3", vec![numtok!(2), Token::Unit(Gigawatt), Token::Operator(Multiply), numtok!(3)]); 1255 1255 - run_lex("4 gigawatt plus 5 watt", vec![numtok!(4), Token::Unit(Gigawatt), Token::Operator(Plus), numtok!(5), Token::Unit(Watt)]); 1256 1256 - run_lex("4 gigawatt plus 5 megawatt", vec![numtok!(4), Token::Unit(Gigawatt), Token::Operator(Plus), numtok!(5), Token::Unit(Megawatt)]); 1257 1257 - run_lex("4 gigawatt plus 5 gigawatt", vec![numtok!(4), Token::Unit(Gigawatt), Token::Operator(Plus), numtok!(5), Token::Unit(Gigawatt)]); 1258 1258 - run_lex("4 gigawatt plus 5 watts", vec![numtok!(4), Token::Unit(Gigawatt), Token::Operator(Plus), numtok!(5), Token::Unit(Watt)]); 1259 1259 - run_lex("4 gigawatt plus 5 megawatts", vec![numtok!(4), Token::Unit(Gigawatt), Token::Operator(Plus), numtok!(5), Token::Unit(Megawatt)]); 1260 1260 - run_lex("4 gigawatt plus 5 gigawatts", vec![numtok!(4), Token::Unit(Gigawatt), Token::Operator(Plus), numtok!(5), Token::Unit(Gigawatt)]); 1261 1261 - run_lex("4 gigawatt times 5", vec![numtok!(4), Token::Unit(Gigawatt), Token::Operator(Multiply), numtok!(5)]); 1262 1262 - run_lex("6 gigawatts plus 7 watt", vec![numtok!(6), Token::Unit(Gigawatt), Token::Operator(Plus), numtok!(7), Token::Unit(Watt)]); 1263 1263 - run_lex("6 gigawatts plus 7 megawatt", vec![numtok!(6), Token::Unit(Gigawatt), Token::Operator(Plus), numtok!(7), Token::Unit(Megawatt)]); 1264 1264 - run_lex("6 gigawatts plus 7 gigawatt", vec![numtok!(6), Token::Unit(Gigawatt), Token::Operator(Plus), numtok!(7), Token::Unit(Gigawatt)]); 1265 1265 - run_lex("6 gigawatts plus 7 watts", vec![numtok!(6), Token::Unit(Gigawatt), Token::Operator(Plus), numtok!(7), Token::Unit(Watt)]); 1266 1266 - run_lex("6 gigawatts plus 7 megawatts", vec![numtok!(6), Token::Unit(Gigawatt), Token::Operator(Plus), numtok!(7), Token::Unit(Megawatt)]); 1267 1267 - run_lex("6 gigawatts plus 7 gigawatts", vec![numtok!(6), Token::Unit(Gigawatt), Token::Operator(Plus), numtok!(7), Token::Unit(Gigawatt)]); 1268 1268 - run_lex("6 gigawatts times 7", vec![numtok!(6), Token::Unit(Gigawatt), Token::Operator(Multiply), numtok!(7)]); 1269 1269 - run_lex("88 mw * 3", vec![numtok!(88), Token::Unit(Megawatt), Token::Operator(Multiply), numtok!(3)]); 1270 1270 - run_lex("88 mw times 3", vec![numtok!(88), Token::Unit(Megawatt), Token::Operator(Multiply), numtok!(3)]); 1802 1802 + run_lex( 1803 1803 + "1 gigawatt hour", 1804 1804 + vec![numtok!(1), Token::Unit(GigawattHour)], 1805 1805 + ); 1806 1806 + run_lex( 1807 1807 + "0 gigawatt + 1 gigawatts", 1808 1808 + vec![ 1809 1809 + numtok!(0), 1810 1810 + Token::Unit(Gigawatt), 1811 1811 + Token::Operator(Plus), 1812 1812 + numtok!(1), 1813 1813 + Token::Unit(Gigawatt), 1814 1814 + ], 1815 1815 + ); 1816 1816 + run_lex( 1817 1817 + "0 gigawatt * 1", 1818 1818 + vec![ 1819 1819 + numtok!(0), 1820 1820 + Token::Unit(Gigawatt), 1821 1821 + Token::Operator(Multiply), 1822 1822 + numtok!(1), 1823 1823 + ], 1824 1824 + ); 1825 1825 + run_lex( 1826 1826 + "2 gigawatts + 3 gigawatts", 1827 1827 + vec![ 1828 1828 + numtok!(2), 1829 1829 + Token::Unit(Gigawatt), 1830 1830 + Token::Operator(Plus), 1831 1831 + numtok!(3), 1832 1832 + Token::Unit(Gigawatt), 1833 1833 + ], 1834 1834 + ); 1835 1835 + run_lex( 1836 1836 + "2 gigawatts * 3", 1837 1837 + vec![ 1838 1838 + numtok!(2), 1839 1839 + Token::Unit(Gigawatt), 1840 1840 + Token::Operator(Multiply), 1841 1841 + numtok!(3), 1842 1842 + ], 1843 1843 + ); 1844 1844 + run_lex( 1845 1845 + "4 gigawatt plus 5 watt", 1846 1846 + vec![ 1847 1847 + numtok!(4), 1848 1848 + Token::Unit(Gigawatt), 1849 1849 + Token::Operator(Plus), 1850 1850 + numtok!(5), 1851 1851 + Token::Unit(Watt), 1852 1852 + ], 1853 1853 + ); 1854 1854 + run_lex( 1855 1855 + "4 gigawatt plus 5 megawatt", 1856 1856 + vec![ 1857 1857 + numtok!(4), 1858 1858 + Token::Unit(Gigawatt), 1859 1859 + Token::Operator(Plus), 1860 1860 + numtok!(5), 1861 1861 + Token::Unit(Megawatt), 1862 1862 + ], 1863 1863 + ); 1864 1864 + run_lex( 1865 1865 + "4 gigawatt plus 5 gigawatt", 1866 1866 + vec![ 1867 1867 + numtok!(4), 1868 1868 + Token::Unit(Gigawatt), 1869 1869 + Token::Operator(Plus), 1870 1870 + numtok!(5), 1871 1871 + Token::Unit(Gigawatt), 1872 1872 + ], 1873 1873 + ); 1874 1874 + run_lex( 1875 1875 + "4 gigawatt plus 5 watts", 1876 1876 + vec![ 1877 1877 + numtok!(4), 1878 1878 + Token::Unit(Gigawatt), 1879 1879 + Token::Operator(Plus), 1880 1880 + numtok!(5), 1881 1881 + Token::Unit(Watt), 1882 1882 + ], 1883 1883 + ); 1884 1884 + run_lex( 1885 1885 + "4 gigawatt plus 5 megawatts", 1886 1886 + vec![ 1887 1887 + numtok!(4), 1888 1888 + Token::Unit(Gigawatt), 1889 1889 + Token::Operator(Plus), 1890 1890 + numtok!(5), 1891 1891 + Token::Unit(Megawatt), 1892 1892 + ], 1893 1893 + ); 1894 1894 + run_lex( 1895 1895 + "4 gigawatt plus 5 gigawatts", 1896 1896 + vec![ 1897 1897 + numtok!(4), 1898 1898 + Token::Unit(Gigawatt), 1899 1899 + Token::Operator(Plus), 1900 1900 + numtok!(5), 1901 1901 + Token::Unit(Gigawatt), 1902 1902 + ], 1903 1903 + ); 1904 1904 + run_lex( 1905 1905 + "4 gigawatt times 5", 1906 1906 + vec![ 1907 1907 + numtok!(4), 1908 1908 + Token::Unit(Gigawatt), 1909 1909 + Token::Operator(Multiply), 1910 1910 + numtok!(5), 1911 1911 + ], 1912 1912 + ); 1913 1913 + run_lex( 1914 1914 + "6 gigawatts plus 7 watt", 1915 1915 + vec![ 1916 1916 + numtok!(6), 1917 1917 + Token::Unit(Gigawatt), 1918 1918 + Token::Operator(Plus), 1919 1919 + numtok!(7), 1920 1920 + Token::Unit(Watt), 1921 1921 + ], 1922 1922 + ); 1923 1923 + run_lex( 1924 1924 + "6 gigawatts plus 7 megawatt", 1925 1925 + vec![ 1926 1926 + numtok!(6), 1927 1927 + Token::Unit(Gigawatt), 1928 1928 + Token::Operator(Plus), 1929 1929 + numtok!(7), 1930 1930 + Token::Unit(Megawatt), 1931 1931 + ], 1932 1932 + ); 1933 1933 + run_lex( 1934 1934 + "6 gigawatts plus 7 gigawatt", 1935 1935 + vec![ 1936 1936 + numtok!(6), 1937 1937 + Token::Unit(Gigawatt), 1938 1938 + Token::Operator(Plus), 1939 1939 + numtok!(7), 1940 1940 + Token::Unit(Gigawatt), 1941 1941 + ], 1942 1942 + ); 1943 1943 + run_lex( 1944 1944 + "6 gigawatts plus 7 watts", 1945 1945 + vec![ 1946 1946 + numtok!(6), 1947 1947 + Token::Unit(Gigawatt), 1948 1948 + Token::Operator(Plus), 1949 1949 + numtok!(7), 1950 1950 + Token::Unit(Watt), 1951 1951 + ], 1952 1952 + ); 1953 1953 + run_lex( 1954 1954 + "6 gigawatts plus 7 megawatts", 1955 1955 + vec![ 1956 1956 + numtok!(6), 1957 1957 + Token::Unit(Gigawatt), 1958 1958 + Token::Operator(Plus), 1959 1959 + numtok!(7), 1960 1960 + Token::Unit(Megawatt), 1961 1961 + ], 1962 1962 + ); 1963 1963 + run_lex( 1964 1964 + "6 gigawatts plus 7 gigawatts", 1965 1965 + vec![ 1966 1966 + numtok!(6), 1967 1967 + Token::Unit(Gigawatt), 1968 1968 + Token::Operator(Plus), 1969 1969 + numtok!(7), 1970 1970 + Token::Unit(Gigawatt), 1971 1971 + ], 1972 1972 + ); 1973 1973 + run_lex( 1974 1974 + "6 gigawatts times 7", 1975 1975 + vec![ 1976 1976 + numtok!(6), 1977 1977 + Token::Unit(Gigawatt), 1978 1978 + Token::Operator(Multiply), 1979 1979 + numtok!(7), 1980 1980 + ], 1981 1981 + ); 1982 1982 + run_lex( 1983 1983 + "88 mw * 3", 1984 1984 + vec![ 1985 1985 + numtok!(88), 1986 1986 + Token::Unit(Megawatt), 1987 1987 + Token::Operator(Multiply), 1988 1988 + numtok!(3), 1989 1989 + ], 1990 1990 + ); 1991 1991 + run_lex( 1992 1992 + "88 mw times 3", 1993 1993 + vec![ 1994 1994 + numtok!(88), 1995 1995 + Token::Unit(Megawatt), 1996 1996 + Token::Operator(Multiply), 1997 1997 + numtok!(3), 1998 1998 + ], 1999 1999 + ); 1271 2000 run_lex("999 kb", vec![numtok!(999), Token::Unit(Kilobyte)]); 1272 1272 - run_lex("200 gb - 100 mb", vec![numtok!(200), Token::Unit(Gigabyte), Token::Operator(Minus), numtok!(100), Token::Unit(Megabyte)]); 2001 2001 + run_lex( 2002 2002 + "200 gb - 100 mb", 2003 2003 + vec![ 2004 2004 + numtok!(200), 2005 2005 + Token::Unit(Gigabyte), 2006 2006 + Token::Operator(Minus), 2007 2007 + numtok!(100), 2008 2008 + Token::Unit(Megabyte), 2009 2009 + ], 2010 2010 + ); 1273 2011 run_lex("999 kib", vec![numtok!(999), Token::Unit(Kibibyte)]); 1274 1274 - run_lex("200 gib - 100 mib", vec![numtok!(200), Token::Unit(Gibibyte), Token::Operator(Minus), numtok!(100), Token::Unit(Mebibyte)]); 2012 2012 + run_lex( 2013 2013 + "200 gib - 100 mib", 2014 2014 + vec![ 2015 2015 + numtok!(200), 2016 2016 + Token::Unit(Gibibyte), 2017 2017 + Token::Operator(Minus), 2018 2018 + numtok!(100), 2019 2019 + Token::Unit(Mebibyte), 2020 2020 + ], 2021 2021 + ); 1275 2022 run_lex("45 btu", vec![numtok!(45), Token::Unit(BritishThermalUnit)]); 1276 1276 - run_lex("45.5 british thermal unit", vec![numtok!(45.5), Token::Unit(BritishThermalUnit)]); 1277 1277 - run_lex("46 british thermal units", vec![numtok!(46), Token::Unit(BritishThermalUnit)]); 1278 1278 - run_lex("5432 newton metres", vec![numtok!(5432), Token::Unit(NewtonMeter)]); 1279 1279 - run_lex("2345 newton-meters", vec![numtok!(2345), Token::Unit(NewtonMeter)]); 2023 2023 + run_lex( 2024 2024 + "45.5 british thermal unit", 2025 2025 + vec![numtok!(45.5), Token::Unit(BritishThermalUnit)], 2026 2026 + ); 2027 2027 + run_lex( 2028 2028 + "46 british thermal units", 2029 2029 + vec![numtok!(46), Token::Unit(BritishThermalUnit)], 2030 2030 + ); 2031 2031 + run_lex( 2032 2032 + "5432 newton metres", 2033 2033 + vec![numtok!(5432), Token::Unit(NewtonMeter)], 2034 2034 + ); 2035 2035 + run_lex( 2036 2036 + "2345 newton-meters", 2037 2037 + vec![numtok!(2345), Token::Unit(NewtonMeter)], 2038 2038 + ); 1280 2039 run_lex("20 lbf", vec![numtok!(20), Token::LexerKeyword(PoundForce)]); 1281 2040 run_lex("60 hz", vec![numtok!(60), Token::Unit(Hertz)]); 1282 1282 - run_lex("1100 rpm", vec![numtok!(1100), Token::Unit(RevolutionsPerMinute)]); 1283 1283 - run_lex("1150 revolutions per minute", vec![numtok!(1150), Token::Unit(RevolutionsPerMinute)]); 1284 1284 - run_lex("1 revolution per min", vec![numtok!(1), Token::Unit(RevolutionsPerMinute)]); 1285 1285 - run_lex("4 revolution / mins", vec![numtok!(4), Token::Unit(RevolutionsPerMinute)]); 1286 1286 - run_lex("1250 r / min", vec![numtok!(1250), Token::Unit(RevolutionsPerMinute)]); 1287 1287 - run_lex("1300 rev / min", vec![numtok!(1300), Token::Unit(RevolutionsPerMinute)]); 1288 1288 - run_lex("1350 rev / minute", vec![numtok!(1350), Token::Unit(RevolutionsPerMinute)]); 1289 1289 - run_lex("1250 r per min", vec![numtok!(1250), Token::Unit(RevolutionsPerMinute)]); 1290 1290 - run_lex("1300 rev per min", vec![numtok!(1300), Token::Unit(RevolutionsPerMinute)]); 1291 1291 - run_lex("1350 rev per minute", vec![numtok!(1350), Token::Unit(RevolutionsPerMinute)]); 1292 1292 - run_lex("100 kph", vec![numtok!(100), Token::Unit(KilometersPerHour)]); 1293 1293 - run_lex("100 kmh", vec![numtok!(100), Token::Unit(KilometersPerHour)]); 1294 1294 - run_lex("100 kilometers per hour", vec![numtok!(100), Token::Unit(KilometersPerHour)]); 1295 1295 - run_lex("100 kilometre / hrs", vec![numtok!(100), Token::Unit(KilometersPerHour)]); 2041 2041 + run_lex( 2042 2042 + "1100 rpm", 2043 2043 + vec![numtok!(1100), Token::Unit(RevolutionsPerMinute)], 2044 2044 + ); 2045 2045 + run_lex( 2046 2046 + "1150 revolutions per minute", 2047 2047 + vec![numtok!(1150), Token::Unit(RevolutionsPerMinute)], 2048 2048 + ); 2049 2049 + run_lex( 2050 2050 + "1 revolution per min", 2051 2051 + vec![numtok!(1), Token::Unit(RevolutionsPerMinute)], 2052 2052 + ); 2053 2053 + run_lex( 2054 2054 + "4 revolution / mins", 2055 2055 + vec![numtok!(4), Token::Unit(RevolutionsPerMinute)], 2056 2056 + ); 2057 2057 + run_lex( 2058 2058 + "1250 r / min", 2059 2059 + vec![numtok!(1250), Token::Unit(RevolutionsPerMinute)], 2060 2060 + ); 2061 2061 + run_lex( 2062 2062 + "1300 rev / min", 2063 2063 + vec![numtok!(1300), Token::Unit(RevolutionsPerMinute)], 2064 2064 + ); 2065 2065 + run_lex( 2066 2066 + "1350 rev / minute", 2067 2067 + vec![numtok!(1350), Token::Unit(RevolutionsPerMinute)], 2068 2068 + ); 2069 2069 + run_lex( 2070 2070 + "1250 r per min", 2071 2071 + vec![numtok!(1250), Token::Unit(RevolutionsPerMinute)], 2072 2072 + ); 2073 2073 + run_lex( 2074 2074 + "1300 rev per min", 2075 2075 + vec![numtok!(1300), Token::Unit(RevolutionsPerMinute)], 2076 2076 + ); 2077 2077 + run_lex( 2078 2078 + "1350 rev per minute", 2079 2079 + vec![numtok!(1350), Token::Unit(RevolutionsPerMinute)], 2080 2080 + ); 2081 2081 + run_lex( 2082 2082 + "100 kph", 2083 2083 + vec![numtok!(100), Token::Unit(KilometersPerHour)], 2084 2084 + ); 2085 2085 + run_lex( 2086 2086 + "100 kmh", 2087 2087 + vec![numtok!(100), Token::Unit(KilometersPerHour)], 2088 2088 + ); 2089 2089 + run_lex( 2090 2090 + "100 kilometers per hour", 2091 2091 + vec![numtok!(100), Token::Unit(KilometersPerHour)], 2092 2092 + ); 2093 2093 + run_lex( 2094 2094 + "100 kilometre / hrs", 2095 2095 + vec![numtok!(100), Token::Unit(KilometersPerHour)], 2096 2096 + ); 1296 2097 run_lex("3.6 mps", vec![numtok!(3.6), Token::Unit(MetersPerSecond)]); 1297 1297 - run_lex("3.6 meters per second", vec![numtok!(3.6), Token::Unit(MetersPerSecond)]); 1298 1298 - run_lex("3.6 metre / secs", vec![numtok!(3.6), Token::Unit(MetersPerSecond)]); 2098 2098 + run_lex( 2099 2099 + "3.6 meters per second", 2100 2100 + vec![numtok!(3.6), Token::Unit(MetersPerSecond)], 2101 2101 + ); 2102 2102 + run_lex( 2103 2103 + "3.6 metre / secs", 2104 2104 + vec![numtok!(3.6), Token::Unit(MetersPerSecond)], 2105 2105 + ); 1299 2106 run_lex("60 mph", vec![numtok!(60), Token::Unit(MilesPerHour)]); 1300 1300 - run_lex("60 miles per hour", vec![numtok!(60), Token::Unit(MilesPerHour)]); 2107 2107 + run_lex( 2108 2108 + "60 miles per hour", 2109 2109 + vec![numtok!(60), Token::Unit(MilesPerHour)], 2110 2110 + ); 1301 2111 run_lex("60 mile / hr", vec![numtok!(60), Token::Unit(MilesPerHour)]); 1302 2112 run_lex("35 fps", vec![numtok!(35), Token::Unit(FeetPerSecond)]); 1303 2113 run_lex("35 ft / sec", vec![numtok!(35), Token::Unit(FeetPerSecond)]); 1304 1304 - run_lex("35 ft per seconds", vec![numtok!(35), Token::Unit(FeetPerSecond)]); 1305 1305 - run_lex("35 foot / secs", vec![numtok!(35), Token::Unit(FeetPerSecond)]); 1306 1306 - run_lex("35 foot per seconds", vec![numtok!(35), Token::Unit(FeetPerSecond)]); 1307 1307 - run_lex("35 feet / sec", vec![numtok!(35), Token::Unit(FeetPerSecond)]); 1308 1308 - run_lex("35 feet per second", vec![numtok!(35), Token::Unit(FeetPerSecond)]); 2114 2114 + run_lex( 2115 2115 + "35 ft per seconds", 2116 2116 + vec![numtok!(35), Token::Unit(FeetPerSecond)], 2117 2117 + ); 2118 2118 + run_lex( 2119 2119 + "35 foot / secs", 2120 2120 + vec![numtok!(35), Token::Unit(FeetPerSecond)], 2121 2121 + ); 2122 2122 + run_lex( 2123 2123 + "35 foot per seconds", 2124 2124 + vec![numtok!(35), Token::Unit(FeetPerSecond)], 2125 2125 + ); 2126 2126 + run_lex( 2127 2127 + "35 feet / sec", 2128 2128 + vec![numtok!(35), Token::Unit(FeetPerSecond)], 2129 2129 + ); 2130 2130 + run_lex( 2131 2131 + "35 feet per second", 2132 2132 + vec![numtok!(35), Token::Unit(FeetPerSecond)], 2133 2133 + ); 1309 2134 run_lex("30 pa", vec![numtok!(30), Token::Unit(Pascal)]); 1310 1310 - run_lex("23 celsius + 4 celsius", vec![numtok!(23), Token::Unit(Celsius), Token::Operator(Plus), numtok!(4), Token::Unit(Celsius)]); 1311 1311 - run_lex("54 f - 1.5 fahrenheit", vec![numtok!(54), Token::Unit(Fahrenheit), Token::Operator(Minus), numtok!(1.5), Token::Unit(Fahrenheit)]); 1312 1312 - run_lex("50 metric tonnes", vec![numtok!(50), Token::Unit(MetricTon)]); 1313 1313 - run_lex("77 metric hps", vec![numtok!(77), Token::Unit(MetricHorsepower)]); 2135 2135 + run_lex( 2136 2136 + "23 celsius + 4 celsius", 2137 2137 + vec![ 2138 2138 + numtok!(23), 2139 2139 + Token::Unit(Celsius), 2140 2140 + Token::Operator(Plus), 2141 2141 + numtok!(4), 2142 2142 + Token::Unit(Celsius), 2143 2143 + ], 2144 2144 + ); 2145 2145 + run_lex( 2146 2146 + "54 f - 1.5 fahrenheit", 2147 2147 + vec![ 2148 2148 + numtok!(54), 2149 2149 + Token::Unit(Fahrenheit), 2150 2150 + Token::Operator(Minus), 2151 2151 + numtok!(1.5), 2152 2152 + Token::Unit(Fahrenheit), 2153 2153 + ], 2154 2154 + ); 2155 2155 + run_lex( 2156 2156 + "50 metric tonnes", 2157 2157 + vec![numtok!(50), Token::Unit(MetricTon)], 2158 2158 + ); 2159 2159 + run_lex( 2160 2160 + "77 metric hps", 2161 2161 + vec![numtok!(77), Token::Unit(MetricHorsepower)], 2162 2162 + ); 1314 2163 1315 1315 - run_lex("100 + 99", vec![numtok!(100), Token::Operator(Plus), numtok!(99)]); 1316 1316 - run_lex("100 plus 99", vec![numtok!(100), Token::Operator(Plus), numtok!(99)]); 1317 1317 - run_lex("12 - 4", vec![numtok!(12), Token::Operator(Minus), numtok!(4)]); 1318 1318 - run_lex("12 minus 4", vec![numtok!(12), Token::Operator(Minus), numtok!(4)]); 1319 1319 - run_lex("50.5 * 2", vec![numtok!(50.5), Token::Operator(Multiply), numtok!(2)]); 1320 1320 - run_lex("50.5 times 2", vec![numtok!(50.5), Token::Operator(Multiply), numtok!(2)]); 1321 1321 - run_lex("50.5 multiplied by 2", vec![numtok!(50.5), Token::Operator(Multiply), numtok!(2)]); 1322 1322 - run_lex("6 / 3", vec![numtok!(6), Token::Operator(Divide), numtok!(3)]); 1323 1323 - run_lex("50 / 10", vec![numtok!(50), Token::Operator(Divide), numtok!(10)]); 1324 1324 - run_lex("52 ÷ 12", vec![numtok!(52), Token::Operator(Divide), numtok!(12)]); 1325 1325 - run_lex("6 divided by 3", vec![numtok!(6), Token::Operator(Divide), numtok!(3)]); 1326 1326 - run_lex("7 mod 5", vec![numtok!(7), Token::Operator(Modulo), numtok!(5)]); 2164 2164 + run_lex( 2165 2165 + "100 + 99", 2166 2166 + vec![numtok!(100), Token::Operator(Plus), numtok!(99)], 2167 2167 + ); 2168 2168 + run_lex( 2169 2169 + "100 plus 99", 2170 2170 + vec![numtok!(100), Token::Operator(Plus), numtok!(99)], 2171 2171 + ); 2172 2172 + run_lex( 2173 2173 + "12 - 4", 2174 2174 + vec![numtok!(12), Token::Operator(Minus), numtok!(4)], 2175 2175 + ); 2176 2176 + run_lex( 2177 2177 + "12 minus 4", 2178 2178 + vec![numtok!(12), Token::Operator(Minus), numtok!(4)], 2179 2179 + ); 2180 2180 + run_lex( 2181 2181 + "50.5 * 2", 2182 2182 + vec![numtok!(50.5), Token::Operator(Multiply), numtok!(2)], 2183 2183 + ); 2184 2184 + run_lex( 2185 2185 + "50.5 times 2", 2186 2186 + vec![numtok!(50.5), Token::Operator(Multiply), numtok!(2)], 2187 2187 + ); 2188 2188 + run_lex( 2189 2189 + "50.5 multiplied by 2", 2190 2190 + vec![numtok!(50.5), Token::Operator(Multiply), numtok!(2)], 2191 2191 + ); 2192 2192 + run_lex( 2193 2193 + "6 / 3", 2194 2194 + vec![numtok!(6), Token::Operator(Divide), numtok!(3)], 2195 2195 + ); 2196 2196 + run_lex( 2197 2197 + "50 / 10", 2198 2198 + vec![numtok!(50), Token::Operator(Divide), numtok!(10)], 2199 2199 + ); 2200 2200 + run_lex( 2201 2201 + "52 ÷ 12", 2202 2202 + vec![numtok!(52), Token::Operator(Divide), numtok!(12)], 2203 2203 + ); 2204 2204 + run_lex( 2205 2205 + "6 divided by 3", 2206 2206 + vec![numtok!(6), Token::Operator(Divide), numtok!(3)], 2207 2207 + ); 2208 2208 + run_lex( 2209 2209 + "7 mod 5", 2210 2210 + vec![numtok!(7), Token::Operator(Modulo), numtok!(5)], 2211 2211 + ); 1327 2212 1328 1328 - run_lex("(2 + 3) * 4", vec![Token::Operator(LeftParen), numtok!(2), Token::Operator(Plus), numtok!(3), Token::Operator(RightParen), Token::Operator(Multiply), numtok!(4)]); 1329 1329 - run_lex("52 weeks * (12 hrs + 12 hours)", vec![numtok!(52), Token::Unit(Week), Token::Operator(Multiply), Token::Operator(LeftParen), numtok!(12), Token::Unit(Hour), Token::Operator(Plus), numtok!(12), Token::Unit(Hour), Token::Operator(RightParen)]); 1330 1330 - run_lex("12 pound+", vec![numtok!(12), Token::Unit(Pound), Token::Operator(Plus)]); 2213 2213 + run_lex( 2214 2214 + "(2 + 3) * 4", 2215 2215 + vec![ 2216 2216 + Token::Operator(LeftParen), 2217 2217 + numtok!(2), 2218 2218 + Token::Operator(Plus), 2219 2219 + numtok!(3), 2220 2220 + Token::Operator(RightParen), 2221 2221 + Token::Operator(Multiply), 2222 2222 + numtok!(4), 2223 2223 + ], 2224 2224 + ); 2225 2225 + run_lex( 2226 2226 + "52 weeks * (12 hrs + 12 hours)", 2227 2227 + vec![ 2228 2228 + numtok!(52), 2229 2229 + Token::Unit(Week), 2230 2230 + Token::Operator(Multiply), 2231 2231 + Token::Operator(LeftParen), 2232 2232 + numtok!(12), 2233 2233 + Token::Unit(Hour), 2234 2234 + Token::Operator(Plus), 2235 2235 + numtok!(12), 2236 2236 + Token::Unit(Hour), 2237 2237 + Token::Operator(RightParen), 2238 2238 + ], 2239 2239 + ); 2240 2240 + run_lex( 2241 2241 + "12 pound+", 2242 2242 + vec![numtok!(12), Token::Unit(Pound), Token::Operator(Plus)], 2243 2243 + ); 1331 2244 1332 1332 - run_lex("5 π m", vec![numtok!(5), Token::Constant(Pi), Token::Unit(Meter)]); 1333 1333 - run_lex("5 Ω + 2 mΩ", vec![numtok!(5), Token::Unit(Ohm), Token::Operator(Plus), numtok!(2), Token::Unit(Milliohm)]); 2245 2245 + run_lex( 2246 2246 + "5 π m", 2247 2247 + vec![numtok!(5), Token::Constant(Pi), Token::Unit(Meter)], 2248 2248 + ); 2249 2249 + run_lex( 2250 2250 + "5 Ω + 2 mΩ", 2251 2251 + vec![ 2252 2252 + numtok!(5), 2253 2253 + Token::Unit(Ohm), 2254 2254 + Token::Operator(Plus), 2255 2255 + numtok!(2), 2256 2256 + Token::Unit(Milliohm), 2257 2257 + ], 2258 2258 + ); 1334 2259 } 1335 2260 }

+128 -32

src/lib.rs

Reviewed

··· 22 22 //! } 23 23 //! ``` 24 24 25 25 - use crate::units::Unit; 26 26 - use fastnum::{dec128 as d, D128}; 27 27 - use std::fmt::{self, Display}; 25 25 + use crate::units::{Unit, UnitType, primitive_unit, sort_units}; 26 26 + use fastnum::{D128, dec128 as d}; 27 27 + use std::fmt::{self, Debug, Display}; 28 28 use web_time::Instant; 29 29 30 30 /// Turns an [`AstNode`](parser::AstNode) into a [`Number`] 31 31 pub mod evaluator; 32 32 /// Turns a string into [`Token`]s 33 33 - #[rustfmt::skip] 34 33 pub mod lexer; 35 35 - #[rustfmt::skip] 36 34 mod lookup; 37 35 /// Turns [`Token`]s into an [`AstNode`](parser::AstNode) 38 36 pub mod parser; 39 37 /// Units, and functions you can use with them 40 40 - #[rustfmt::skip] 41 38 pub mod units; 42 39 43 43 - #[derive(Clone, Debug, PartialEq)] 40 40 + #[derive(Clone)] 44 41 /// A number with a `Unit`. 45 42 /// 46 43 /// Example: ··· 49 46 /// use cpc::units::Unit; 50 47 /// use fastnum::dec128; 51 48 /// 52 52 - /// let x = Number { 53 53 - /// value: dec128!(100), 54 54 - /// unit: Unit::Meter, 55 55 - /// }; 49 49 + /// let x = Number::with_basic_unit(dec128!(100), Unit::Meter); 56 50 /// ``` 57 51 pub struct Number { 58 58 - /// The number part of a [`Number`] struct 52 52 + /// The value of the number 59 53 pub value: D128, 60 60 - /// The unit of a [`Number`] struct. This can be [`NoType`](units::UnitType::NoType) 61 61 - pub unit: Unit, 54 54 + /// The unit and exponent 55 55 + pub unit: Vec<(Unit, isize)>, 62 56 } 63 63 - 64 57 impl Number { 65 65 - pub const fn new(value: D128, unit: Unit) -> Number { 58 58 + pub fn new_unitless(value: D128) -> Number { 59 59 + Number { 60 60 + value, 61 61 + unit: vec![], 62 62 + } 63 63 + } 64 64 + pub fn with_basic_unit(value: D128, unit: Unit) -> Number { 65 65 + Number { 66 66 + value, 67 67 + unit: vec![(unit, 1)], 68 68 + } 69 69 + } 70 70 + pub fn with_unit(value: D128, unit: Vec<(Unit, isize)>) -> Number { 66 71 Number { value, unit } 67 72 } 73 73 + pub fn has_unit(&self) -> bool { 74 74 + !self.unit.is_empty() 75 75 + } 76 76 + pub fn is_unitless(&self) -> bool { 77 77 + self.unit.is_empty() 78 78 + } 68 79 pub fn get_simplified_value(&self) -> D128 { 69 80 self.value.reduce() 70 81 } 82 82 + pub fn primitive_unit(&self) -> Vec<(Unit, isize)> { 83 83 + primitive_unit(&self.unit) 84 84 + } 85 85 + pub fn contains_primitive(&self, unit: UnitType) -> bool { 86 86 + self.unit.iter().any(|(u, _)| u.category() == unit) 87 87 + } 88 88 + fn get_unit_string(&self, plural: bool) -> String { 89 89 + let mut s = String::new(); 90 90 + let mut units = self.unit.clone(); 91 91 + sort_units(&mut units); 92 92 + let mut positives = units.iter().filter(|u| u.1 > 0).peekable(); 93 93 + while let Some(unit) = positives.next() { 94 94 + if unit.1 <= 0 { 95 95 + continue; 96 96 + } 97 97 + if s.len() != 0 { 98 98 + s.push_str(" * "); 99 99 + } 100 100 + // only the last multiplication should be plural: `100 minute meters / volt hour` 101 101 + let is_last = positives.peek().is_none(); 102 102 + match is_last && plural { 103 103 + false => s.push_str(unit.0.singular()), 104 104 + true => s.push_str(unit.0.plural()), 105 105 + }; 106 106 + if unit.1.abs() >= 2 { 107 107 + s.push_str("^"); 108 108 + s.push_str(&unit.1.to_string()); 109 109 + } 110 110 + } 111 111 + for unit in units { 112 112 + if unit.1 >= 0 { 113 113 + continue; 114 114 + } 115 115 + s.push_str(" / "); 116 116 + s.push_str(unit.0.singular()); 117 117 + if unit.1.abs() >= 2 { 118 118 + s.push_str("^"); 119 119 + s.push_str(&unit.1.to_string()); 120 120 + } 121 121 + } 122 122 + s 123 123 + } 124 124 + pub fn singular(&self) -> String { 125 125 + self.get_unit_string(false) 126 126 + } 127 127 + pub fn plural(&self) -> String { 128 128 + self.get_unit_string(true) 129 129 + } 71 130 } 72 131 impl Display for Number { 73 132 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 74 133 let value = self.get_simplified_value(); 75 134 let word = match self.value == d!(1) { 76 76 - true => self.unit.singular(), 77 77 - false => self.unit.plural(), 135 135 + true => self.singular(), 136 136 + false => self.plural(), 78 137 }; 79 79 - let output = match word { 138 138 + let output = match word.as_str() { 80 139 "" => format!("{value}"), 81 140 _ => format!("{value} {word}"), 82 141 }; 83 142 write!(f, "{output}") 143 143 + } 144 144 + } 145 145 + impl Debug for Number { 146 146 + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 147 147 + let unit_strings: Vec<_> = self 148 148 + .unit 149 149 + .iter() 150 150 + .map(|u| format!("{:?}^{}", u.0, u.1)) 151 151 + .collect(); 152 152 + write!( 153 153 + f, 154 154 + "Number({} {})", 155 155 + self.get_simplified_value(), 156 156 + unit_strings.join(" ") 157 157 + ) 158 158 + } 159 159 + } 160 160 + impl PartialEq for Number { 161 161 + fn eq(&self, other: &Self) -> bool { 162 162 + self.value == other.value && self.primitive_unit() == other.primitive_unit() 84 163 } 85 164 } 86 165 ··· 187 266 Revolution, 188 267 } 189 268 190 190 - #[derive(Clone, Debug, PartialEq)] 269 269 + #[derive(Clone, PartialEq)] 191 270 /// A token like a [`Number`](Token::Number), [`Operator`](Token::Operator), [`Unit`](Token::Unit) etc. 192 271 /// 193 272 /// Strings can be divided up into these tokens by the [`lexer`], and then put into the [`parser`]. ··· 209 288 Negative, 210 289 Unit(units::Unit), 211 290 } 291 291 + impl fmt::Debug for Token { 292 292 + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 293 293 + match self { 294 294 + Token::Operator(op) => write!(f, "Operator({:?})", op), 295 295 + Token::UnaryOperator(op) => write!(f, "UnaryOperator({:?})", op), 296 296 + Token::Number(num) => write!(f, "Number({num})"), 297 297 + Token::FunctionIdentifier(id) => write!(f, "FunctionIdentifier({:?})", id), 298 298 + Token::Constant(c) => write!(f, "Constant({:?})", c), 299 299 + Token::Paren => write!(f, "Paren"), 300 300 + Token::Per => write!(f, "Per"), 301 301 + Token::LexerKeyword(op) => write!(f, "LexerKeyword({:?})", op), 302 302 + Token::TextOperator(op) => write!(f, "TextOperator({:?})", op), 303 303 + Token::NamedNumber(num) => write!(f, "NamedNumber({:?})", num), 304 304 + Token::Negative => write!(f, "Negative"), 305 305 + Token::Unit(u) => write!(f, "Unit({:?})", u), 306 306 + } 307 307 + } 308 308 + } 212 309 213 310 #[macro_export] 214 311 macro_rules! numtok { ··· 234 331 /// } 235 332 /// } 236 333 /// ``` 237 237 - pub fn eval( 238 238 - input: &str, 239 239 - allow_trailing_operators: bool, 240 240 - verbose: bool, 241 241 - ) -> Result<Number, String> { 334 334 + pub fn eval(input: &str, allow_trailing_operators: bool, verbose: bool) -> Result<Number, String> { 242 335 let lex_start = Instant::now(); 243 336 244 337 match lexer::lex(input, allow_trailing_operators) { ··· 315 408 316 409 #[test] 317 410 fn test_evaluations() { 318 318 - assert_eq!(default_eval("-2(-3)"), Number::new(d!(6), Unit::NoUnit)); 319 319 - assert_eq!(default_eval("-2(3)"), Number::new(d!(-6), Unit::NoUnit)); 320 320 - assert_eq!(default_eval("(3)-2"), Number::new(d!(1), Unit::NoUnit)); 321 321 - assert_eq!(default_eval("-1km to m"), Number::new(d!(-1000), Unit::Meter)); 322 322 - assert_eq!(default_eval("2*-3*0.5"), Number::new(d!(-3), Unit::NoUnit)); 323 323 - assert_eq!(default_eval("-3^2"), Number::new(d!(-9), Unit::NoUnit)); 324 324 - assert_eq!(default_eval("-1+2"), Number::new(d!(1), Unit::NoUnit)); 411 411 + assert_eq!(default_eval("-2(-3)"), Number::new_unitless(d!(6))); 412 412 + assert_eq!(default_eval("-2(3)"), Number::new_unitless(d!(-6))); 413 413 + assert_eq!(default_eval("(3)-2"), Number::new_unitless(d!(1))); 414 414 + assert_eq!( 415 415 + default_eval("-1km to m"), 416 416 + Number::with_basic_unit(d!(-1000), Unit::Meter) 417 417 + ); 418 418 + assert_eq!(default_eval("2*-3*0.5"), Number::new_unitless(d!(-3))); 419 419 + assert_eq!(default_eval("-3^2"), Number::new_unitless(d!(-9))); 420 420 + assert_eq!(default_eval("-1+2"), Number::new_unitless(d!(1))); 325 421 } 326 422 }

+3 -2

src/lookup.rs

Reviewed

··· 1 1 + use crate::NamedNumber; 1 2 use crate::NamedNumber::*; 2 2 - use crate::NamedNumber; 3 3 - use fastnum::{dec128 as d, D128}; 3 3 + use fastnum::{D128, dec128 as d}; 4 4 5 5 /// Returns the corresponding [`D128`] of a [`NamedNumber`] 6 6 + #[rustfmt::skip] 6 7 pub fn lookup_named_number(named_number: &NamedNumber) -> D128 { 7 8 match named_number { 8 9 Hundred => d!(100),

+657 -531

src/units.rs

Reviewed

··· 1 1 - use fastnum::{dec128 as d, D128}; 2 1 use crate::Number; 2 2 + use fastnum::{D128, dec128 as d}; 3 3 + use std::cmp::Reverse; 3 4 4 5 #[derive(Clone, Copy, PartialEq, Debug)] 5 6 /// An enum of all possible unit types, like [`Length`], [`DigitalStorage`] etc. 6 6 - /// There is also a [`NoType`] unit type for normal numbers. 7 7 pub enum UnitType { 8 8 - /// A normal number, for example `5` 9 9 - NoType, 10 8 /// A unit of time, for example [`Hour`] 11 9 Time, 12 10 /// A unit of length, for example [`Mile`] ··· 43 41 Speed, 44 42 /// A unit of temperature, for example [`Kelvin`] 45 43 Temperature, 44 44 + } 45 45 + impl UnitType { 46 46 + fn primitive(&self) -> Vec<(Unit, isize)> { 47 47 + let units = match self { 48 48 + Time => vec![(Second, 1)], 49 49 + Length => vec![(Meter, 1)], 50 50 + Area => vec![(Meter, 2)], 51 51 + Volume => vec![(Meter, 3)], 52 52 + Mass => vec![(Kilogram, 1)], 53 53 + DigitalStorage => vec![(Bit, 1)], 54 54 + DataTransferRate => vec![(Bit, 1), (Second, -1)], 55 55 + FlopCount => vec![(Flop, 1)], 56 56 + FlopRate => vec![(Flop, 1), (Second, -1)], 57 57 + Energy => vec![(Meter, 2), (Kilogram, 1), (Second, -2)], 58 58 + Power => vec![(Meter, 2), (Kilogram, 1), (Second, -3)], 59 59 + ElectricCurrent => vec![(Ampere, 1)], 60 60 + Resistance => vec![(Meter, 2), (Kilogram, 1), (Second, -3), (Ampere, -2)], 61 61 + Voltage => vec![(Meter, 2), (Kilogram, 1), (Second, -3), (Ampere, -1)], 62 62 + Pressure => vec![(Kilogram, 1), (Second, -2), (Meter, -1)], 63 63 + Frequency => vec![(Second, -1)], 64 64 + Speed => vec![(Meter, 1), (Second, -1)], 65 65 + Temperature => vec![(Kelvin, 1)], 66 66 + }; 67 67 + #[cfg(debug_assertions)] 68 68 + { 69 69 + let u0 = units.clone(); 70 70 + let mut u1 = units.clone(); 71 71 + sort_units(&mut u1); 72 72 + assert!(u0 == u1) 73 73 + } 74 74 + units 75 75 + } 46 76 } 47 77 use UnitType::*; 48 78 79 79 + /// Sort for display and comparison purposes. 80 80 + pub fn sort_units(primitives: &mut Vec<(Unit, isize)>) { 81 81 + primitives.sort_by_key(|u| { 82 82 + ( 83 83 + u.1 < 0, // multiplications first 84 84 + Reverse(u.1.abs()), // largest first, like "sqm seconds" 85 85 + u.0, // then sort by unit, to have a fully deterministic order 86 86 + ) 87 87 + }); 88 88 + } 89 89 + 90 90 + pub fn primitive_unit(unit: &Vec<(Unit, isize)>) -> Vec<(Unit, isize)> { 91 91 + let mut primitives: Vec<(Unit, isize)> = Vec::new(); 92 92 + for (unit, exponent) in unit { 93 93 + for (primitive, primitive_exponent) in unit.category().primitive() { 94 94 + let existing = primitives.iter_mut().find(|(u, _)| u == &primitive); 95 95 + match existing { 96 96 + Some(existing) => existing.1 += primitive_exponent * exponent, 97 97 + None => primitives.push((primitive, primitive_exponent * exponent)), 98 98 + } 99 99 + } 100 100 + } 101 101 + primitives.retain(|(_, exponent)| exponent != &0); 102 102 + sort_units(&mut primitives); 103 103 + primitives 104 104 + } 105 105 + 49 106 // Macro for creating units. Not possible to extend/change the default units 50 107 // with this because the default units are imported into the lexer, parser 51 108 // and evaluator 52 109 macro_rules! create_units { 53 110 ( $( $variant:ident : $properties:expr ),*, ) => { 54 54 - #[derive(Clone, Copy, PartialEq, Debug)] 111 111 + #[derive(Clone, Copy, PartialEq, Debug, Eq, PartialOrd, Ord)] 55 112 /// A Unit enum. Note that it can also be [`NoUnit`]. 56 113 pub enum Unit { 57 114 $($variant),* ··· 92 149 } 93 150 94 151 create_units!( 95 95 - NoUnit: (NoType, d!(1), "", ""), 152 152 + Nanosecond: (Time, d!(0.000000001), "nanosecond", "nanoseconds"), 153 153 + Microsecond: (Time, d!(0.000001), "microsecond", "microseconds"), 154 154 + Millisecond: (Time, d!(0.001), "millisecond", "milliseconds"), 155 155 + Second: (Time, d!(1), "second", "seconds"), 156 156 + Minute: (Time, d!(60), "minute", "minutes"), 157 157 + Hour: (Time, d!(3600), "hour", "hours"), 158 158 + Day: (Time, d!(86400), "day", "days"), 159 159 + Week: (Time, d!(604800), "week", "weeks"), 160 160 + Month: (Time, d!(2629746), "month", "months"), 161 161 + Quarter: (Time, d!(7889238), "quarter", "quarters"), 162 162 + Year: (Time, d!(31556952), "year", "years"), 163 163 + Decade: (Time, d!(315569520), "decade", "decades"), 164 164 + Century: (Time, d!(3155695200), "century", "centuries"), 165 165 + Millennium: (Time, d!(31556952000), "millennium", "millennia"), 96 166 97 97 - Nanosecond: (Time, d!(1), "nanosecond", "nanoseconds"), 98 98 - Microsecond: (Time, d!(1000), "microsecond", "microseconds"), 99 99 - Millisecond: (Time, d!(1000000), "millisecond", "milliseconds"), 100 100 - Second: (Time, d!(1000000000), "second", "seconds"), 101 101 - Minute: (Time, d!(60000000000), "minute", "minutes"), 102 102 - Hour: (Time, d!(3600000000000), "hour", "hours"), 103 103 - Day: (Time, d!(86400000000000), "day", "days"), 104 104 - Week: (Time, d!(604800000000000), "week", "weeks"), 105 105 - Month: (Time, d!(2629746000000000), "month", "months"), 106 106 - Quarter: (Time, d!(7889238000000000), "quarter", "quarters"), 107 107 - Year: (Time, d!(31556952000000000), "year", "years"), 108 108 - Decade: (Time, d!(315569520000000000), "decade", "decades"), 109 109 - Century: (Time, d!(3155695200000000000), "century", "centuries"), 110 110 - Millennium: (Time, d!(31556952000000000000), "millennium", "millennia"), 111 111 - 112 112 - Millimeter: (Length, d!(1), "millimeter", "millimeters"), 113 113 - Centimeter: (Length, d!(10), "centimeter", "centimeters"), 114 114 - Decimeter: (Length, d!(100), "decimeter", "decimeters"), 115 115 - Meter: (Length, d!(1000), "meter", "meters"), 116 116 - Kilometer: (Length, d!(1000000), "kilometer", "kilometers"), 117 117 - Inch: (Length, d!(25.4), "inch", "inches"), 118 118 - Foot: (Length, d!(304.8), "foot", "feet"), 119 119 - Yard: (Length, d!(914.4), "yard", "yards"), 120 120 - Mile: (Length, d!(1609344), "mile", "miles"), 167 167 + Millimeter: (Length, d!(0.001), "millimeter", "millimeters"), 168 168 + Centimeter: (Length, d!(0.01), "centimeter", "centimeters"), 169 169 + Decimeter: (Length, d!(0.1), "decimeter", "decimeters"), 170 170 + Meter: (Length, d!(1), "meter", "meters"), 171 171 + Kilometer: (Length, d!(1000), "kilometer", "kilometers"), 172 172 + Inch: (Length, d!(0.0254), "inch", "inches"), 173 173 + Foot: (Length, d!(0.3048), "foot", "feet"), 174 174 + Yard: (Length, d!(0.9144), "yard", "yards"), 175 175 + Mile: (Length, d!(1609.344), "mile", "miles"), 121 176 // 1-dimensional only: 122 122 - Marathon: (Length, d!(42195000), "marathon", "marathons"), 123 123 - NauticalMile: (Length, d!(1852000), "nautical mile", "nautical miles"), 124 124 - LightYear: (Length, d!(9460730472580800000), "light year", "light years"), 125 125 - LightSecond: (Length, d!(299792458000), "light second", "light seconds"), 177 177 + Marathon: (Length, d!(42195), "marathon", "marathons"), 178 178 + NauticalMile: (Length, d!(1852), "nautical mile", "nautical miles"), 179 179 + LightYear: (Length, d!(9460730472580800), "light year", "light years"), 180 180 + LightSecond: (Length, d!(299792458), "light second", "light seconds"), 126 181 127 127 - SquareMillimeter: (Area, d!(1), "square millimeter", "square millimeters"), 128 128 - SquareCentimeter: (Area, d!(100), "square centimeter", "square centimeters"), 129 129 - SquareDecimeter: (Area, d!(10000), "square decimeter", "square decimeters"), 130 130 - SquareMeter: (Area, d!(1000000), "square meter", "square meters"), 131 131 - SquareKilometer: (Area, d!(1000000000000), "square kilometer", "square kilometers"), 132 132 - SquareInch: (Area, d!(645.16), "square inch", "square inches"), 133 133 - SquareFoot: (Area, d!(92903.04), "square foot", "square feet"), 134 134 - SquareYard: (Area, d!(836127.36), "square yard", "square yards"), 135 135 - SquareMile: (Area, d!(2589988110336.00), "square mile", "square miles"), 182 182 + SquareMillimeter: (Area, d!(0.000001), "square millimeter", "square millimeters"), 183 183 + SquareCentimeter: (Area, d!(0.0001), "square centimeter", "square centimeters"), 184 184 + SquareDecimeter: (Area, d!(0.01), "square decimeter", "square decimeters"), 185 185 + SquareMeter: (Area, d!(1), "square meter", "square meters"), 186 186 + SquareKilometer: (Area, d!(1000000), "square kilometer", "square kilometers"), 187 187 + SquareInch: (Area, d!(0.00064516), "square inch", "square inches"), 188 188 + SquareFoot: (Area, d!(0.09290304), "square foot", "square feet"), 189 189 + SquareYard: (Area, d!(0.83612736), "square yard", "square yards"), 190 190 + SquareMile: (Area, d!(2589988.110336), "square mile", "square miles"), 136 191 // 2-dimensional only 137 137 - Are: (Area, d!(100000000), "are", "ares"), 138 138 - Decare: (Area, d!(1000000000), "decare", "decares"), 139 139 - Hectare: (Area, d!(10000000000), "hectare", "hectares"), 140 140 - Acre: (Area, d!(4046856422.40), "acre", "acres"), 192 192 + Are: (Area, d!(100), "are", "ares"), 193 193 + Decare: (Area, d!(1000), "decare", "decares"), 194 194 + Hectare: (Area, d!(10000), "hectare", "hectares"), 195 195 + Acre: (Area, d!(4046.8564224), "acre", "acres"), 141 196 142 142 - CubicMillimeter: (Volume, d!(1), "cubic millimeter", "cubic millimeters"), 143 143 - CubicCentimeter: (Volume, d!(1000), "cubic centimeter", "cubic centimeters"), 144 144 - CubicDecimeter: (Volume, d!(1000000), "cubic decimeter", "cubic decimeters"), 145 145 - CubicMeter: (Volume, d!(1000000000), "cubic meter", "cubic meters"), 146 146 - CubicKilometer: (Volume, d!(1000000000000000000), "cubic kilometer", "cubic kilometers"), 147 147 - CubicInch: (Volume, d!(16387.064), "cubic inch", "cubic inches"), 148 148 - CubicFoot: (Volume, d!(28316846.592), "cubic foot", "cubic feet"), 149 149 - CubicYard: (Volume, d!(764554857.984), "cubic yard", "cubic yards"), 150 150 - CubicMile: (Volume, d!(4168181825440579584), "cubic mile", "cubic miles"), 197 197 + CubicMillimeter: (Volume, d!(0.000000001), "cubic millimeter", "cubic millimeters"), 198 198 + CubicCentimeter: (Volume, d!(0.000001), "cubic centimeter", "cubic centimeters"), 199 199 + CubicDecimeter: (Volume, d!(0.001), "cubic decimeter", "cubic decimeters"), 200 200 + CubicMeter: (Volume, d!(1), "cubic meter", "cubic meters"), 201 201 + CubicKilometer: (Volume, d!(1000000000), "cubic kilometer", "cubic kilometers"), 202 202 + CubicInch: (Volume, d!(0.000016387064), "cubic inch", "cubic inches"), 203 203 + CubicFoot: (Volume, d!(0.028316846592), "cubic foot", "cubic feet"), 204 204 + CubicYard: (Volume, d!(0.764554857984), "cubic yard", "cubic yards"), 205 205 + CubicMile: (Volume, d!(4168181825.440579584), "cubic mile", "cubic miles"), 151 206 // 3-dimensional only 152 152 - Milliliter: (Volume, d!(1000), "milliliter", "milliliters"), 153 153 - Centiliter: (Volume, d!(10000), "centiliter", "centiliters"), 154 154 - Deciliter: (Volume, d!(100000), "deciliter", "deciliters"), 155 155 - Liter: (Volume, d!(1000000), "liter", "liters"), 156 156 - Teaspoon: (Volume, d!(4928.92159375), "teaspoon", "teaspoons"), 157 157 - Tablespoon: (Volume, d!(14786.76478125), "tablespoon", "tablespoons"), 158 158 - FluidOunce: (Volume, d!(29573.5295625), "fluid ounce", "fluid ounces"), 159 159 - Cup: (Volume, d!(236588.2365), "cup", "cups"), 160 160 - Pint: (Volume, d!(473176.473), "pint", "pints"), 161 161 - Quart: (Volume, d!(946352.946), "quart", "quarts"), 162 162 - Gallon: (Volume, d!(3785411.784), "gallon", "gallons"), 163 163 - OilBarrel: (Volume, d!(158987294.928), "oil barrel", "oil barrels"), 207 207 + Milliliter: (Volume, d!(0.000001), "milliliter", "milliliters"), 208 208 + Centiliter: (Volume, d!(0.00001), "centiliter", "centiliters"), 209 209 + Deciliter: (Volume, d!(0.0001), "deciliter", "deciliters"), 210 210 + Liter: (Volume, d!(0.001), "liter", "liters"), 211 211 + Teaspoon: (Volume, d!(0.00000492892159375), "teaspoon", "teaspoons"), 212 212 + Tablespoon: (Volume, d!(0.00001478676478125), "tablespoon", "tablespoons"), 213 213 + FluidOunce: (Volume, d!(0.0000295735295625), "fluid ounce", "fluid ounces"), 214 214 + Cup: (Volume, d!(0.0002365882365), "cup", "cups"), 215 215 + Pint: (Volume, d!(0.000473176473), "pint", "pints"), 216 216 + Quart: (Volume, d!(0.000946352946), "quart", "quarts"), 217 217 + Gallon: (Volume, d!(0.003785411784), "gallon", "gallons"), 218 218 + OilBarrel: (Volume, d!(0.158987294928), "oil barrel", "oil barrels"), 164 219 165 165 - Milligram: (Mass, d!(0.001), "milligram", "milligrams"), 166 166 - Gram: (Mass, d!(1), "gram", "grams"), 167 167 - Hectogram: (Mass, d!(100), "hectogram", "hectograms"), 168 168 - Kilogram: (Mass, d!(1000), "kilogram", "kilograms"), 169 169 - MetricTon: (Mass, d!(1000000), "metric ton", "metric tons"), 170 170 - Ounce: (Mass, d!(28.349523125), "ounce", "ounces"), 171 171 - Pound: (Mass, d!(453.59237), "pound", "pounds"), 172 172 - Stone: (Mass, d!(6350.29318), "stone", "stones"), 173 173 - ShortTon: (Mass, d!(907184.74), "short ton", "short tons"), 174 174 - LongTon: (Mass, d!(1016046.9088), "long ton", "long tons"), 220 220 + Milligram: (Mass, d!(0.000001), "milligram", "milligrams"), 221 221 + Gram: (Mass, d!(0.001), "gram", "grams"), 222 222 + Hectogram: (Mass, d!(0.1), "hectogram", "hectograms"), 223 223 + Kilogram: (Mass, d!(1), "kilogram", "kilograms"), 224 224 + MetricTon: (Mass, d!(1000), "metric ton", "metric tons"), 225 225 + Ounce: (Mass, d!(0.028349523125), "ounce", "ounces"), 226 226 + Pound: (Mass, d!(0.45359237), "pound", "pounds"), 227 227 + Stone: (Mass, d!(6.35029318), "stone", "stones"), 228 228 + ShortTon: (Mass, d!(907.18474), "short ton", "short tons"), 229 229 + LongTon: (Mass, d!(1016.0469088), "long ton", "long tons"), 175 230 176 231 Bit: (DigitalStorage, d!(1), "bit", "bits"), 177 232 Kilobit: (DigitalStorage, d!(1000), "kilobit", "kilobits"), ··· 294 349 // inexact: 295 350 BritishThermalUnitsPerMinute: (Power, d!(17.584264210333), "british thermal unit per minute", "british thermal units per minute"), 296 351 // inexact: 297 297 - BritishThermalUnitsPerHour: (Power, d!(0.29307107017222), "british thermal unit per hour", "british thermal units per hour"), // exact according to wikipedia: 352 352 + BritishThermalUnitsPerHour: (Power, d!(0.29307107017222), "british thermal unit per hour", "british thermal units per hour"), 353 353 + // exact according to wikipedia: 298 354 Horsepower: (Power, d!(745.69987158227022), "horsepower", "horsepower"), 299 355 MetricHorsepower: (Power, d!(735.49875), "metric horsepower", "metric horsepower"), 300 356 ··· 330 386 Petahertz: (Frequency, d!(1000000000000000), "petahertz", "petahertz"), 331 387 RevolutionsPerMinute: (Frequency, d!(60), "revolution per minute", "revolutions per minute"), 332 388 333 333 - KilometersPerHour: (Speed, d!(1), "kilometer per hour", "kilometers per hour"), 334 334 - MetersPerSecond: (Speed, d!(3.6), "meter per second", "meters per second"), 335 335 - MilesPerHour: (Speed, d!(1.609344), "mile per hour", "miles per hour"), 336 336 - FeetPerSecond: (Speed, d!(1.09728), "foot per second", "feet per second"), 337 337 - Knot: (Speed, d!(1.852), "knot", "knots"), 389 389 + // inexact: 390 390 + KilometersPerHour: (Speed, d!(0.2777777778), "kilometer per hour", "kilometers per hour"), 391 391 + MetersPerSecond: (Speed, d!(1), "meter per second", "meters per second"), 392 392 + MilesPerHour: (Speed, d!(0.44704), "mile per hour", "miles per hour"), 393 393 + FeetPerSecond: (Speed, d!(0.3048), "foot per second", "feet per second"), 394 394 + // inexact: 395 395 + Knot: (Speed, d!(0.5144444444), "knot", "knots"), 338 396 339 397 Kelvin: (Temperature, d!(0), "kelvin", "kelvin"), 340 398 Celsius: (Temperature, d!(0), "celsius", "celsius"), 341 399 Fahrenheit: (Temperature, d!(0), "fahrenheit", "fahrenheit"), 342 400 ); 343 401 344 344 - /// Returns the conversion factor between two units. 345 345 - /// 346 346 - /// The conversion factor is what you need to multiply `unit` with to get 347 347 - /// `to_unit`. For example, the conversion factor from 1 minute to 1 second 348 348 - /// is 60. 349 349 - /// 350 350 - /// This is not sufficient for [`Temperature`] units. 351 351 - pub fn get_conversion_factor(unit: Unit, to_unit: Unit) -> D128 { 352 352 - unit.weight() / to_unit.weight() 402 402 + fn combined_weight(unit: &[(Unit, isize)]) -> D128 { 403 403 + unit.iter().fold(D128::from(1), |acc, (u, exp)| { 404 404 + acc * integer_power(u.weight(), *exp) 405 405 + }) 406 406 + } 407 407 + 408 408 + fn integer_power(base: D128, exp: isize) -> D128 { 409 409 + let positive = (0..exp.unsigned_abs()).fold(D128::from(1), |acc, _| acc * base); 410 410 + if exp >= 0 { 411 411 + positive 412 412 + } else { 413 413 + D128::from(1) / positive 414 414 + } 353 415 } 354 416 355 417 /// Convert a [`Number`] to a specified [`Unit`]. 356 356 - pub fn convert(number: Number, to_unit: Unit) -> Result<Number, String> { 357 357 - if number.unit.category() != to_unit.category() { 358 358 - return Err(format!("Cannot convert from {:?} to {:?}", number.unit, to_unit)); 418 418 + pub fn convert(number: Number, to_unit: Vec<(Unit, isize)>) -> Result<Number, String> { 419 419 + if number.primitive_unit() != primitive_unit(&to_unit) { 420 420 + return Err(format!( 421 421 + "Cannot convert {} to {}", 422 422 + number, 423 423 + Number::with_unit(d!(0), to_unit).plural() 424 424 + )); 359 425 } 360 426 let value = number.value; 361 361 - let ok = |new_value| { 362 362 - Ok(Number::new(new_value, to_unit)) 363 363 - }; 364 364 - if number.unit.category() == UnitType::Temperature { 365 365 - match (number.unit, to_unit) { 366 366 - (Kelvin, Kelvin) => ok(value), 367 367 - (Kelvin, Celsius) => ok(value-d!(273.15)), 368 368 - (Kelvin, Fahrenheit) => ok(value*d!(1.8)-d!(459.67)), 369 369 - (Celsius, Celsius) => ok(value), 370 370 - (Celsius, Kelvin) => ok(value+d!(273.15)), 371 371 - (Celsius, Fahrenheit) => ok(value*d!(1.8)+d!(32)), 427 427 + if number.primitive_unit() == Temperature.primitive() { 428 428 + if number.unit.len() != 1 429 429 + || to_unit.len() != 1 430 430 + || number.unit[0].1 != 1 431 431 + || to_unit[0].1 != 1 432 432 + { 433 433 + return Err(format!( 434 434 + "Cannot convert {} to {}", 435 435 + number, 436 436 + Number::with_unit(d!(0), to_unit).plural() 437 437 + )); 438 438 + } 439 439 + let ok = |new_value| Ok(Number::with_unit(new_value, to_unit.clone())); 440 440 + match (number.unit[0].0, to_unit[0].0) { 441 441 + (Kelvin, Kelvin) => ok(value), 442 442 + (Kelvin, Celsius) => ok(value - d!(273.15)), 443 443 + (Kelvin, Fahrenheit) => ok(value * d!(1.8) - d!(459.67)), 444 444 + (Celsius, Celsius) => ok(value), 445 445 + (Celsius, Kelvin) => ok(value + d!(273.15)), 446 446 + (Celsius, Fahrenheit) => ok(value * d!(1.8) + d!(32)), 372 447 (Fahrenheit, Fahrenheit) => ok(value), 373 373 - (Fahrenheit, Kelvin) => ok((value+d!(459.67))*d!(5)/d!(9)), 374 374 - (Fahrenheit, Celsius) => ok((value-d!(32))/d!(1.8)), 375 375 - _ => Err(format!("Error converting temperature {:?} to {:?}", number.unit, to_unit)), 448 448 + (Fahrenheit, Kelvin) => ok((value + d!(459.67)) * d!(5) / d!(9)), 449 449 + (Fahrenheit, Celsius) => ok((value - d!(32)) / d!(1.8)), 450 450 + _ => Err(format!( 451 451 + "Error converting temperature {} to {}", 452 452 + number, 453 453 + Number::with_unit(d!(0), to_unit).plural() 454 454 + )), 376 455 } 377 456 } else { 378 378 - let conversion_factor = get_conversion_factor(number.unit, to_unit); 379 379 - ok(number.value * conversion_factor) 457 457 + let source_weight = combined_weight(&number.unit); 458 458 + let target_weight = combined_weight(&to_unit); 459 459 + 460 460 + Ok(Number { 461 461 + value: number.value * source_weight / target_weight, 462 462 + unit: to_unit.to_vec(), 463 463 + }) 380 464 } 381 465 } 382 466 383 467 /// If one of two provided [`Number`]s has a larger [`Unit`] than the other, convert 384 468 /// the large one to the unit of the small one. 385 469 pub fn convert_to_lowest(left: Number, right: Number) -> Result<(Number, Number), String> { 386 386 - if left.unit.weight() == right.unit.weight() { 470 470 + assert!(left.primitive_unit() == right.primitive_unit()); 471 471 + if combined_weight(&left.unit) == combined_weight(&right.unit) { 387 472 Ok((left, right)) 388 388 - } else if left.unit.weight() > right.unit.weight() { 389 389 - let left_converted = convert(left, right.unit)?; 473 473 + } else if combined_weight(&left.unit) > combined_weight(&right.unit) { 474 474 + let left_converted = convert(left, right.unit.clone())?; 390 475 Ok((left_converted, right)) 391 476 } else { 392 392 - let right_converted = convert(right, left.unit)?; 477 477 + let right_converted = convert(right, left.unit.clone())?; 393 478 Ok((left, right_converted)) 394 479 } 395 480 } ··· 397 482 /// Return the sum of two [`Number`]s 398 483 pub fn add(left: Number, right: Number) -> Result<Number, String> { 399 484 if left.unit == right.unit { 400 400 - Ok(Number::new(left.value + right.value, left.unit)) 401 401 - } else if left.unit.category() == right.unit.category() && left.unit.category() != Temperature { 485 485 + Ok(Number::with_unit(left.value + right.value, left.unit)) 486 486 + } else if left.primitive_unit() == right.primitive_unit() 487 487 + && !left.contains_primitive(Temperature) 488 488 + { 402 489 let (left, right) = convert_to_lowest(left, right)?; 403 403 - Ok(Number::new(left.value + right.value, left.unit)) 490 490 + Ok(Number::with_unit(left.value + right.value, left.unit)) 404 491 } else { 405 405 - Err(format!("Cannot add {:?} and {:?}", left.unit, right.unit)) 492 492 + Err(format!("Cannot add {} and {}", left, right)) 406 493 } 407 494 } 408 495 409 496 /// Subtract a [`Number`] from another [`Number`] 410 497 pub fn subtract(left: Number, right: Number) -> Result<Number, String> { 411 498 if left.unit == right.unit { 412 412 - Ok(Number::new(left.value - right.value, left.unit)) 413 413 - } else if left.unit.category() == right.unit.category() && left.unit.category() != Temperature { 499 499 + Ok(Number::with_unit(left.value - right.value, left.unit)) 500 500 + } else if left.primitive_unit() == right.primitive_unit() 501 501 + && !left.contains_primitive(Temperature) 502 502 + { 414 503 let (left, right) = convert_to_lowest(left, right)?; 415 415 - Ok(Number::new(left.value - right.value, left.unit)) 504 504 + Ok(Number::with_unit(left.value - right.value, left.unit)) 416 505 } else { 417 417 - Err(format!("Cannot subtract {:?} by {:?}", left.unit, right.unit)) 506 506 + Err(format!("Cannot subtract {} by {}", left, right)) 418 507 } 419 508 } 420 509 421 510 /// Convert a [`Number`] to an ideal unit. 422 422 - /// 511 511 + /// 423 512 /// If you have 1,000,000 millimeters, this will return 1 kilometer. 424 424 - /// 513 513 + /// 425 514 /// This only affects units of `Length`, `Time`, `Area`, `Volume`, 426 515 /// `Energy`, `Power`, `ElectricCurrent`, `Resistance`, and `Voltage`. 427 516 /// Other units are passed through. 428 517 pub fn to_ideal_unit(number: Number) -> Number { 429 429 - let value = number.value * number.unit.weight(); 430 430 - if number.unit.category() == Length { 431 431 - if value >= d!(1000000000000000000) { // ≈ 0.1 light years 432 432 - return Number::new(value/LightYear.weight(), LightYear) 433 433 - } else if value >= d!(1000000) { // 1 km 434 434 - return Number::new(value/Kilometer.weight(), Kilometer) 435 435 - } else if value >= d!(1000) { // 1 m 436 436 - return Number::new(value/Meter.weight(), Meter) 437 437 - } else if value >= d!(10) { // 1 cm 438 438 - return Number::new(value/Centimeter.weight(), Centimeter) 518 518 + let value = number.value * combined_weight(&number.unit); 519 519 + let primitive = number.primitive_unit(); 520 520 + if primitive == Length.primitive() { 521 521 + if value >= 0.1 * LightYear.weight() { 522 522 + return Number::with_basic_unit(value / LightYear.weight(), LightYear); 523 523 + } else if value >= Kilometer.weight() { 524 524 + return Number::with_basic_unit(value / Kilometer.weight(), Kilometer); 525 525 + } else if value >= Meter.weight() { 526 526 + return Number::with_basic_unit(value / Meter.weight(), Meter); 527 527 + } else if value >= Centimeter.weight() { 528 528 + return Number::with_basic_unit(value / Centimeter.weight(), Centimeter); 439 529 } else { 440 440 - return Number::new(value, Millimeter) 530 530 + return Number::with_basic_unit(value / Millimeter.weight(), Millimeter); 441 531 } 442 442 - } else if number.unit.category() == Time { 443 443 - if value >= d!(31556952000000000) { 444 444 - return Number::new(value/Year.weight(), Year); 445 445 - } else if value >= d!(86400000000000) { 446 446 - return Number::new(value/Day.weight(), Day); 447 447 - } else if value >= d!(3600000000000) { 448 448 - return Number::new(value/Hour.weight(), Hour); 449 449 - } else if value >= d!(60000000000) { 450 450 - return Number::new(value/Minute.weight(), Minute); 451 451 - } else if value >= d!(1000000000) { 452 452 - return Number::new(value/Second.weight(), Second); 453 453 - } else if value >= d!(1000000) { 454 454 - return Number::new(value/Millisecond.weight(), Millisecond); 455 455 - } else if value >= d!(1000) { 456 456 - return Number::new(value/Microsecond.weight(), Microsecond); 532 532 + } else if primitive == Time.primitive() { 533 533 + if value >= Year.weight() { 534 534 + return Number::with_basic_unit(value / Year.weight(), Year); 535 535 + } else if value >= Day.weight() { 536 536 + return Number::with_basic_unit(value / Day.weight(), Day); 537 537 + } else if value >= Hour.weight() { 538 538 + return Number::with_basic_unit(value / Hour.weight(), Hour); 539 539 + } else if value >= Minute.weight() { 540 540 + return Number::with_basic_unit(value / Minute.weight(), Minute); 541 541 + } else if value >= Second.weight() { 542 542 + return Number::with_basic_unit(value / Second.weight(), Second); 543 543 + } else if value >= Millisecond.weight() { 544 544 + return Number::with_basic_unit(value / Millisecond.weight(), Millisecond); 545 545 + } else if value >= Microsecond.weight() { 546 546 + return Number::with_basic_unit(value / Microsecond.weight(), Microsecond); 457 547 } else { 458 458 - return Number::new(value, Nanosecond); 548 548 + return Number::with_basic_unit(value / Nanosecond.weight(), Nanosecond); 459 549 } 460 460 - } else if number.unit.category() == Area { 461 461 - if value >= d!(1000000000000) { // 1 km2 462 462 - return Number::new(value/SquareKilometer.weight(), SquareKilometer) 463 463 - } else if value >= d!(10000000000) { // 1 hectare 464 464 - return Number::new(value/Hectare.weight(), Hectare) 465 465 - } else if value >= d!(1000000) { // 1 m2 466 466 - return Number::new(value/SquareMeter.weight(), SquareMeter) 467 467 - } else if value >= d!(100) { // 1 cm2 468 468 - return Number::new(value/SquareCentimeter.weight(), SquareCentimeter) 550 550 + } else if primitive == Area.primitive() { 551 551 + if value >= SquareKilometer.weight() { 552 552 + return Number::with_basic_unit(value / SquareKilometer.weight(), SquareKilometer); 553 553 + } else if value >= Hectare.weight() { 554 554 + return Number::with_basic_unit(value / Hectare.weight(), Hectare); 555 555 + } else if value >= SquareMeter.weight() { 556 556 + return Number::with_basic_unit(value / SquareMeter.weight(), SquareMeter); 557 557 + } else if value >= SquareCentimeter.weight() { 558 558 + return Number::with_basic_unit(value / SquareCentimeter.weight(), SquareCentimeter); 469 559 } else { 470 470 - return Number::new(value, SquareMillimeter) 560 560 + return Number::with_basic_unit(value / SquareMillimeter.weight(), SquareMillimeter); 471 561 } 472 472 - } else if number.unit.category() == Volume { 473 473 - if value >= d!(1000000000000000000) { // 1 km3 474 474 - return Number::new(value/CubicKilometer.weight(), CubicKilometer) 475 475 - } else if value >= d!(1000000000) { // 1 m3 476 476 - return Number::new(value/CubicMeter.weight(), CubicMeter) 477 477 - } else if value >= d!(1000000) { // 1 l 478 478 - return Number::new(value/Liter.weight(), Liter) 479 479 - } else if value >= d!(1000) { // 1 ml 480 480 - return Number::new(value/Milliliter.weight(), Milliliter) 562 562 + } else if primitive == Volume.primitive() { 563 563 + if value >= CubicKilometer.weight() { 564 564 + return Number::with_basic_unit(value / CubicKilometer.weight(), CubicKilometer); 565 565 + } else if value >= CubicMeter.weight() { 566 566 + return Number::with_basic_unit(value / CubicMeter.weight(), CubicMeter); 567 567 + } else if value >= Liter.weight() { 568 568 + return Number::with_basic_unit(value / Liter.weight(), Liter); 569 569 + } else if value >= Milliliter.weight() { 570 570 + return Number::with_basic_unit(value / Milliliter.weight(), Milliliter); 481 571 } else { 482 482 - return Number::new(value, CubicMillimeter) 572 572 + return Number::with_basic_unit(value / CubicMillimeter.weight(), CubicMillimeter); 483 573 } 484 484 - } else if number.unit.category() == Energy { 485 485 - if value >= d!(3600000000000000000) { // 1 petawatthour 486 486 - return Number::new(value/PetawattHour.weight(), PetawattHour) 487 487 - } else if value >= d!(3600000000000000) { // 1 terawatthour 488 488 - return Number::new(value/TerawattHour.weight(), TerawattHour) 489 489 - } else if value >= d!(3600000000000) { // 1 gigawatthour 490 490 - return Number::new(value/GigawattHour.weight(), GigawattHour) 491 491 - } else if value >= d!(3600000000) { // 1 megawatthour 492 492 - return Number::new(value/MegawattHour.weight(), MegawattHour) 493 493 - } else if value >= d!(3600000) { // 1 kilowatthour 494 494 - return Number::new(value/KilowattHour.weight(), KilowattHour) 495 495 - } else if value >= d!(3600) { // 1 watthour 496 496 - return Number::new(value/WattHour.weight(), WattHour) 497 497 - } else if value >= d!(1) { // 1 joule 498 498 - return Number::new(value, Joule) 574 574 + } else if primitive == Energy.primitive() { 575 575 + let has_second = number.unit.iter().find(|unit| unit.0 == Second).is_some(); 576 576 + if has_second { 577 577 + if value >= Terajoule.weight() { 578 578 + return Number::with_basic_unit(value / Terajoule.weight(), Terajoule); 579 579 + } else if value >= Gigajoule.weight() { 580 580 + return Number::with_basic_unit(value / Gigajoule.weight(), Gigajoule); 581 581 + } else if value >= Megajoule.weight() { 582 582 + return Number::with_basic_unit(value / Megajoule.weight(), Megajoule); 583 583 + } else if value >= Kilojoule.weight() { 584 584 + return Number::with_basic_unit(value / Kilojoule.weight(), Kilojoule); 585 585 + } else if value >= Joule.weight() { 586 586 + return Number::with_basic_unit(value / Joule.weight(), Joule); 587 587 + } else { 588 588 + return Number::with_basic_unit(value / Millijoule.weight(), Millijoule); 589 589 + } 499 590 } else { 500 500 - return Number::new(value/Millijoule.weight(), Millijoule) 591 591 + if value >= PetawattHour.weight() { 592 592 + return Number::with_basic_unit(value / PetawattHour.weight(), PetawattHour); 593 593 + } else if value >= TerawattHour.weight() { 594 594 + return Number::with_basic_unit(value / TerawattHour.weight(), TerawattHour); 595 595 + } else if value >= GigawattHour.weight() { 596 596 + return Number::with_basic_unit(value / GigawattHour.weight(), GigawattHour); 597 597 + } else if value >= MegawattHour.weight() { 598 598 + return Number::with_basic_unit(value / MegawattHour.weight(), MegawattHour); 599 599 + } else if value >= KilowattHour.weight() { 600 600 + return Number::with_basic_unit(value / KilowattHour.weight(), KilowattHour); 601 601 + } else if value >= WattHour.weight() { 602 602 + return Number::with_basic_unit(value / WattHour.weight(), WattHour); 603 603 + } else if value >= Joule.weight() { 604 604 + return Number::with_basic_unit(value / Joule.weight(), Joule); 605 605 + } else { 606 606 + return Number::with_basic_unit(value / Millijoule.weight(), Millijoule); 607 607 + } 501 608 } 502 502 - } else if number.unit.category() == Power { 503 503 - if value >= d!(1000000000000000) { // 1 petawatt 504 504 - return Number::new(value/Petawatt.weight(), Petawatt) 505 505 - } else if value >= d!(1000000000000) { // 1 terawatt 506 506 - return Number::new(value/Terawatt.weight(), Terawatt) 507 507 - } else if value >= d!(1000000000) { // 1 gigawatt 508 508 - return Number::new(value/Gigawatt.weight(), Gigawatt) 509 509 - } else if value >= d!(1000000) { // megawatt 510 510 - return Number::new(value/Megawatt.weight(), Megawatt) 511 511 - } else if value >= d!(1000) { // 1 kilowatt 512 512 - return Number::new(value/Kilowatt.weight(), Kilowatt) 513 513 - } else if value >= d!(1) { // 1 watt 514 514 - return Number::new(value, Watt) 609 609 + } else if primitive == Power.primitive() { 610 610 + if value >= Petawatt.weight() { 611 611 + return Number::with_basic_unit(value / Petawatt.weight(), Petawatt); 612 612 + } else if value >= Terawatt.weight() { 613 613 + return Number::with_basic_unit(value / Terawatt.weight(), Terawatt); 614 614 + } else if value >= Gigawatt.weight() { 615 615 + return Number::with_basic_unit(value / Gigawatt.weight(), Gigawatt); 616 616 + } else if value >= Megawatt.weight() { 617 617 + return Number::with_basic_unit(value / Megawatt.weight(), Megawatt); 618 618 + } else if value >= Kilowatt.weight() { 619 619 + return Number::with_basic_unit(value / Kilowatt.weight(), Kilowatt); 620 620 + } else if value >= Watt.weight() { 621 621 + return Number::with_basic_unit(value / Watt.weight(), Watt); 515 622 } else { 516 516 - return Number::new(value/Milliwatt.weight(), Milliwatt) 623 623 + return Number::with_basic_unit(value / Milliwatt.weight(), Milliwatt); 517 624 } 518 518 - } else if number.unit.category() == ElectricCurrent { 519 519 - if value >= d!(1000) { // 1 kiloampere 520 520 - return Number::new(value/Kiloampere.weight(), Kiloampere) 521 521 - } else if value >= d!(1) { // 1 ampere 522 522 - return Number::new(value, Ampere) 625 625 + } else if primitive == ElectricCurrent.primitive() { 626 626 + if value >= Kiloampere.weight() { 627 627 + return Number::with_basic_unit(value / Kiloampere.weight(), Kiloampere); 628 628 + } else if value >= Ampere.weight() { 629 629 + return Number::with_basic_unit(value / Ampere.weight(), Ampere); 523 630 } else { 524 524 - return Number::new(value/Milliampere.weight(), Milliampere) 631 631 + return Number::with_basic_unit(value / Milliampere.weight(), Milliampere); 525 632 } 526 526 - } else if number.unit.category() == Resistance { 527 527 - if value >= d!(1000) { // 1 kiloohm 528 528 - return Number::new(value/Kiloohm.weight(), Kiloohm) 529 529 - } else if value >= d!(1) { // 1 ohm 530 530 - return Number::new(value, Ohm) 633 633 + } else if primitive == Resistance.primitive() { 634 634 + if value >= Kiloohm.weight() { 635 635 + return Number::with_basic_unit(value / Kiloohm.weight(), Kiloohm); 636 636 + } else if value >= Ohm.weight() { 637 637 + return Number::with_basic_unit(value / Ohm.weight(), Ohm); 531 638 } else { 532 532 - return Number::new(value/Milliohm.weight(), Milliohm) 639 639 + return Number::with_basic_unit(value / Milliohm.weight(), Milliohm); 533 640 } 534 534 - } else if number.unit.category() == Voltage { 535 535 - if value >= d!(1000) { // 1 kilovolt 536 536 - return Number::new(value/Kilovolt.weight(), Kilovolt) 537 537 - } else if value >= d!(1) { // 1 volt 538 538 - return Number::new(value, Volt) 641 641 + } else if primitive == Voltage.primitive() { 642 642 + if value >= Kilovolt.weight() { 643 643 + return Number::with_basic_unit(value / Kilovolt.weight(), Kilovolt); 644 644 + } else if value >= Volt.weight() { 645 645 + return Number::with_basic_unit(value / Volt.weight(), Volt); 539 646 } else { 540 540 - return Number::new(value/Millivolt.weight(), Millivolt) 647 647 + return Number::with_basic_unit(value / Millivolt.weight(), Millivolt); 541 648 } 542 542 - } 543 543 - number 544 544 - } 545 545 - 546 546 - /// Convert a [`Number`] to an ideal [`Joule`] unit, if the number is a unit of [`Energy`]. 547 547 - pub fn to_ideal_joule_unit(number: Number) -> Number { 548 548 - let value = number.value * number.unit.weight(); 549 549 - if number.unit.category() == Energy { 550 550 - if value >= d!(1000000000000) { // 1 terajoule 551 551 - return Number::new(value/Terajoule.weight(), Terajoule) 552 552 - } else if value >= d!(1000000000) { // 1 gigajoule 553 553 - return Number::new(value/Gigajoule.weight(), Gigajoule) 554 554 - } else if value >= d!(1000000) { // 1 megajoule 555 555 - return Number::new(value/Megajoule.weight(), Megajoule) 556 556 - } else if value >= d!(1000) { // 1 kilojoule 557 557 - return Number::new(value/Kilojoule.weight(), Kilojoule) 558 558 - } else if value >= d!(1) { // 1 joule 559 559 - return Number::new(value/Joule.weight(), Joule) 560 560 - } else { 561 561 - return Number::new(value/Millijoule.weight(), Millijoule) 649 649 + } else if primitive == DigitalStorage.primitive() { 650 650 + let bits = &[ 651 651 + Bit, Kilobit, Megabit, Gigabit, Terabit, Petabit, Exabit, Zettabit, Yottabit, 652 652 + ]; 653 653 + let bibits = &[ 654 654 + Bit, Kibibit, Mebibit, Gibibit, Tebibit, Pebibit, Exbibit, Zebibit, Yobibit, 655 655 + ]; 656 656 + let bytes = &[ 657 657 + Byte, Kilobyte, Megabyte, Gigabyte, Terabyte, Petabyte, Exabyte, Zettabyte, Yottabyte, 658 658 + ]; 659 659 + let bibytes = &[ 660 660 + Byte, Kibibyte, Mebibyte, Gibibyte, Tebibyte, Pebibyte, Exbibyte, Zebibyte, Yobibyte, 661 661 + ]; 662 662 + for unit in &number.unit { 663 663 + if unit.0.category() == DigitalStorage || unit.0.category() == DataTransferRate { 664 664 + let weight = unit.0.weight(); 665 665 + let candidates = if weight % 8192 == d!(0) { 666 666 + bibytes 667 667 + } else if weight % 8000 == d!(0) { 668 668 + bytes 669 669 + } else if weight % 1024 == d!(0) { 670 670 + bibits 671 671 + } else { 672 672 + bits 673 673 + }; 674 674 + let unit = candidates 675 675 + .iter() 676 676 + .rev() 677 677 + .find(|&&u| value >= u.weight()) 678 678 + .copied() 679 679 + .unwrap_or(candidates[0]); 680 680 + return Number::with_basic_unit(value / unit.weight(), unit); 681 681 + } 562 682 } 683 683 + } else if primitive == FlopCount.primitive() { 684 684 + let candidates = [ 685 685 + Flop, KiloFlop, MegaFlop, GigaFlop, TeraFlop, PetaFlop, ExaFlop, ZettaFlop, YottaFlop, 686 686 + RonnaFlop, QuettaFlop, 687 687 + ]; 688 688 + let unit = candidates 689 689 + .iter() 690 690 + .rev() 691 691 + .find(|&&u| value >= u.weight()) 692 692 + .copied() 693 693 + .unwrap_or(candidates[0]); 694 694 + return Number::with_basic_unit(value / unit.weight(), unit); 563 695 } 564 696 number 565 697 } 566 698 567 567 - /// Multiply two [`Number`]s 568 568 - /// 569 569 - /// - Temperatures don't work 570 570 - /// - If you multiply [`NoType`] with any other unit, the result gets that other unit 571 571 - /// - If you multiply [`Length`] with [`Length`], the result has a unit of [`Area`], etc. 572 572 - /// - If you multiply [`Speed`] with [`Time`], the result has a unit of [`Length`] 573 573 - /// - If you multiply [`Voltage`] with [`ElectricCurrent`], the result has a unit of [`Power`] 574 574 - /// - If you multiply [`ElectricCurrent`] with [`Resistance`], the result has a unit of [`Voltage`] 575 575 - /// - If you multiply [`Power`] with [`Time`], the result has a unit of [`Energy`] 699 699 + /// Multiply two [`Number`]s. 700 700 + /// 701 701 + /// Units are converted accordingly. 702 702 + /// 703 703 + /// Temperatures don't work 576 704 pub fn multiply(left: Number, right: Number) -> Result<Number, String> { 577 577 - actual_multiply(left, right, false) 578 578 - } 579 579 - 580 580 - fn actual_multiply(left: Number, right: Number, swapped: bool) -> Result<Number, String> { 581 581 - let lcat = left.unit.category(); 582 582 - let rcat = right.unit.category(); 583 583 - if left.unit == NoUnit && right.unit == NoUnit { 584 584 - // 3 * 2 585 585 - Ok(Number::new(left.value * right.value, left.unit)) 586 586 - } else if left.unit.category() == Temperature || right.unit.category() == Temperature { 587 587 - // if temperature 588 588 - Err(format!("Cannot multiply {:?} and {:?}", left.unit, right.unit)) 589 589 - } else if left.unit == NoUnit && right.unit != NoUnit { 590 590 - // 3 * 2 anyunit 591 591 - Ok(Number::new(left.value * right.value, right.unit)) 592 592 - } else if lcat == Length && rcat == Length { 593 593 - // length * length 594 594 - let result = (left.value * left.unit.weight()) * (right.value * right.unit.weight()); 595 595 - Ok(to_ideal_unit(Number::new(result, SquareMillimeter))) 596 596 - } else if lcat == Length && rcat == Area { 597 597 - // length * area 598 598 - let result = (left.value * left.unit.weight()) * (right.value * right.unit.weight()); 599 599 - Ok(to_ideal_unit(Number::new(result, CubicMillimeter))) 600 600 - } else if lcat == Speed && rcat == Time { 601 601 - // 1 km/h * 1h 602 602 - let kph_value = left.value * left.unit.weight(); 603 603 - let hours = convert(right, Hour)?; 604 604 - let result = kph_value * hours.value; 605 605 - let final_unit = match left.unit { 606 606 - KilometersPerHour => Kilometer, 607 607 - MetersPerSecond => Meter, 608 608 - MilesPerHour => Mile, 609 609 - FeetPerSecond => Foot, 610 610 - Knot => NauticalMile, 611 611 - _ => Meter, 612 612 - }; 613 613 - let kilometers = Number::new(result, Kilometer); 614 614 - Ok(convert(kilometers, final_unit)?) 615 615 - } else if lcat == DataTransferRate && rcat == Time { 616 616 - // 8 megabytes per second * 1 minute 617 617 - let data_rate_value = left.value * left.unit.weight(); 618 618 - let seconds = convert(right, Second)?; 619 619 - let result = data_rate_value * seconds.value; 620 620 - let final_unit = match left.unit { 621 621 - BitsPerSecond => Bit, 622 622 - KilobitsPerSecond => Kilobit, 623 623 - MegabitsPerSecond => Megabit, 624 624 - GigabitsPerSecond => Gigabit, 625 625 - TerabitsPerSecond => Terabit, 626 626 - PetabitsPerSecond => Petabit, 627 627 - ExabitsPerSecond => Exabit, 628 628 - ZettabitsPerSecond => Zettabit, 629 629 - YottabitsPerSecond => Yottabit, 630 630 - KibibitsPerSecond => Kibibit, 631 631 - MebibitsPerSecond => Mebibit, 632 632 - GibibitsPerSecond => Gibibit, 633 633 - TebibitsPerSecond => Tebibit, 634 634 - PebibitsPerSecond => Pebibit, 635 635 - ExbibitsPerSecond => Exbibit, 636 636 - ZebibitsPerSecond => Zebibit, 637 637 - YobibitsPerSecond => Yobibit, 638 638 - BytesPerSecond => Byte, 639 639 - KilobytesPerSecond => Kilobyte, 640 640 - MegabytesPerSecond => Megabyte, 641 641 - GigabytesPerSecond => Gigabyte, 642 642 - TerabytesPerSecond => Terabyte, 643 643 - PetabytesPerSecond => Petabyte, 644 644 - ExabytesPerSecond => Exabyte, 645 645 - ZettabytesPerSecond => Zettabyte, 646 646 - YottabytesPerSecond => Yottabyte, 647 647 - KibibytesPerSecond => Kibibyte, 648 648 - MebibytesPerSecond => Mebibyte, 649 649 - GibibytesPerSecond => Gibibyte, 650 650 - TebibytesPerSecond => Tebibyte, 651 651 - PebibytesPerSecond => Pebibyte, 652 652 - ExbibytesPerSecond => Exbibyte, 653 653 - ZebibytesPerSecond => Zebibyte, 654 654 - YobibytesPerSecond => Yobibyte, 655 655 - _ => Bit, 656 656 - }; 657 657 - let data_storage = Number::new(result, Bit); 658 658 - Ok(convert(data_storage, final_unit)?) 659 659 - } else if lcat == FlopRate && rcat == Time { 660 660 - // 8 megaFLOP per second * 1 minute 661 661 - let compute_perf_value = left.value * left.unit.weight(); 662 662 - let seconds = convert(right, Second)?; 663 663 - let result = compute_perf_value * seconds.value; 664 664 - let final_unit = match left.unit { 665 665 - FlopPerSecond => Flop, 666 666 - KiloFlopPerSecond => KiloFlop, 667 667 - MegaFlopPerSecond => MegaFlop, 668 668 - GigaFlopPerSecond => GigaFlop, 669 669 - TeraFlopPerSecond => TeraFlop, 670 670 - PetaFlopPerSecond => PetaFlop, 671 671 - ExaFlopPerSecond => ExaFlop, 672 672 - ZettaFlopPerSecond => ZettaFlop, 673 673 - YottaFlopPerSecond => YottaFlop, 674 674 - RonnaFlopPerSecond => RonnaFlop, 675 675 - QuettaFlopPerSecond => QuettaFlop, 676 676 - _ => Flop, 677 677 - }; 678 678 - let compute_work = Number::new(result, Flop); 679 679 - Ok(convert(compute_work, final_unit)?) 680 680 - } else if lcat == Voltage && rcat == ElectricCurrent { 681 681 - // 1 volt * 1 ampere = 1 watt 682 682 - let result = (left.value * left.unit.weight()) * (right.value * right.unit.weight()); 683 683 - Ok(to_ideal_unit(Number::new(result, Watt))) 684 684 - } else if lcat == ElectricCurrent && rcat == Resistance { 685 685 - // 1 amp * 1 ohm = 1 volt 686 686 - let result = (left.value * left.unit.weight()) * (right.value * right.unit.weight()); 687 687 - Ok(to_ideal_unit(Number::new(result, Watt))) 688 688 - } else if lcat == Power && rcat == Time { 689 689 - // 1 watt * 1 second = 1 joule 690 690 - let result = (left.value * left.unit.weight()) * (right.value * right.unit.weight() / Unit::Second.weight()); 691 691 - match right.unit { 692 692 - Second => Ok(to_ideal_joule_unit(Number::new(result, Joule))), 693 693 - _ => Ok(to_ideal_unit(Number::new(result, Joule))), 705 705 + if left.contains_primitive(Temperature) || right.contains_primitive(Temperature) { 706 706 + Err(format!("Cannot multiply {} and {}", left, right)) 707 707 + } else { 708 708 + let mut new_number = left; 709 709 + new_number.value *= right.value; 710 710 + for (r_unit, r_exp) in right.unit { 711 711 + let existing = new_number.unit.iter_mut().find(|(u, _)| u == &r_unit); 712 712 + match existing { 713 713 + Some(existing) => existing.1 += r_exp, 714 714 + None => new_number.unit.push((r_unit, r_exp)), 715 715 + } 694 716 } 695 695 - } else if swapped { 696 696 - Err(format!("Cannot multiply {:?} and {:?}", right.unit, left.unit)) 697 697 - } else { 698 698 - actual_multiply(right, left, true) 717 717 + let new_number = to_ideal_unit(new_number); 718 718 + Ok(new_number) 699 719 } 700 720 } 701 721 702 702 - /// Divide a [`Number`] by another [`Number`] 703 703 - /// 704 704 - /// - Temperatures don't work 705 705 - /// - If you divide a unit by that same unit, the result has a unit of [`NoType`] 706 706 - /// - If you divide [`Volume`] by [`Length`], the result has a unit of [`Area`], etc. 707 707 - /// - If you divide [`Length`] by [`Time`], the result has a unit of [`Speed`] 708 708 - /// - If you divide [`Length`] by [`Speed`], the result has a unit of [`Time`] 709 709 - /// - If you divide [`Power`] by [`ElectricCurrent`], the result has a unit of [`Volt`] 710 710 - /// - If you divide [`Voltage`] by [`ElectricCurrent`], the result has a unit of [`Ohm`] 711 711 - /// - If you divide [`Voltage`] by [`Resistance`], the result has a unit of [`Ampere`] 712 712 - /// - If you divide [`Power`] by [`Voltage`], the result has a unit of [`Ampere`] 713 713 - /// - If you divide [`Energy`] by [`Time`], the result has a unit of [`Power`] 722 722 + /// Divide a [`Number`] by another [`Number`]. 723 723 + /// 724 724 + /// Units are converted accordingly. 725 725 + /// 726 726 + /// Temperatures don't work. 714 727 pub fn divide(left: Number, right: Number) -> Result<Number, String> { 715 715 - let lcat = left.unit.category(); 716 716 - let rcat = right.unit.category(); 717 717 - if left.unit == NoUnit && right.unit == NoUnit { 718 718 - // 3 / 2 719 719 - Ok(Number::new(left.value / right.value, left.unit)) 720 720 - } else if lcat == Temperature || rcat == Temperature { 721 721 - // if temperature 722 722 - Err(format!("Cannot divide {:?} by {:?}", left.unit, right.unit)) 723 723 - } else if left.unit != NoUnit && right.unit == NoUnit { 724 724 - // 1 km / 2 725 725 - Ok(Number::new(left.value / right.value, left.unit)) 726 726 - } else if lcat == rcat { 727 727 - // 4 km / 2 km 728 728 - let (left, right) = convert_to_lowest(left, right)?; 729 729 - Ok(Number::new(left.value / right.value, NoUnit)) 730 730 - } else if (lcat == Area && rcat == Length) || (lcat == Volume && rcat == Area) { 731 731 - // 1 km2 / 1 km, 1 km3 / 1 km2 732 732 - let result = (left.value * left.unit.weight()) / (right.value * right.unit.weight()); 733 733 - Ok(to_ideal_unit(Number::new(result, Millimeter))) 734 734 - } else if lcat == Volume && rcat == Length { 735 735 - // 1 km3 / 1 km 736 736 - let result = (left.value * left.unit.weight()) / (right.value * right.unit.weight()); 737 737 - Ok(to_ideal_unit(Number::new(result, SquareMillimeter))) 738 738 - } else if lcat == Length && rcat == Time { 739 739 - // 1 km / 2s 740 740 - let final_unit = match (left.unit, right.unit) { 741 741 - (Kilometer, Hour) => KilometersPerHour, 742 742 - (Meter, Second) => MetersPerSecond, 743 743 - (Mile, Hour) => MilesPerHour, 744 744 - (Foot, Second) => FeetPerSecond, 745 745 - (NauticalMile, Hour) => Knot, 746 746 - _ => KilometersPerHour, 747 747 - }; 748 748 - let kilometers = convert(left, Kilometer)?; 749 749 - let hours = convert(right, Hour)?; 750 750 - let kph = Number::new(kilometers.value / hours.value, KilometersPerHour); 751 751 - Ok(convert(kph, final_unit)?) 752 752 - } else if lcat == Length && rcat == Speed { 753 753 - // 12 km / 100 kph 754 754 - let kilometers = convert(left, Kilometer)?; 755 755 - let kilometers_per_hour = convert(right, KilometersPerHour)?; 756 756 - let hour = Number::new(kilometers.value / kilometers_per_hour.value, Hour); 757 757 - Ok(to_ideal_unit(hour)) 758 758 - } else if lcat == DigitalStorage && rcat == DataTransferRate { 759 759 - // 1 kilobit / 1 bit per second 760 760 - let bits = convert(left, Bit)?; 761 761 - let bits_per_second = convert(right, BitsPerSecond)?; 762 762 - let seconds = Number::new(bits.value / bits_per_second.value, Second); 763 763 - Ok(to_ideal_unit(seconds)) 764 764 - } else if lcat == FlopCount && rcat == FlopRate { 765 765 - // 1 kiloFLOP / 1 FLOP per second 766 766 - let flop = convert(left, Flop)?; 767 767 - let flop_per_second = convert(right, FlopPerSecond)?; 768 768 - let seconds = Number::new(flop.value / flop_per_second.value, Second); 769 769 - Ok(to_ideal_unit(seconds)) 770 770 - } else if lcat == Power && rcat == ElectricCurrent { 771 771 - // 1 watt / 1 ampere = 1 volt 772 772 - let result = (left.value * left.unit.weight()) / (right.value * right.unit.weight()); 773 773 - Ok(to_ideal_unit(Number::new(result, Volt))) 774 774 - } else if lcat == Voltage && rcat == ElectricCurrent { 775 775 - // 1 volt / 1 ampere = 1 ohm 776 776 - let result = (left.value * left.unit.weight()) / (right.value * right.unit.weight()); 777 777 - Ok(to_ideal_unit(Number::new(result, Ohm))) 778 778 - } else if lcat == Voltage && rcat == Resistance { 779 779 - // 1 volt / 1 ohm = 1 amp 780 780 - let result = (left.value * left.unit.weight()) / (right.value * right.unit.weight()); 781 781 - Ok(to_ideal_unit(Number::new(result, Ampere))) 782 782 - } else if lcat == Power && rcat == Voltage { 783 783 - // 1 watt / 1 volt = 1 amp 784 784 - let result = (left.value * left.unit.weight()) / (right.value * right.unit.weight()); 785 785 - Ok(to_ideal_unit(Number::new(result, Ampere))) 786 786 - } else if lcat == Energy && rcat == Time { 787 787 - // 1 joule / 1 second = 1 watt 788 788 - let result = (left.value * left.unit.weight()) / (right.value * right.unit.weight() / Unit::Second.weight()); 789 789 - Ok(to_ideal_unit(Number::new(result, Watt))) 728 728 + if left.contains_primitive(Temperature) || right.contains_primitive(Temperature) { 729 729 + Err(format!("Cannot divide {} by {}", left, right)) 790 730 } else { 791 791 - Err(format!("Cannot divide {:?} by {:?}", left.unit, right.unit)) 731 731 + let mut new_number = left; 732 732 + new_number.value /= right.value; 733 733 + for (r_unit, r_exp) in right.unit { 734 734 + let existing = new_number.unit.iter_mut().find(|(u, _)| u == &r_unit); 735 735 + match existing { 736 736 + Some(existing) => existing.1 -= r_exp, 737 737 + None => new_number.unit.push((r_unit, -r_exp)), 738 738 + } 739 739 + } 740 740 + let new_number = to_ideal_unit(new_number); 741 741 + Ok(new_number) 792 742 } 793 743 } 744 744 + 794 745 /// Modulo a [`Number`] by another [`Number`]. 795 795 - /// 746 746 + /// 796 747 /// `left` and `right` need to have the same [`UnitType`], and the result will have that same [`UnitType`]. 797 748 /// 798 749 /// Temperatures don't work. 799 750 pub fn modulo(left: Number, right: Number) -> Result<Number, String> { 800 800 - if left.unit.category() == Temperature || right.unit.category() == Temperature { 801 801 - // if temperature 802 802 - Err(format!("Cannot modulo {:?} by {:?}", left.unit, right.unit)) 803 803 - } else if left.unit.category() == right.unit.category() { 751 751 + if left.contains_primitive(Temperature) || right.contains_primitive(Temperature) { 752 752 + Err(format!("Cannot modulo {} by {}", left, right)) 753 753 + } else if left.primitive_unit() == right.primitive_unit() { 804 754 // 5 km % 3 m 805 755 let (left, right) = convert_to_lowest(left, right)?; 806 806 - Ok(Number::new(left.value % right.value, left.unit)) 756 756 + Ok(Number::with_unit(left.value % right.value, left.unit)) 807 757 } else { 808 808 - Err(format!("Cannot modulo {:?} by {:?}", left.unit, right.unit)) 758 758 + Err(format!("Cannot modulo {} by {}", left, right)) 809 759 } 810 760 } 811 761 812 762 /// Returns a [`Number`] to the power of another [`Number`] 813 813 - /// 763 763 + /// 814 764 /// - If you take [`Length`] to the power of [`NoType`], the result has a unit of [`Area`]. 815 765 /// - If you take [`Length`] to the power of [`Length`], the result has a unit of [`Area`] 816 766 /// - If you take [`Length`] to the power of [`Area`], the result has a unit of [`Volume`] 817 767 /// - etc. 818 768 pub fn pow(left: Number, right: Number) -> Result<Number, String> { 819 769 // I tried converting `right` to use powi, but somehow that was slower 820 820 - let lcat = left.unit.category(); 821 821 - let rcat = left.unit.category(); 822 822 - if left.unit == NoUnit && right.unit == NoUnit { 823 823 - // 3 ^ 2 824 824 - Ok(Number::new(left.value.pow(right.value), left.unit)) 825 825 - } else if right.value == d!(1) && right.unit == NoUnit { 826 826 - Ok(left) 827 827 - } else if lcat == Length && right.unit == NoUnit && right.value == d!(2) { 828 828 - // x km ^ 2 829 829 - let result = (left.value * left.unit.weight()).pow(right.value); 830 830 - Ok(to_ideal_unit(Number::new(result, SquareMillimeter))) 831 831 - } else if lcat == Length && right.unit == NoUnit && right.value == d!(3) { 832 832 - // x km ^ 3 833 833 - let result = (left.value * left.unit.weight()).pow(right.value); 834 834 - Ok(to_ideal_unit(Number::new(result, CubicMillimeter))) 770 770 + if left.contains_primitive(Temperature) || right.has_unit() { 771 771 + Err(format!("Cannot raise {} to the power of {}", left, right)) 772 772 + } else if left.is_unitless() { 773 773 + let result = left.value.pow(right.value); 774 774 + let new_number = Number::new_unitless(result); 775 775 + Ok(new_number) 835 776 } else { 836 836 - Err(format!("Cannot multiply {:?} and {:?}", left.unit, right.unit)) 777 777 + let exp: isize = match (right.value.try_into(), right.value.is_integral()) { 778 778 + (Ok(exp), true) => exp, 779 779 + _ => { 780 780 + return Err(format!( 781 781 + "Cannot raise {} to the power of {}. Numbers with units can only be raised to integer powers", 782 782 + left, right 783 783 + )); 784 784 + } 785 785 + }; 786 786 + let result = left.value.pow(right.value); 787 787 + let mut new_number = Number::with_unit(result, left.unit); 788 788 + for (_, unit_exp) in new_number.unit.iter_mut() { 789 789 + *unit_exp *= exp; 790 790 + } 791 791 + let new_number = to_ideal_unit(new_number); 792 792 + Ok(new_number) 837 793 } 838 794 } 839 795 ··· 841 797 mod tests { 842 798 use fastnum::decimal::Context; 843 799 844 844 - use super::*; 800 800 + use super::*; 845 801 846 802 macro_rules! assert_float_eq { 847 803 ( $actual:expr, $expected:literal ) => { 848 804 assert!(($actual - $expected).abs() < f64::EPSILON); 849 849 - } 805 805 + }; 850 806 } 851 807 852 808 #[test] ··· 856 812 857 813 let value_string = &value.to_string(); 858 814 let value_d128 = D128::from_str(value_string, Context::default()).unwrap(); 859 859 - let number = Number::new(value_d128, unit); 815 815 + let number = Number::with_basic_unit(value_d128, unit); 860 816 861 861 - let result = convert(number, to_unit); 817 817 + let result = convert(number, vec![(to_unit, 1)]); 862 818 let string_result = &result.unwrap().value.to_string(); 863 819 let float_result = f64::from_str(string_result).unwrap(); 864 820 ··· 970 926 assert_float_eq!(convert_test(1024.0, Zebibyte, Yobibyte), 1.0); 971 927 972 928 assert_float_eq!(convert_test(1000.0, BitsPerSecond, KilobitsPerSecond), 1.0); 973 973 - assert_float_eq!(convert_test(1000.0, KilobitsPerSecond, MegabitsPerSecond), 1.0); 974 974 - assert_float_eq!(convert_test(1000.0, MegabitsPerSecond, GigabitsPerSecond), 1.0); 975 975 - assert_float_eq!(convert_test(1000.0, GigabitsPerSecond, TerabitsPerSecond), 1.0); 976 976 - assert_float_eq!(convert_test(1000.0, TerabitsPerSecond, PetabitsPerSecond), 1.0); 977 977 - assert_float_eq!(convert_test(1000.0, PetabitsPerSecond, ExabitsPerSecond), 1.0); 978 978 - assert_float_eq!(convert_test(1000.0, ExabitsPerSecond, ZettabitsPerSecond), 1.0); 979 979 - assert_float_eq!(convert_test(1000.0, ZettabitsPerSecond, YottabitsPerSecond), 1.0); 929 929 + assert_float_eq!( 930 930 + convert_test(1000.0, KilobitsPerSecond, MegabitsPerSecond), 931 931 + 1.0 932 932 + ); 933 933 + assert_float_eq!( 934 934 + convert_test(1000.0, MegabitsPerSecond, GigabitsPerSecond), 935 935 + 1.0 936 936 + ); 937 937 + assert_float_eq!( 938 938 + convert_test(1000.0, GigabitsPerSecond, TerabitsPerSecond), 939 939 + 1.0 940 940 + ); 941 941 + assert_float_eq!( 942 942 + convert_test(1000.0, TerabitsPerSecond, PetabitsPerSecond), 943 943 + 1.0 944 944 + ); 945 945 + assert_float_eq!( 946 946 + convert_test(1000.0, PetabitsPerSecond, ExabitsPerSecond), 947 947 + 1.0 948 948 + ); 949 949 + assert_float_eq!( 950 950 + convert_test(1000.0, ExabitsPerSecond, ZettabitsPerSecond), 951 951 + 1.0 952 952 + ); 953 953 + assert_float_eq!( 954 954 + convert_test(1000.0, ZettabitsPerSecond, YottabitsPerSecond), 955 955 + 1.0 956 956 + ); 980 957 assert_float_eq!(convert_test(1024.0, BitsPerSecond, KibibitsPerSecond), 1.0); 981 981 - assert_float_eq!(convert_test(1024.0, KibibitsPerSecond, MebibitsPerSecond), 1.0); 982 982 - assert_float_eq!(convert_test(1024.0, MebibitsPerSecond, GibibitsPerSecond), 1.0); 983 983 - assert_float_eq!(convert_test(1024.0, GibibitsPerSecond, TebibitsPerSecond), 1.0); 984 984 - assert_float_eq!(convert_test(1024.0, TebibitsPerSecond, PebibitsPerSecond), 1.0); 985 985 - assert_float_eq!(convert_test(1024.0, PebibitsPerSecond, ExbibitsPerSecond), 1.0); 986 986 - assert_float_eq!(convert_test(1024.0, ExbibitsPerSecond, ZebibitsPerSecond), 1.0); 987 987 - assert_float_eq!(convert_test(1024.0, ZebibitsPerSecond, YobibitsPerSecond), 1.0); 958 958 + assert_float_eq!( 959 959 + convert_test(1024.0, KibibitsPerSecond, MebibitsPerSecond), 960 960 + 1.0 961 961 + ); 962 962 + assert_float_eq!( 963 963 + convert_test(1024.0, MebibitsPerSecond, GibibitsPerSecond), 964 964 + 1.0 965 965 + ); 966 966 + assert_float_eq!( 967 967 + convert_test(1024.0, GibibitsPerSecond, TebibitsPerSecond), 968 968 + 1.0 969 969 + ); 970 970 + assert_float_eq!( 971 971 + convert_test(1024.0, TebibitsPerSecond, PebibitsPerSecond), 972 972 + 1.0 973 973 + ); 974 974 + assert_float_eq!( 975 975 + convert_test(1024.0, PebibitsPerSecond, ExbibitsPerSecond), 976 976 + 1.0 977 977 + ); 978 978 + assert_float_eq!( 979 979 + convert_test(1024.0, ExbibitsPerSecond, ZebibitsPerSecond), 980 980 + 1.0 981 981 + ); 982 982 + assert_float_eq!( 983 983 + convert_test(1024.0, ZebibitsPerSecond, YobibitsPerSecond), 984 984 + 1.0 985 985 + ); 988 986 assert_float_eq!(convert_test(8.0, BitsPerSecond, BytesPerSecond), 1.0); 989 989 - assert_float_eq!(convert_test(1000.0, BytesPerSecond, KilobytesPerSecond), 1.0); 990 990 - assert_float_eq!(convert_test(1000.0, KilobytesPerSecond, MegabytesPerSecond), 1.0); 991 991 - assert_float_eq!(convert_test(1000.0, MegabytesPerSecond, GigabytesPerSecond), 1.0); 992 992 - assert_float_eq!(convert_test(1000.0, GigabytesPerSecond, TerabytesPerSecond), 1.0); 993 993 - assert_float_eq!(convert_test(1000.0, TerabytesPerSecond, PetabytesPerSecond), 1.0); 994 994 - assert_float_eq!(convert_test(1000.0, PetabytesPerSecond, ExabytesPerSecond), 1.0); 995 995 - assert_float_eq!(convert_test(1000.0, ExabytesPerSecond, ZettabytesPerSecond), 1.0); 996 996 - assert_float_eq!(convert_test(1000.0, ZettabytesPerSecond, YottabytesPerSecond), 1.0); 997 997 - assert_float_eq!(convert_test(1024.0, KibibytesPerSecond, MebibytesPerSecond), 1.0); 998 998 - assert_float_eq!(convert_test(1024.0, MebibytesPerSecond, GibibytesPerSecond), 1.0); 999 999 - assert_float_eq!(convert_test(1024.0, GibibytesPerSecond, TebibytesPerSecond), 1.0); 1000 1000 - assert_float_eq!(convert_test(1024.0, TebibytesPerSecond, PebibytesPerSecond), 1.0); 1001 1001 - assert_float_eq!(convert_test(1024.0, PebibytesPerSecond, ExbibytesPerSecond), 1.0); 1002 1002 - assert_float_eq!(convert_test(1024.0, ExbibytesPerSecond, ZebibytesPerSecond), 1.0); 1003 1003 - assert_float_eq!(convert_test(1024.0, ZebibytesPerSecond, YobibytesPerSecond), 1.0); 987 987 + assert_float_eq!( 988 988 + convert_test(1000.0, BytesPerSecond, KilobytesPerSecond), 989 989 + 1.0 990 990 + ); 991 991 + assert_float_eq!( 992 992 + convert_test(1000.0, KilobytesPerSecond, MegabytesPerSecond), 993 993 + 1.0 994 994 + ); 995 995 + assert_float_eq!( 996 996 + convert_test(1000.0, MegabytesPerSecond, GigabytesPerSecond), 997 997 + 1.0 998 998 + ); 999 999 + assert_float_eq!( 1000 1000 + convert_test(1000.0, GigabytesPerSecond, TerabytesPerSecond), 1001 1001 + 1.0 1002 1002 + ); 1003 1003 + assert_float_eq!( 1004 1004 + convert_test(1000.0, TerabytesPerSecond, PetabytesPerSecond), 1005 1005 + 1.0 1006 1006 + ); 1007 1007 + assert_float_eq!( 1008 1008 + convert_test(1000.0, PetabytesPerSecond, ExabytesPerSecond), 1009 1009 + 1.0 1010 1010 + ); 1011 1011 + assert_float_eq!( 1012 1012 + convert_test(1000.0, ExabytesPerSecond, ZettabytesPerSecond), 1013 1013 + 1.0 1014 1014 + ); 1015 1015 + assert_float_eq!( 1016 1016 + convert_test(1000.0, ZettabytesPerSecond, YottabytesPerSecond), 1017 1017 + 1.0 1018 1018 + ); 1019 1019 + assert_float_eq!( 1020 1020 + convert_test(1024.0, KibibytesPerSecond, MebibytesPerSecond), 1021 1021 + 1.0 1022 1022 + ); 1023 1023 + assert_float_eq!( 1024 1024 + convert_test(1024.0, MebibytesPerSecond, GibibytesPerSecond), 1025 1025 + 1.0 1026 1026 + ); 1027 1027 + assert_float_eq!( 1028 1028 + convert_test(1024.0, GibibytesPerSecond, TebibytesPerSecond), 1029 1029 + 1.0 1030 1030 + ); 1031 1031 + assert_float_eq!( 1032 1032 + convert_test(1024.0, TebibytesPerSecond, PebibytesPerSecond), 1033 1033 + 1.0 1034 1034 + ); 1035 1035 + assert_float_eq!( 1036 1036 + convert_test(1024.0, PebibytesPerSecond, ExbibytesPerSecond), 1037 1037 + 1.0 1038 1038 + ); 1039 1039 + assert_float_eq!( 1040 1040 + convert_test(1024.0, ExbibytesPerSecond, ZebibytesPerSecond), 1041 1041 + 1.0 1042 1042 + ); 1043 1043 + assert_float_eq!( 1044 1044 + convert_test(1024.0, ZebibytesPerSecond, YobibytesPerSecond), 1045 1045 + 1.0 1046 1046 + ); 1004 1047 1005 1048 assert_float_eq!(convert_test(1000.0, Flop, KiloFlop), 1.0); 1006 1049 assert_float_eq!(convert_test(1000.0, KiloFlop, MegaFlop), 1.0); ··· 1014 1057 assert_float_eq!(convert_test(1000.0, RonnaFlop, QuettaFlop), 1.0); 1015 1058 1016 1059 assert_float_eq!(convert_test(1000.0, FlopPerSecond, KiloFlopPerSecond), 1.0); 1017 1017 - assert_float_eq!(convert_test(1000.0, KiloFlopPerSecond, MegaFlopPerSecond), 1.0); 1018 1018 - assert_float_eq!(convert_test(1000.0, MegaFlopPerSecond, GigaFlopPerSecond), 1.0); 1019 1019 - assert_float_eq!(convert_test(1000.0, GigaFlopPerSecond, TeraFlopPerSecond), 1.0); 1020 1020 - assert_float_eq!(convert_test(1000.0, TeraFlopPerSecond, PetaFlopPerSecond), 1.0); 1021 1021 - assert_float_eq!(convert_test(1000.0, PetaFlopPerSecond, ExaFlopPerSecond), 1.0); 1022 1022 - assert_float_eq!(convert_test(1000.0, ExaFlopPerSecond, ZettaFlopPerSecond), 1.0); 1023 1023 - assert_float_eq!(convert_test(1000.0, ZettaFlopPerSecond, YottaFlopPerSecond), 1.0); 1024 1024 - assert_float_eq!(convert_test(1000.0, YottaFlopPerSecond, RonnaFlopPerSecond), 1.0); 1025 1025 - assert_float_eq!(convert_test(1000.0, RonnaFlopPerSecond, QuettaFlopPerSecond), 1.0); 1060 1060 + assert_float_eq!( 1061 1061 + convert_test(1000.0, KiloFlopPerSecond, MegaFlopPerSecond), 1062 1062 + 1.0 1063 1063 + ); 1064 1064 + assert_float_eq!( 1065 1065 + convert_test(1000.0, MegaFlopPerSecond, GigaFlopPerSecond), 1066 1066 + 1.0 1067 1067 + ); 1068 1068 + assert_float_eq!( 1069 1069 + convert_test(1000.0, GigaFlopPerSecond, TeraFlopPerSecond), 1070 1070 + 1.0 1071 1071 + ); 1072 1072 + assert_float_eq!( 1073 1073 + convert_test(1000.0, TeraFlopPerSecond, PetaFlopPerSecond), 1074 1074 + 1.0 1075 1075 + ); 1076 1076 + assert_float_eq!( 1077 1077 + convert_test(1000.0, PetaFlopPerSecond, ExaFlopPerSecond), 1078 1078 + 1.0 1079 1079 + ); 1080 1080 + assert_float_eq!( 1081 1081 + convert_test(1000.0, ExaFlopPerSecond, ZettaFlopPerSecond), 1082 1082 + 1.0 1083 1083 + ); 1084 1084 + assert_float_eq!( 1085 1085 + convert_test(1000.0, ZettaFlopPerSecond, YottaFlopPerSecond), 1086 1086 + 1.0 1087 1087 + ); 1088 1088 + assert_float_eq!( 1089 1089 + convert_test(1000.0, YottaFlopPerSecond, RonnaFlopPerSecond), 1090 1090 + 1.0 1091 1091 + ); 1092 1092 + assert_float_eq!( 1093 1093 + convert_test(1000.0, RonnaFlopPerSecond, QuettaFlopPerSecond), 1094 1094 + 1.0 1095 1095 + ); 1026 1096 1027 1097 assert_float_eq!(convert_test(1000.0, Millijoule, Joule), 1.0); 1028 1098 assert_float_eq!(convert_test(1000.0, Joule, Kilojoule), 1.0); ··· 1046 1116 assert_float_eq!(convert_test(1000.0, Megawatt, Gigawatt), 1.0); 1047 1117 assert_float_eq!(convert_test(1000.0, Gigawatt, Terawatt), 1.0); 1048 1118 assert_float_eq!(convert_test(1000.0, Terawatt, Petawatt), 1.0); 1049 1049 - assert_float_eq!(convert_test(17.584264210333, Watt, BritishThermalUnitsPerMinute), 1.0); 1050 1050 - assert_float_eq!(convert_test(59.999999999999317571673374406441452784, BritishThermalUnitsPerHour, BritishThermalUnitsPerMinute), 1.0); 1119 1119 + assert_float_eq!( 1120 1120 + convert_test(17.584264210333, Watt, BritishThermalUnitsPerMinute), 1121 1121 + 1.0 1122 1122 + ); 1123 1123 + assert_float_eq!( 1124 1124 + convert_test( 1125 1125 + 59.999999999999317571673374406441452784, 1126 1126 + BritishThermalUnitsPerHour, 1127 1127 + BritishThermalUnitsPerMinute 1128 1128 + ), 1129 1129 + 1.0 1130 1130 + ); 1051 1131 assert_float_eq!(convert_test(745.6998715822702, Watt, Horsepower), 1.0); 1052 1132 assert_float_eq!(convert_test(735.49875, Watt, MetricHorsepower), 1.0); 1053 1133 ··· 1066 1146 assert_float_eq!(convert_test(100.0, Pascal, Millibar), 1.0); 1067 1147 assert_float_eq!(convert_test(1000.0, Millibar, Bar), 1.0); 1068 1148 assert_float_eq!(convert_test(3386.389, Pascal, InchOfMercury), 1.0); 1069 1069 - assert_float_eq!(convert_test(6894.757293168361, Pascal, PoundsPerSquareInch), 1.0); 1149 1149 + assert_float_eq!( 1150 1150 + convert_test(6894.757293168361, Pascal, PoundsPerSquareInch), 1151 1151 + 1.0 1152 1152 + ); 1070 1153 assert_float_eq!(convert_test(133.3223684210526, Pascal, Torr), 1.0); 1071 1154 1072 1155 assert_float_eq!(convert_test(1000.0, Hertz, Kilohertz), 1.0); ··· 1076 1159 assert_float_eq!(convert_test(1000.0, Terahertz, Petahertz), 1.0); 1077 1160 assert_float_eq!(convert_test(60.0, Hertz, RevolutionsPerMinute), 1.0); 1078 1161 1079 1079 - assert_float_eq!(convert_test(3.6, KilometersPerHour, MetersPerSecond), 1.0); 1162 1162 + // assert_float_eq!(convert_test(3.6, KilometersPerHour, MetersPerSecond), 1.0); 1080 1163 assert_float_eq!(convert_test(0.3048, MetersPerSecond, FeetPerSecond), 1.0); 1081 1081 - assert_float_eq!(convert_test(1.609344, KilometersPerHour, MilesPerHour), 1.0); 1082 1082 - assert_float_eq!(convert_test(1.852, KilometersPerHour, Knot), 1.0); 1164 1164 + // assert_float_eq!(convert_test(1.609344, KilometersPerHour, MilesPerHour), 1.0); 1165 1165 + // assert_float_eq!(convert_test(1.852, KilometersPerHour, Knot), 1.0); 1083 1166 1084 1167 assert_float_eq!(convert_test(274.15, Kelvin, Celsius), 1.0); 1085 1168 assert_float_eq!(convert_test(300.0, Kelvin, Fahrenheit), 80.33); ··· 1087 1170 assert_float_eq!(convert_test(-15.0, Celsius, Fahrenheit), 5.0); 1088 1171 assert_float_eq!(convert_test(80.33, Fahrenheit, Kelvin), 300.0); 1089 1172 assert_float_eq!(convert_test(5.0, Fahrenheit, Celsius), -15.0); 1173 1173 + } 1174 1174 + 1175 1175 + #[track_caller] 1176 1176 + fn eval_test(a: &str, b: &str) { 1177 1177 + let result_a = crate::eval(a, true, false).unwrap(); 1178 1178 + let result_b = crate::eval(b, true, false).unwrap(); 1179 1179 + assert_eq!(result_a, result_b, "{a} != {b}"); 1180 1180 + } 1181 1181 + #[track_caller] 1182 1182 + fn eval_approx_test(a: &str, b: &str) { 1183 1183 + let result_a = crate::eval(a, true, false).unwrap(); 1184 1184 + let result_b = crate::eval(b, true, false).unwrap(); 1185 1185 + let diff_pct: D128 = result_a.value / result_b.value - 1; 1186 1186 + let diff_pct = diff_pct.abs(); 1187 1187 + assert!(diff_pct <= d!(0.00000001), "{a} !≈ {b}") 1188 1188 + } 1189 1189 + 1190 1190 + #[test] 1191 1191 + fn test_unit_evals() { 1192 1192 + eval_test("3.6km/1h", "3.6 kph"); 1193 1193 + eval_test("0.3048 m/s to ft/s", "1 ft/s"); 1194 1194 + eval_test("1.609344 km/1h to mph", "1 mph"); 1195 1195 + eval_approx_test("1.852 kph to knots", "1 knots"); 1196 1196 + eval_test("120 seconds to minutes", "2 minutes"); 1197 1197 + eval_test("100 cm to m", "1 m"); 1198 1198 + eval_test("1 km2 to m2", "1000000 m2"); 1199 1199 + eval_test("1 liter to ml", "1000 ml"); 1200 1200 + eval_test("1 kg to g", "1000 g"); 1201 1201 + eval_test("1 KB to bytes", "1000 bytes"); 1202 1202 + eval_test("1 MBps to KBps", "1000 KBps"); 1203 1203 + eval_test("1 KFLOP to FLOP", "1000 FLOP"); 1204 1204 + eval_test("1 KFLOPs to FLOPs", "1000 FLOPs"); 1205 1205 + eval_test("1 kWh to Wh", "1000 Wh"); 1206 1206 + eval_test("1 kW to W", "1000 W"); 1207 1207 + eval_test("1000 mA to A", "1 A"); 1208 1208 + eval_test("1000 mΩ to Ω", "1 Ω"); 1209 1209 + eval_test("1000 mV to V", "1 V"); 1210 1210 + eval_test("1 bar to Pa", "100000 Pa"); 1211 1211 + eval_test("1 kHz to Hz", "1000 Hz"); 1212 1212 + eval_approx_test("1 km/h to m/s", "0.27777777777777777777 m/s"); 1213 1213 + eval_test("0 C to K", "273.15 K"); 1214 1214 + eval_test("8 megabytes per second * 1 minute", "480mb"); 1215 1215 + eval_test("8 megaFLOP per second * 1 minute", "480megaFLOP"); 1090 1216 } 1091 1217 }