use std::fmt;
pub const BASE_DIMENSION_COUNT: usize = 7;
pub const BASE_DIMENSIONS: [BaseDimension; BASE_DIMENSION_COUNT] = [
BaseDimension::Length,
BaseDimension::Mass,
BaseDimension::Time,
BaseDimension::ElectricCurrent,
BaseDimension::Temperature,
BaseDimension::AmountOfSubstance,
BaseDimension::LuminousIntensity,
];
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum BaseDimension {
Length,
Mass,
Time,
ElectricCurrent,
Temperature,
AmountOfSubstance,
LuminousIntensity,
}
impl BaseDimension {
pub fn symbol(self) -> &'static str {
match self {
BaseDimension::Length => "m",
BaseDimension::Mass => "kg",
BaseDimension::Time => "s",
BaseDimension::ElectricCurrent => "A",
BaseDimension::Temperature => "K",
BaseDimension::AmountOfSubstance => "mol",
BaseDimension::LuminousIntensity => "cd",
}
}
pub fn index(self) -> usize {
match self {
BaseDimension::Length => 0,
BaseDimension::Mass => 1,
BaseDimension::Time => 2,
BaseDimension::ElectricCurrent => 3,
BaseDimension::Temperature => 4,
BaseDimension::AmountOfSubstance => 5,
BaseDimension::LuminousIntensity => 6,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Dimension {
exps: [i32; BASE_DIMENSION_COUNT],
}
impl Dimension {
pub const DIMENSIONLESS: Dimension = Dimension {
exps: [0; BASE_DIMENSION_COUNT],
};
pub const fn from_exponents(exps: [i32; BASE_DIMENSION_COUNT]) -> Self {
Dimension { exps }
}
pub fn base(base: BaseDimension) -> Self {
let mut exps = [0; BASE_DIMENSION_COUNT];
exps[base.index()] = 1;
Dimension { exps }
}
pub fn exponent(&self, base: BaseDimension) -> i32 {
self.exps[base.index()]
}
pub fn is_dimensionless(&self) -> bool {
self.exps.iter().all(|&e| e == 0)
}
pub fn multiply(&self, other: &Dimension) -> Dimension {
let mut exps = self.exps;
for i in 0..BASE_DIMENSION_COUNT {
exps[i] += other.exps[i];
}
Dimension { exps }
}
pub fn divide(&self, other: &Dimension) -> Dimension {
let mut exps = self.exps;
for i in 0..BASE_DIMENSION_COUNT {
exps[i] -= other.exps[i];
}
Dimension { exps }
}
pub fn powi(&self, n: i32) -> Dimension {
let mut exps = self.exps;
for e in exps.iter_mut() {
*e *= n;
}
Dimension { exps }
}
pub fn reciprocal(&self) -> Dimension {
self.powi(-1)
}
pub fn checked_add(&self, other: &Dimension) -> Result<Dimension, UnitError> {
if self == other {
Ok(*self)
} else {
Err(UnitError::Mismatch {
left: *self,
right: *other,
operation: "add",
})
}
}
pub fn checked_sub(&self, other: &Dimension) -> Result<Dimension, UnitError> {
if self == other {
Ok(*self)
} else {
Err(UnitError::Mismatch {
left: *self,
right: *other,
operation: "subtract",
})
}
}
pub fn checked_compare(&self, other: &Dimension) -> Result<(), UnitError> {
if self == other {
Ok(())
} else {
Err(UnitError::Mismatch {
left: *self,
right: *other,
operation: "compare",
})
}
}
pub fn to_canonical_string(&self) -> String {
let mut numerator: Vec<String> = Vec::new();
let mut denominator: Vec<String> = Vec::new();
for base in BASE_DIMENSIONS {
let e = self.exps[base.index()];
if e > 0 {
numerator.push(factor_string(base.symbol(), e));
} else if e < 0 {
denominator.push(factor_string(base.symbol(), -e));
}
}
if numerator.is_empty() && denominator.is_empty() {
return "1".to_string();
}
let num = if numerator.is_empty() {
"1".to_string()
} else {
numerator.join("*")
};
if denominator.is_empty() {
num
} else {
format!("{}/{}", num, denominator.join("*"))
}
}
}
impl fmt::Display for Dimension {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.to_canonical_string())
}
}
fn factor_string(symbol: &str, exp: i32) -> String {
if exp == 1 {
symbol.to_string()
} else {
format!("{}^{}", symbol, exp)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum UnitError {
Mismatch {
left: Dimension,
right: Dimension,
operation: &'static str,
},
UnknownUnit(String),
ParseError(String),
}
impl fmt::Display for UnitError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
UnitError::Mismatch {
left,
right,
operation,
} => write!(
f,
"unit mismatch: cannot {} `{}` and `{}` (dimensions differ)",
operation, left, right
),
UnitError::UnknownUnit(u) => write!(f, "unknown unit `{}`", u),
UnitError::ParseError(m) => write!(f, "malformed unit annotation: {}", m),
}
}
}
impl std::error::Error for UnitError {}
pub fn lookup_unit(token: &str) -> Result<Dimension, UnitError> {
use BaseDimension::*;
let d = |exps: [i32; BASE_DIMENSION_COUNT]| Dimension::from_exponents(exps);
let dim = match token {
"1" => Dimension::DIMENSIONLESS,
"m" => Dimension::base(Length),
"kg" => Dimension::base(Mass),
"s" => Dimension::base(Time),
"A" => Dimension::base(ElectricCurrent),
"K" => Dimension::base(Temperature),
"mol" => Dimension::base(AmountOfSubstance),
"cd" => Dimension::base(LuminousIntensity),
"Hz" => d([0, 0, -1, 0, 0, 0, 0]),
"N" => d([1, 1, -2, 0, 0, 0, 0]),
"Pa" => d([-1, 1, -2, 0, 0, 0, 0]),
"J" => d([2, 1, -2, 0, 0, 0, 0]),
"W" => d([2, 1, -3, 0, 0, 0, 0]),
"C" => d([0, 0, 1, 1, 0, 0, 0]),
"V" => d([2, 1, -3, -1, 0, 0, 0]),
other => return Err(UnitError::UnknownUnit(other.to_string())),
};
Ok(dim)
}
pub fn parse_unit(input: &str) -> Result<Dimension, UnitError> {
let trimmed = input.trim();
if trimmed.is_empty() {
return Err(UnitError::ParseError("empty unit annotation".to_string()));
}
let tokens = tokenize(trimmed)?;
if tokens.is_empty() {
return Err(UnitError::ParseError("no unit factors found".to_string()));
}
let mut idx = 0usize;
let mut result = Dimension::DIMENSIONLESS;
let (first, next) = parse_factor(&tokens, idx)?;
result = result.multiply(&first);
idx = next;
while idx < tokens.len() {
let op = &tokens[idx];
let sign = match op.as_str() {
"*" => 1,
"/" => -1,
other => {
return Err(UnitError::ParseError(format!(
"expected `*` or `/`, found `{}`",
other
)))
}
};
idx += 1;
let (factor, next) = parse_factor(&tokens, idx)?;
result = if sign == 1 {
result.multiply(&factor)
} else {
result.divide(&factor)
};
idx = next;
}
Ok(result)
}
fn parse_factor(tokens: &[String], idx: usize) -> Result<(Dimension, usize), UnitError> {
let token = tokens.get(idx).ok_or_else(|| {
UnitError::ParseError("expected a unit factor but reached end of input".to_string())
})?;
if token == "*" || token == "/" || token == "^" {
return Err(UnitError::ParseError(format!(
"expected a unit name, found `{}`",
token
)));
}
let mut dim = lookup_unit(token)?;
let mut next = idx + 1;
if next < tokens.len() && tokens[next] == "^" {
let exp_tok = tokens
.get(next + 1)
.ok_or_else(|| UnitError::ParseError("expected an exponent after `^`".to_string()))?;
let exp: i32 = exp_tok
.parse()
.map_err(|_| UnitError::ParseError(format!("invalid exponent `{}`", exp_tok)))?;
dim = dim.powi(exp);
next += 2;
}
Ok((dim, next))
}
fn tokenize(input: &str) -> Result<Vec<String>, UnitError> {
let mut tokens: Vec<String> = Vec::new();
let chars: Vec<char> = input.chars().collect();
let mut i = 0;
while i < chars.len() {
let c = chars[i];
if c.is_whitespace() {
i += 1;
continue;
}
match c {
'*' | '/' | '^' => {
tokens.push(c.to_string());
i += 1;
}
_ if c.is_ascii_alphabetic() => {
let start = i;
while i < chars.len() && chars[i].is_ascii_alphabetic() {
i += 1;
}
tokens.push(chars[start..i].iter().collect());
}
_ if c.is_ascii_digit() || c == '-' => {
let start = i;
if c == '-' {
i += 1;
}
while i < chars.len() && chars[i].is_ascii_digit() {
i += 1;
}
let lit: String = chars[start..i].iter().collect();
if lit == "-" {
return Err(UnitError::ParseError(
"stray `-` with no digits".to_string(),
));
}
tokens.push(lit);
}
other => {
return Err(UnitError::ParseError(format!(
"unexpected character `{}`",
other
)))
}
}
}
Ok(tokens)
}
pub fn canonicalize_unit(input: &str) -> Result<String, UnitError> {
Ok(parse_unit(input)?.to_canonical_string())
}
#[cfg(test)]
mod tests {
use super::*;
use BaseDimension::*;
#[test]
fn dimensionless_is_all_zero() {
assert!(Dimension::DIMENSIONLESS.is_dimensionless());
assert_eq!(Dimension::DIMENSIONLESS.to_canonical_string(), "1");
}
#[test]
fn base_units_round_trip() {
assert_eq!(Dimension::base(Length).to_canonical_string(), "m");
assert_eq!(Dimension::base(Mass).to_canonical_string(), "kg");
assert_eq!(Dimension::base(Time).to_canonical_string(), "s");
assert_eq!(Dimension::base(ElectricCurrent).to_canonical_string(), "A");
assert_eq!(Dimension::base(Temperature).to_canonical_string(), "K");
assert_eq!(
Dimension::base(AmountOfSubstance).to_canonical_string(),
"mol"
);
assert_eq!(
Dimension::base(LuminousIntensity).to_canonical_string(),
"cd"
);
}
#[test]
fn multiply_adds_exponents() {
let area = Dimension::base(Length).multiply(&Dimension::base(Length));
assert_eq!(area.exponent(Length), 2);
assert_eq!(area.to_canonical_string(), "m^2");
}
#[test]
fn divide_subtracts_exponents() {
let velocity = Dimension::base(Length).divide(&Dimension::base(Time));
assert_eq!(velocity.exponent(Length), 1);
assert_eq!(velocity.exponent(Time), -1);
assert_eq!(velocity.to_canonical_string(), "m/s");
}
#[test]
fn acceleration_and_force() {
let accel = Dimension::base(Length).divide(&Dimension::base(Time).powi(2));
assert_eq!(accel.to_canonical_string(), "m/s^2");
let force = Dimension::base(Mass).multiply(&accel);
assert_eq!(force, lookup_unit("N").unwrap());
assert_eq!(force.to_canonical_string(), "m*kg/s^2");
}
#[test]
fn checked_add_same_dimension_ok() {
let a = Dimension::base(Length);
let b = Dimension::base(Length);
assert_eq!(a.checked_add(&b), Ok(Dimension::base(Length)));
}
#[test]
fn checked_add_mismatch_is_error() {
let metre = Dimension::base(Length);
let second = Dimension::base(Time);
let err = metre.checked_add(&second).unwrap_err();
match err {
UnitError::Mismatch {
left,
right,
operation,
} => {
assert_eq!(left, metre);
assert_eq!(right, second);
assert_eq!(operation, "add");
}
other => panic!("expected Mismatch, got {:?}", other),
}
}
#[test]
fn checked_sub_and_compare_mismatch() {
let energy = lookup_unit("J").unwrap();
let power = lookup_unit("W").unwrap();
assert!(energy.checked_sub(&power).is_err());
assert!(energy.checked_compare(&power).is_err());
assert!(energy.checked_compare(&lookup_unit("J").unwrap()).is_ok());
}
#[test]
fn parse_base_and_derived() {
assert_eq!(parse_unit("m").unwrap(), Dimension::base(Length));
assert_eq!(parse_unit("1").unwrap(), Dimension::DIMENSIONLESS);
assert_eq!(parse_unit("N").unwrap(), lookup_unit("N").unwrap());
}
#[test]
fn parse_composite_velocity() {
let v = parse_unit("m/s").unwrap();
assert_eq!(v, Dimension::base(Length).divide(&Dimension::base(Time)));
assert_eq!(v.to_canonical_string(), "m/s");
}
#[test]
fn parse_force_expression() {
let f = parse_unit("kg*m/s^2").unwrap();
assert_eq!(f, lookup_unit("N").unwrap());
}
#[test]
fn parse_negative_exponent_form_equals_slash_form() {
let a = parse_unit("m*s^-1").unwrap();
let b = parse_unit("m/s").unwrap();
assert_eq!(a, b);
assert_eq!(a.to_canonical_string(), b.to_canonical_string());
}
#[test]
fn parse_inverse_time() {
let hz = parse_unit("1/s").unwrap();
assert_eq!(hz, lookup_unit("Hz").unwrap());
assert_eq!(hz.to_canonical_string(), "1/s");
}
#[test]
fn canonicalize_normalizes_spellings() {
assert_eq!(canonicalize_unit("m*s^-1").unwrap(), "m/s");
assert_eq!(canonicalize_unit("kg*m/s^2").unwrap(), "m*kg/s^2");
assert_eq!(canonicalize_unit("m*kg/s^2").unwrap(), "m*kg/s^2");
assert_eq!(canonicalize_unit(" m / s ").unwrap(), "m/s");
}
#[test]
fn unknown_unit_is_error() {
let err = parse_unit("furlong").unwrap_err();
assert!(matches!(err, UnitError::UnknownUnit(u) if u == "furlong"));
}
#[test]
fn malformed_annotations_are_errors() {
assert!(parse_unit("").is_err());
assert!(parse_unit("m/").is_err());
assert!(parse_unit("m^").is_err());
assert!(parse_unit("*s").is_err());
assert!(parse_unit("m s").is_err()); }
#[test]
fn powi_and_reciprocal() {
let area = Dimension::base(Length).powi(2);
assert_eq!(area.to_canonical_string(), "m^2");
let inv_time = Dimension::base(Time).reciprocal();
assert_eq!(inv_time.to_canonical_string(), "1/s");
assert_eq!(inv_time, lookup_unit("Hz").unwrap());
}
#[test]
fn energy_from_named_units_matches_base_composition() {
let joule = lookup_unit("J").unwrap();
let n_times_m = lookup_unit("N").unwrap().multiply(&Dimension::base(Length));
assert_eq!(joule, n_times_m);
let watt = lookup_unit("W").unwrap();
assert_eq!(watt, joule.divide(&Dimension::base(Time)));
}
}