dimensional_quantity

Dimensional quantity: checking dimensions of physical quantities in compile time using generic const expressions

This crate is experimental and uses unstable generic_const_exprs feature and can only be compiled with nightly toolchain.
If you need a stable solution, please check excellent dimensioned and uom crates.
The only implemented underlying storage types are f64 and f32.

To use this crate, you need to enable generic_const_exprs feature in your crate:

#![feature(generic_const_exprs)]

and build it with nightly by using cargo +nightly:

bash cargo +nightly build

or by adding rust-toolchain.toml file with the following content to your project toml [toolchain] channel = "nightly"

and add this to your Cargo.toml

toml [dependencies] dimensional_quantity = "0.0.1"

Here you will find:

Examples

Creating dimensional quantities from f64

```rust

![feature(genericconstexprs)]

use dimensionalquantity::si::extended::f64::quantities::{Velocity}; use dimensionalquantity::si::extended::f64::unitsofmeasure::velocity::{MILLIMETERPERSECOND};

// This will create velocity of 10 m/s, default units are SI units let v1: Velocity = Velocity::new(10.0); // This method is constant and works also at compile time: const SPEEDOFSOUND: Velocity = Velocity::new(343.0);

// Various units of length are available at // dimensionalquantity::si::extended::f64::unitsofmeasure::* // Units are just constant dimensional quantities // For example, MILLIMETER unit is defined as // pub const MILLIMETER: Length = Length::new(1.0E-3); // One way is using newwithunit method: let v2: Velocity = Velocity::newwithunit(10000.0, MILLIMETERPERSECOND); // Another is just multiplying f64 with unit: let v3: Velocity = 10000.0 * MILLIMETERPER_SECOND;

// Any of the above methods lead to the same result: asserteq!(v1, v2); asserteq!(v1, v3); ```

Converting dimensional quantities back to f64

```rust use dimensionalquantity::si::extended::f64::quantities::{Velocity}; use dimensionalquantity::si::extended::f64::unitsofmeasure::velocity::{MILLIMETERPERSECOND};

// Getting f64 value of dimensional quantity in SI units: // Velocity of 10 m/s let v1: Velocity = Velocity::new(10.0); // Velocity of 343 m/s const SPEEDOFSOUND: Velocity = Velocity::new(343.0);

let v1valueissiunits = v1.getwithsiunit(); // also possible at compile time: const SPEEDOFSOUNDINSIUNITS:f64 = SPEEDOFSOUND.getwithsi_unit();

asserteq!(SPEEDOFSOUNDINSIUNITS, 343.0); asserteq!(v1valueissi_units, 10.0);

// Getting f64 value of dimensional quantity in arbitrary units is possible: let v1valueismmpersecond = v1.getwithunit(MILLIMETERPERSECOND); asserteq!(v1valueismmpersecond, 10000.0); ```

Mathematical operations with dimensional quantities

```rust

![feature(genericconstexprs)]

use dimensionalquantity::si::extended::f64::quantities::{Area, Energy, Length, Mass, ReciprocalLength, Velocity}; use dimensionalquantity::si::extended::f64::unitsofmeasure::length::{METER, MICROMETER}; use dimensionalquantity::si::extended::f64::unitsofmeasure::reciprocallength::{RECIPROCALCENTIMETER}; use std::f64::consts::PI; let width: Length = 5.0 * METER; let height: Length = 8.0 * METER; // Quantities can be multiplied or divided by f64 floating numbers, // resulting in quantities of same dimension let doubleheight: Length = height * 2.0; let half_width = width / 2.0;

asserteq!(doubleheight, Length::new(16.0)); asserteq!(halfwidth, Length::new(2.5));

// Dividing f64 by dimensional quantity returns reciprocal quantity: let redlightwavelength: Length = 0.65 * MICROMETER; let redlightk: ReciprocalLength = 2.0 * PI / redlightwavelength; let redlightkinreciprocalcm = redlightk.getwithunit(RECIPROCALCENTIMETER);

asserteq!(redlightkinreciprocalcm, 96664.38934122439); // Most quantities of same dimension (except ones containing ThermodynamicTemperatures, // that will be discussed below) can be added or subtracted:

let perimeter: Length = 2.0 * (width + height); // AddAssign and SubAssign operators are supported let mut widthminusheight = Length::new(0.0); widthminusheight += width; widthminusheight -= height;

assert_eq!(perimeter, Length::new(26.0));

// Dimensional quantities can be multiplied and divided: let area1: Area = width * height; let area2: Area = halfwidth * doubleheight; asserteq!(area1, area2); let height1 :Length = area1 / width; asserteq!(height_1, height);

// Dimensional quantities can also be raised to an integer power during compile time let v: Velocity = Velocity::new(10.0); let m: Mass = Mass::new(5.0); // 5 kg let e: Energy = m * v.powi::<2>() / 2.0; assert_eq!(e, Energy::new(250.0)); ```

Attempting to add, subtract, or assign quantities with mismatching dimensions will results in compile-time error:

```compile_fail

![feature(genericconstexprs)]

use dimensional_quantity::si::extended::{Area, Length};

let length: Length = Length::new(10.0); let area: Area = length.powi<2>(); // Type mismatch: can not add Length and Area: let fail1 = length + area; // Type mismatch: can not subtract Area from Length: let fail2 = length - area; // Type mismatch: can not assign Area to Length: let fail_3: Length = area; ```

Creating new quantities and tests

If some quantity or unit are not implemented in predefined dimensional quantities and predefined units of measure, then new quantity and units can be defined:

```rust

![feature(genericconstexprs)]

use dimensionalquantity::si::extended::f64::quantities::{Information, Volume}; use dimensionalquantity::si::extended::f64::Quantity; // New quantity: amount of information per unit of volume, standard unit of measure: Bit per cubic meter, B ⋅ m^-3: pub type VolumetricInformationDensity = Quantity< -3, // Length 0, // Mass 0, // Time 0, // ElectricCurrent 0, // ThermodynamicTemperature 0, // AmountOfSubstance 0, // LuminousIntensity 0, // TemperatureInterval 0, // Angle 1, // Information

;

pub const GIGABITPERCUBICMETER: VolumetricInformationDensity = VolumetricInformationDensity::new(1.0E9); let informationdensity1: VolumetricInformationDensity = 5.0 * GIGABITPERCUBICMETER; let informationdensity2: VolumetricInformationDensity = Information::new(5.0E9) / Volume::new(1.0); asserteq!(informationdensity1, informationdensity_2); ```

Definition of quantities and units of measure

Quantities and corresponding units are defined at src/si/quantities_definition/*toml files.

For example, definition of Area quantity is: ```toml name = "Area" symbol = "Area" snakecasename = "area" shortdimformula = "L²" longdimformula = "Length²" unitsformula = "m²" [dimensions] length = 2 mass = 0 time = 0 electriccurrent = 0 thermodynamictemperature = 0 temperatureinterval = 0 amountofsubstance = 0 luminous_intensity = 0 angle = 0 information = 0

[units.SQUARE_METER] multiplier = "1.0E0" symbol = "m²" singular = "square meter" plural = "square meters"

[units.SQUARECENTIMETER] multiplier = "1.0E-4" symbol = "cm²" singular = "square centimeter" plural = "square centimeters" ```

Licence

Licensed under either of Apache License, Version 2.0 or MIT license (LICENSE-MIT or https://opensource.org/licenses/MIT) at your option.

License: MIT OR Apache-2.0