cmn 0.0.6

What is CMN?

CMN gives you accurate, well-documented mathematical and physical constants as compile-time const values in Rust. Every constant resolves at compile time with zero runtime allocation.

One line to install. Zero configuration. 295 tests. 100% code coverage.

cargo add cmn

Why CMN?

How CMN compares to other constants crates

physical_constants has the most values but is GPL-3.0 — incompatible with MIT/Apache projects. natural_constants spans the most disciplines but is 29% documented and stale since 2022. CMN is the only crate that combines constants, typed runtime lookup, utility macros, and a word list under a permissive license with 100% test coverage.

Install

Add to Cargo.toml:

[dependencies]
cmn = "0.0.6"

Requires Rust 1.72+. Works on macOS, Linux, and Windows.

Quick Start

Constants (compile-time)

use cmn::constants::{PI, TAU, EULER, SQRT2};

fn main() {
    println!("PI    = {PI}");
    println!("TAU   = {TAU}");
    println!("e     = {EULER}");
    println!("sqrt2 = {SQRT2}");
}

Constants (runtime lookup)

use cmn::constants::{Constants, ConstantValue};

let constants = Constants::new();
if let Some(ConstantValue::Float(pi)) = constants.get_value("PI") {
    println!("PI = {pi}");
}

Macros

use cmn::{cmn_max, cmn_min, cmn_in_range, cmn_vec};

let max = cmn_max!(3, 7, 2);       // 7
let min = cmn_min!(3, 7, 2);       // 2
let ok  = cmn_in_range!(5, 0, 10); // true
let v   = cmn_vec!(1, 2, 3);       // Vec<i32>

Word List

use cmn::Words;

let words = Words::default();
println!("{} words loaded", words.count());
println!("First: {}", words.words_list()[0]); // "aboard"

Datetime

use cmn::datetime::DateTime;

let dt = DateTime::parse("2026-04-05T14:30:00Z").unwrap();
assert_eq!(dt.year(), 2026);
assert_eq!(dt.to_iso8601(), "2026-04-05T14:30:00Z");

// Duration between two datetimes
let dt2 = DateTime::parse("2026-04-05T16:30:00Z").unwrap();
let dur = dt2.duration_since(&dt);
assert_eq!(dur.whole_hours(), 2);

// Relative time formatting
let rel = dt.relative_to(&dt2);
assert_eq!(rel, "2 hours ago");

Available Constants

Mathematical — Core

Mathematical — Logarithmic & Pi Fractions

Physical — Fundamental

Physical — Electromagnetic & Vacuum

Physical — Particles & Thermodynamics

Cryptographic & Utility

Full API reference: docs.rs/cmn

Architecture

graph LR
    subgraph "cmn crate"
        B["constants.rs<br/>121 const values<br/>Constants lookup API"]
        C["words.rs<br/>Words HashSet<br/>WORD_LIST dictionary"]
        D["macros.rs<br/>14 utility macros"]
        A["lib.rs<br/>Common struct<br/>JSON serde bridge"]
    end

    A --> B
    A --> C
    A --> D

    U["Your Code"] --> B
    U --> C
    U --> D
    U --> A

FAQ

How accurate are the constants? Mathematical constants use std::f64::consts where available (PI, E, TAU, SQRT2). Physical constants are sourced from CODATA 2018 recommended values. All values are validated by 295 tests including mathematical identity checks (e.g., SQRT2^2 == 2, R == k_B * N_A).

Does CMN support no_std? Yes. Disable default features to get all 121 const values and 14 macros with zero dependencies:

cmn = { version = "0.0.6", default-features = false }

The Constants runtime API, Words, and Common structs require the std feature (enabled by default).

Does CMN compile to WASM? Yes. cargo build --target wasm32-unknown-unknown --no-default-features compiles cleanly.

What is the MSRV? Rust 1.72. Tested on stable. No nightly features required.

How does CMN compare to other Rust constants crates? physical_constants has 354 values but is GPL-3.0 — incompatible with MIT/Apache projects. natural_constants covers more disciplines but is only 29% documented and unmaintained since 2022. std::f64::consts provides 11 math constants with no physical or cryptographic values. CMN is the only crate combining constants, typed runtime lookup, utility macros, and a word list under a permissive license with 100% test coverage. See the comparison table above.

Development

Prerequisites

Build, Test, Verify

git clone https://github.com/sebastienrousseau/cmn.git
cd cmn
cargo build        # Compile
cargo test         # 295 tests, 100% coverage
cargo clippy       # Zero warnings
cargo fmt --check  # Verify formatting
cargo doc --open   # Browse API docs locally

Run Example

cargo run --example cmn

Run Benchmarks

cargo bench

Troubleshooting

Contributing

See CONTRIBUTING.md for signed-commit setup and PR guidelines. See CHANGELOG.md for version history.

License

Dual-licensed under Apache 2.0 or MIT, at your option.

Built by Sebastien Rousseau.