calculation + conversion
cpc parses and evaluates strings of math, with support for units and conversion. 128-bit decimal floating points are used for high accuracy.
cpc lets you mix units, so for example 1 km - 1m results in Number { value: 999, unit: Meter }.
To install the CLI using cargo:
cargo install cpc
To install the CLI directly, grab the appropriate binary from cpc's Releases page on GitHub, then place it wherever you normally place binaries on your OS (On Windows, you may need to edit your PATH variable or something).
cpc '20c to f'
If you installed the binary somewhere that doesn't make binaries global, you would need to specify the path: ```sh /usr/local/bin/custom/cpc '10+10'
./cpc '1" in cm' ```
To install the library as a Rust dependency, add cpc to your Cargo.toml like so:
toml
[dependencies]
cpc = "1.*"
```rust use cpc::{eval}; use cpc::units::Unit;
match eval("3m + 1cm", true, Unit::Celcius, false) { Ok(answer) => { // answer: Number { value: 301, unit: Unit::Centimeter } println!("Evaluated value: {} {:?}", answer.value, answer.unit) }, Err(e) => { println!("{}", e) } } ```
``` 3 + 4 * 2
8 % 3
(4 + 1)km to light years
10m/2s * 5 trillion s
1 lightyear * 0.001mm in km2
1m/s + 1mi/h in kilometers per h
round(sqrt(2)^4)! liters
10% of abs(sin(pi)) horsepower to watts ```
cpc Uses 128-bit Decimal Floating Point (d128) numbers instead of Binary Coded Decimals for better accuracy. The result cpc gives will still not always be 100% accurate. I would recommend rounding the result to 20 decimals or less.
It's pretty fast and scales well. In my case, eval() usually runs under 0.1ms. The biggest performance hit is functions like log(). log(12345) evaluates in 0.12ms, and log(e) in 0.25ms.
To see how fast it is, you can pass the --debug flag in CLI, or the debug argument to eval().
cpc returns Results with basic strings as errors. Just to be safe, you may want to handle panics (You can do that using std::panic::catch_unwind).
Install Rust. This project was built in Rust 1.45.
Run cpc with a CLI argument as input:
cargo run -- '100ms to s'
Run with debugging, which shows some extra logs:
cargo run -- '100ms to s' --debug
Run tests:
cargo test
Build:
cargo build
In src/units.rs, units are specified like this:
```rs
pub enum UnitType {
Time,
// etc
}
// ...
create_units!( Nanosecond: (Time, d128!(1)), Microsecond: (Time, d128!(1000)), // etc ) ```
The number associated with a unit is it's "weight". For example, if a second's weight is 1, then a minute's weight is 60.
I have found translatorscafe.com and calculateme.com to be good websites for unit conversion. Wikipedia is worth looking at as well.
Make sure to also add a test for each unit. The tests look like this:
rs
assert_eq!(convert_test(1000.0, Meter, Kilometer), 1.0);
Basically, 1000 Meter == 1 Kilometer.
Text is turned into tokens (some of which are units) in lexer.rs. Here's one example:
rs
// ...
match string {
"h" | "hr" | "hrs" | "hour" | "hours" => tokens.push(Token::Unit(Hour)),
// etc
}
// ...
Nice list of units: https://support.google.com/websearch/answer/3284611 - Currency: How would you go about dynamically updating the weights? - Fuel consumption - Data transfer rate - Color codes - Force - Roman numerals - Angles - Flow rate
cross:
cargo install cross
sh
cross build --release --target x86_64-apple-darwin && cross build --release --target x86_64-unknown-linux-musl && cross build --release --target x86_64-pc-windows-gnu
x86_64-apple-darwin only works on macOScross supportscross build in parallel, you might get a cargo not found error
The compiled binaries will now be available inside target/<target>/release/. The filename will be either cpc or cpc.exe.CHANGELOG.mdCargo.toml and run cargo checkcargo testv0.0.0cargo login and following the instructions
cargo publish --dry-run
cargo publish
cpc-v1.0.0-darwin-x64