CLI calculator app and library

Peter Goodspeed-Niklaus

Last update: Nov 13, 2022

Related tags

Command-line calc

Overview

`calc`

Yet another CLI calculator. Inspired by the excellent https://github.com/alfredxing/calc.

Installation

With a Rust toolchain in place:

cargo install --force calc

Alternately, you can download a precompiled executable of the most recent release.

Usage

Expression Mode

$ calc "1/(2+(3*(4-5)))"
-1
$ calc "round(12345 / 543)"
23

When non-flag arguments are present, calc interprets them as an expression and evaluates them immediately.

Shell Mode

$ calc
[0]: 1 + 1
2
[1]: 3*(5/(3-4))
-15
[2]: 3*pi**2
29.608813203268074
[3]: @+1
30.608813203268074
[4]: @@@*2
-30
[5]: ln(-1)
NaN

In the absence of non-flag arguments, calc launches a simple shell which just evaluates each line of input.

Reference

Data Types

Every invocation of calc interprets all arguments as a single data type. By default, calc uses f64, but other data types can be chosen by command-line flag:

f64 (default): signed 64-bit floating point operations
u64: unsigned 64-bit integer operations
i64: signed 64-bit integer operations

Note that the data type chosen will restrict the available operators, functions, and constants. For example, trigonometric operations are not available on integers, and bit-shifting operations are not available on floats.

Numeric Input Format

Numbers may contain _ characters at any point. Those symbols are ignored; they are for user convenience and readability only.

calc can handle inputs in several numeric bases.

Un-annotated numbers are assumed to be base 10. Example: 123.45.

Note: this is the only format which is legal for non-integral numbers.
Numbers with a 0b prefix are in base 2. Example: 0b0110_1010.
Numbers with a 0o prefix are in base 8. Example: 0o755.

Note: a leading 0 is not in itself an octal prefix. Example: 0755 equals 0d755.
Numbers with a 0d prefix are in base 10. Example: 1234_5678.
Numbers with a 0x prefix are in base 16. Example: 0xdead_beef.

It is legal to intermix inputs of varying bases.

Numeric Output Format

The output format of an expression can be specified by adding a : symbol followed by a format specifier to the expression.

The format specifier can be anything recognized by the num-runtime-fmt crate.

$ calc -u "0o644 | 0o111 :#o"
0o755
$ calc -u '0o755 & !0o111 :04o'
0644

[0]: 0xab :b 4
1010 1011
[1]: @[0] >>> 4 :x_4
b000_0000_0000_000a
[2]: @ & 0xF :4b
1010

$ calc pi / 3 :v#04.4
0d01.0471

Order of Operations

The following order of operations is used to resolve expressions:

Parentheses ((...))
Unary Prefix Operators (- !)
Shifts and Exponentiation (<< >> <<< >>> **)
Bitwise operations (& | ^)
Multiplication and Division (* / // %)
Addition and Subtraction (+ -)

Operations at the same level of precedence are resolved from left to right.

Unary Prefix Operators

-: Negation
!: Bitwise Not

Infix Operators

+: Addition
-: Subtraction
*: Multiplication
/: Division
//: Truncating Division: divides, truncating all data after the decimal point.
**: Exponentiation
% : Arithmetic remainder
<<: Left Shift
>>: Right Shift
<<<: Wrapping Left Shift (Rotate Left)
>>>: Wrappping Right Shift (Rotate Right)
&: Bitwise And
|: Bitwise Or
^: Bitwise Xor

Functions

abs: Absolute Value
ceil: Smallest integer greater than or equal to the input
floor: Greatest integer less than or equal to the input
round: Nearest integer to the input; halfway cases away from 0.0
sin: Sine
cos: Cosine
tan: Tangent
sinh: Hyperbolic Sine
cosh: Hyperbolic Cosine
tanh: Hyperbolic Tangent
asin: Arcine
acos: Arccosine
atan: Arctangent
asinh: Inverse Hyperbolic Sine
acosh: Inverse Hyperbolic Cosine
atanh: Inverse Hyperbolic Tangent
rad: Convert a number in degrees to radians
dec: Convert a number in radians to degrees
sqrt: Square Root
cbrt: Cube Root
log: Base-10 Logarithm
lg: Base-2 Logarithm
ln: Natural (Base-e) Logarithm
exp: e**x

Trigonometric functions operate on radians.

Constants

e: Euler's Number
pi: Archimedes' Constant
π: Archimedes' Constant

History

In shell mode, calc keeps the results of all expressions in memory until it is quit.

The pseudovariable @ always refers to the result of the previous expression. The pseudovariable @@ always refers to the result of the expression before the previous. Any number of @ symbols can be chained this way.

Simply chaining @ symbols can get cumbersome. The syntax @{N}, where N is an integer, refers to the Nth previous result. @{1} always refers to the result of the previous expression; it is equivalent to @. @{3} refers to the result 3 expressions ago; it is equivalent to @@@.

The pseuaovariable @[0] always refers to the result of the first expression in this shell session. Likewise, @[1] refers to the second, and so on. The shell interface indicates the current expression.

Warnings

No Implicit Multiplication

Implicit multiplication is not supported. Use a multiplication operator such as *.

Floating Point Errors

Floating point operations can compound lossily, and calc makes no special efforts to guard against this kind of error. For example:

$ calc 'sin(rad(45)) - (sqrt(2) / 2)'
-0.00000000000000011102230246251565

Crate Structure

This crate includes both library code and CLI code. The CLI code is all gated behind feature cli; the cli feature is in the default features. This means that the CLI is built by default. However, it is possible to use this crate as a library without building any of the CLI code by including in your Cargo.toml:

[dependencies]
calc = { version = "*", default-features = false }

Comments

twice action when using @ operator at version 0.3.0

my program and OS versions

$calc --version
calc 0.3.0
$lsb_release -a
No LSB modules are available.
Distributor ID:	Ubuntu
Description:	Ubuntu 22.04.1 LTS
Release:	22.04
Codename:	jammy

steps to reproduce 1

$calc --i64
[1]: 528500/100
5285
[2]: @/2
1321
[3]: 5285/2
2642
[4]:
Error: Interrupted

steps to reproduce 2

$calc --u64
[0]: 2+2*2
6
[1]: @*100
60000
[2]: @*-1
operation `-` not implemented for u64
[2]: @*2
2400
[3]: @+1
1202
[4]:
Error: Interrupted

steps to reproduce 3

[0]: 0.1+0.2
.30000000000000004 (skip, because https://0.30000000000000004.com/ )
[1]: @+0.003
.30600000000000005
[2]: @+0.0001
.3032
[3]: 
Error: Interrupted

opened by sv-atoslav 2

Percentage issue
Dear Peter, I am trying to calculate as follows

$ calc.exe 130-20% Error: unexpected EOF 130-20% ^

However other CLI calculators such as Qalc output 104 as expected.
opened by sergeevabc 1

Custom Formatting

It would be nice to support format strings enabling nice output formatting. Did some work on that already, but it turned out to require quite a lot more work than I'm willing to invest for the moment. Storing it here, then removing from the repo until we can implement it later.

README.md

### Numeric Output Format

The output format of an expression can be specified by adding a `:` symbol followed by a format
specifier to the expression.

A format separator consists of several parts, each of which is optional.

- `+`: if present, prefix positive numbers with a `+` sign. Normally, only `-` signs are printed.
- `#`: if present, add a base signifier prefix (`0b`, `0o`, `0d`, or `0x` as appropriate)
- `0`: if present and a width is specified, pads to that width with `0` chars. If not specified, pads with spaces.
- Width: decimal numeric digits not beginning with `0`. If present, attempt to fill this many characters.
- Precision: `.` plus decimal numeric digits. If present, how many digits to display after the decimal point. Ignored for ints.
- Base: one of `b`, `o`, `d`, `x`, for binary, octal, decimal, hexadecimal rational, respectively.

  Default: decimal. The other options are only valid for integer data types.

  Example:

  ```text
  % calc --u64
  [0]: 0o644 | 1 :o
  755
  [1]: 0o755 & (!0 ^ 1) :o
  644
  ```

- Separator: one of `_`, `,`, `s`. Separate the digits into groups with underscores, commas, and spaces respectively.

  Default: no separation.
- Group size: if a separator is specified, how many characters appear in the group.


  Default: 3

  Example:

  ```text
  [2]: 0b0101_1010 >> 1:08bs4
  0010 1101
  [3]: 0xff << 1:04x_2
  01_fe
  ```

  Example with floating point numbers:

  ```text
  $ calc "123*45:,"
  5,535
  ```

render.rs

use lazy_static::lazy_static;
use regex::Regex;
use std::{borrow::Cow, char::ToLowercase, str::FromStr};

lazy_static! {
    static ref OUTPUT_FORMAT_RE: Regex = Regex::new(
        r"(?P<width>[1-9][0-9]*)?(\.(?P<precision>\d+))?(?P<base>[bodx])?(?P<separator>[n_,s])?(?P<group_size>\d+)?"
    ).unwrap();
}

/// A numeric base
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Base {
    Binary,
    Octal,
    Decimal,
    Hexadecimal,
}

impl Default for Base {
    fn default() -> Self {
        Self::Decimal
    }
}

/// Separator between character groups in the output
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Separator {
    None,
    Underscore,
    Comma,
    Space,
}

impl Default for Separator {
    fn default() -> Self {
        Self::None
    }
}

/// Output format
///
/// This controls the displayed representation of the number.
#[derive(Debug, Default)]
pub struct OutputFormat {
    pub width: Option<usize>,
    pub precision: Option<usize>,
    pub base: Base,
    pub separator: Separator,
    pub group_size: Option<usize>,
}

impl FromStr for OutputFormat {
    type Err = ();

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let captures = OUTPUT_FORMAT_RE.captures(s).ok_or(())?;
        let mut format = Self::default();

        if let Some(width) = captures.name("width") {
            format.width = Some(width.as_str().parse().map_err(|_| ())?);
        }
        if let Some(precision) = captures.name("precision") {
            format.precision = Some(precision.as_str().parse().map_err(|_| ())?);
        }
        if let Some(base) = captures.name("base") {
            format.base = match base.as_str() {
                "b" => Base::Binary,
                "o" => Base::Octal,
                "d" => Base::Decimal,
                "x" => Base::Hexadecimal,
                _ => unreachable!("regex ensures we don't hit this branch"),
            };
        }
        if let Some(separator) = captures.name("separator") {
            format.separator = match separator.as_str() {
                "n" => Separator::None,
                "_" => Separator::Underscore,
                "," => Separator::Comma,
                "s" => Separator::Space,
                _ => unreachable!("regex ensures we don't hit this branch"),
            };
        }
        if let Some(group_size) = captures.name("group_size") {
            format.group_size = group_size.as_str().parse().map_err(|_| ())?;
        }

        Ok(format)
    }
}

ast.rs

/// An expression with an output format
pub struct FormattedExpr<'input> {
    pub expr: Expr<'input>,
    pub output_format: OutputFormat,
}

impl<'input> FormattedExpr<'input> {
    /// Decompose this `FormattedExpr` into its component parts.
    pub fn decompose(self) -> (Expr<'input>, OutputFormat) {
        (self.expr, self.output_format)
    }
}

parser.lalrpop

pub FormattedExpr: FormattedExpr<'input> = {
    <expr:Expr> ":" <output_format:r"\+?#?\d*(\.\d+)?[bodx]?[n_,s]?\d*"> =>? Ok(FormattedExpr {
        expr,
        output_format: output_format.parse().map_err(|_| ParseError::User { error: "failed to parse output format" })?,
     }),
    <expr:Expr> => FormattedExpr { expr, output_format: Default::default() },
};

opened by coriolinus 1

Bump regex from 1.4.3 to 1.5.5
Bumps regex from 1.4.3 to 1.5.5.

Changelog

Sourced from regex's changelog.

1.5.5 (2022-03-08)

This releases fixes a security bug in the regex compiler. This bug permits a vector for a denial-of-service attack in cases where the regex being compiled is untrusted. There are no known problems where the regex is itself trusted, including in cases of untrusted haystacks.

SECURITY #GHSA-m5pq-gvj9-9vr8: Fixes a bug in the regex compiler where empty sub-expressions subverted the existing mitigations in place to enforce a size limit on compiled regexes. The Rust Security Response WG published an advisory about this: https://groups.google.com/g/rustlang-security-announcements/c/NcNNL1Jq7Yw

1.5.4 (2021-05-06)

This release fixes another compilation failure when building regex. This time, the fix is for when the pattern feature is enabled, which only works on nightly Rust. CI has been updated to test this case.

[BUG #772](rust-lang/regex#772): Fix build when pattern feature is enabled.

1.5.3 (2021-05-01)

This releases fixes a bug when building regex with only the unicode-perl feature. It turns out that while CI was building this configuration, it wasn't actually failing the overall build on a failed compilation.

[BUG #769](rust-lang/regex#769): Fix build in regex-syntax when only the unicode-perl feature is enabled.

1.5.2 (2021-05-01)

This release fixes a performance bug when Unicode word boundaries are used. Namely, for certain regexes on certain inputs, it's possible for the lazy DFA to stop searching (causing a fallback to a slower engine) when it doesn't actually need to.

[PR #768](rust-lang/regex#768) fixes the bug, which was originally reported in ripgrep#1860.

1.5.1 (2021-04-30)

This is a patch release that fixes a compilation error when the perf-literal feature is not enabled.

... (truncated)

Commits

d130381 1.5.5

ae70b41 security: fix denial-of-service bug in compiler

b92ffd5 cargo: use SPDX license format

f6e52da syntax: fix 'unused' warnings

5197f21 fuzz: do not use inherits in Cargo.toml

3662851 doc: fix typo

63ee669 syntax/doc: fix 'their' typo

d6bc7a4 readme: remove broken badge

bd74660 fuzz: try to fix build issue

bd0a142 readme: fix badges

Additional commits viewable in compare view

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.

Dependabot commands and options

You can trigger Dependabot actions by commenting on this PR:

@dependabot rebase will rebase this PR

@dependabot recreate will recreate this PR, overwriting any edits that have been made to it

@dependabot merge will merge this PR after your CI passes on it

@dependabot squash and merge will squash and merge this PR after your CI passes on it

@dependabot cancel merge will cancel a previously requested merge and block automerging

@dependabot reopen will reopen this PR if it is closed

@dependabot close will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually

@dependabot ignore this major version will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)

@dependabot ignore this minor version will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)

@dependabot ignore this dependency will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

@dependabot use these labels will set the current labels as the default for future PRs for this repo and language

@dependabot use these reviewers will set the current reviewers as the default for future PRs for this repo and language

@dependabot use these assignees will set the current assignees as the default for future PRs for this repo and language

@dependabot use this milestone will set the current milestone as the default for future PRs for this repo and language

You can disable automated security fix PRs for this repo from the Security Alerts page.

dependencies
opened by dependabot[bot] 0
Bump crossbeam-utils from 0.8.1 to 0.8.8
Bumps crossbeam-utils from 0.8.1 to 0.8.8.

Release notes

Sourced from crossbeam-utils's releases.

crossbeam-utils 0.8.8

Fix a bug when unstable loom support is enabled. (#787)

crossbeam-utils 0.8.7

Add AtomicCell<{i*,u*}>::{fetch_max,fetch_min}. (#785)

Add AtomicCell<{i*,u*,bool}>::fetch_nand. (#785)

Fix unsoundness of AtomicCell<{i,u}64> arithmetics on 32-bit targets that support Atomic{I,U}64 (#781)

crossbeam-utils 0.8.6

Re-add AtomicCell<{i,u}64>::{fetch_add,fetch_sub,fetch_and,fetch_or,fetch_xor} that were accidentally removed in ~~0.8.0~~ 0.7.1 on targets that do not support Atomic{I,U}64. (#767)

Re-add AtomicCell<{i,u}128>::{fetch_add,fetch_sub,fetch_and,fetch_or,fetch_xor} that were accidentally removed in ~~0.8.0~~ 0.7.1. (#767)

crossbeam-utils 0.8.5

Add AtomicCell::fetch_update (#704)

Support targets that do not have atomic CAS on stable Rust (#698)

crossbeam-utils 0.8.4

Bump loom dependency to version 0.5. (#686)

crossbeam-utils 0.8.3

Make loom dependency optional. (#666)

crossbeam-utils 0.8.2

Deprecate AtomicCell::compare_and_swap. Use AtomicCell::compare_exchange instead. (#619)

Add Parker::park_deadline. (#563)

Improve implementation of CachePadded. (#636)

Add unstable support for loom. (#487)

Commits

5b4d808 Merge #800

6fa7246 Prepare for the next release

8efcd02 Merge #798

baedeb0 channel: Do not panic on very large timeout

113daf4 Merge #799

5cb7cac Update no_atomic.rs

0081fcc Merge #789 #797

7b2d65f Update to stabilized const_fn_trait_bound

bd75c3c Add force_push to ArrayQueue

b11f1a8 Merge #793

Additional commits viewable in compare view

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.

Dependabot commands and options

You can trigger Dependabot actions by commenting on this PR:

@dependabot rebase will rebase this PR

@dependabot recreate will recreate this PR, overwriting any edits that have been made to it

@dependabot merge will merge this PR after your CI passes on it

@dependabot squash and merge will squash and merge this PR after your CI passes on it

@dependabot cancel merge will cancel a previously requested merge and block automerging

@dependabot reopen will reopen this PR if it is closed

@dependabot close will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually

@dependabot ignore this major version will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)

@dependabot ignore this minor version will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)

@dependabot ignore this dependency will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)

@dependabot use these labels will set the current labels as the default for future PRs for this repo and language

@dependabot use these reviewers will set the current reviewers as the default for future PRs for this repo and language

@dependabot use these assignees will set the current assignees as the default for future PRs for this repo and language

@dependabot use this milestone will set the current milestone as the default for future PRs for this repo and language

You can disable automated security fix PRs for this repo from the Security Alerts page.

dependencies
opened by dependabot[bot] 0
repl mode: set persistent output format

If you're doing a bunch of bit-twiddling, it's tedious to append :09b_4 to every expression. Better to do output :09b_4 and have it automatically apply to every subsequent expression unless changed again.

opened by coriolinus 0

semicolon separation for inline expressions

Use case:

$ calc "load $history_path; history"
[0]: 1+1
2
[1]: 3*pi**2
29.608813203268074
$ calc "load $history_path; @ + 1; save $history_path"
30.608813203268074

opened by coriolinus 0

Non-arithmetic commands
The parser should be able to evaluate commands like help, help FOO, exit, etc. eval_and_print should be able to delegate to appropriate command handlers in that case.

Minimal commands necessary for completion:

[ ] help: enumerate supported functions and operators and a basic syntax description

[ ] quit: exit cleanly. Alternative to ctrl-c.

Bonus objectives:

[ ] help FOO: for any FOO in supported functions and operators, emit a description of what that operation does.

[ ] save PATH: save history (input expressions and results) to PATH

[ ] load PATH: load history (input expressions and results) from PATH

[ ] history: replay entire history
opened by coriolinus 0
Choose backing type at evaluation time, not in the CLI

It should be possible for us to parse evaluation type metadata in parallel with the expression itself and use that instead of a CLI switch. This will improve the usability in shell applications.

opened by coriolinus 1
Add rational support
We should allow both fixed and arbitrary precision rational support.

rat64: signed 64-bit rational operations building on the num_rational crate

bigrat: signed arbitrary-precision rational operations building on the num_rational crate
opened by coriolinus 0

Releases(v0.4.0)

v0.4.0(Aug 7, 2022)

Fix #14: history operations were being applied twice.
Source code(tar.gz)
Source code(zip)
calc-darwin.tar.bz2(857.29 KB)
calc-linux.tar.bz2(908.90 KB)
calc-win.tar.bz2(787.47 KB)

v0.3.0(Feb 24, 2021)

$ calc -u "0o644 | 0o111 :#o"
0o755
$ calc -u '0o755 & !0o111 :04o'
0644

[0]: 0xab :b 4
1010 1011
[1]: @[0] >>> 4 :x_4
b000_0000_0000_000a
[2]: @ & 0xF :4b
1010

$ calc pi / 3 :v#04.4
0d01.0471

Source code(tar.gz)
Source code(zip)
calc-darwin.tar.bz2(846.43 KB)
calc-linux.tar.bz2(894.54 KB)
calc-win.tar.bz2(796.15 KB)

v0.2.1(Feb 12, 2021)

Still establishing project infrastructure.
Source code(tar.gz)
Source code(zip)
calc-darwin.tar.bz2(780.08 KB)
calc-linux.tar.bz2(865.14 KB)
calc-win.tar.bz2(730.62 KB)
v0.2.0(Feb 12, 2021)

Take over the crate name from its squatter.
Source code(tar.gz)
Source code(zip)
calc-darwin.tar.bz2(779.83 KB)
calc-linux.tar.bz2(865.51 KB)
calc-win.tar.bz2(730.65 KB)
v0.1.0(Feb 10, 2021)
performs all advertised operations

respects hierarchy of operator precedence

expression mode and shell mode

automatic release CI

reference documentation

There's a lot more coming, but this is enough to be useful.
Source code(tar.gz)
Source code(zip)
calc-darwin.tar.bz2(779.91 KB)
calc-linux.tar.bz2(865.54 KB)
calc-win.tar.bz2(730.64 KB)

Owner

Peter Goodspeed-Niklaus

Blockchain engineer at @paritytech. Rust track maintainer for @exercism.

GitHub

An interactive Bayesian Probability Calculator CLI that guides users through updating beliefs based on new evidence.

Bayesian Probability Calculator CLI Welcome to the Bayesian Probability Calculator CLI! This command-line tool is designed to help you update your bel

4 Apr 25, 2023

A complex numbers, graphing, cli calculator

calc requires gnuplot for graphing history file is stored in ~/.config/.calc_history or C:\\Users\\%USERNAME%\\AppData\\Roaming\\calc.history usage Us

6 May 21, 2023

a (soon to be) calculator frontend and a (soon to be optimizing) toy IR backend

Zach-Calc Zach-Calc is a pet project for me to try and better understand pattern matching, optimization, IRs, and the likes. ./libs/* contains librari

0 Jan 6, 2022

Simple calculator REPL, similar to bc(1), with syntax highlighting and persistent history

eva simple calculator REPL, similar to bc(1), with syntax highlighting and persistent history installation Homebrew $ brew install eva crates.io $ car

632 Jan 4, 2023

A todo list app that indexes your app to find TODO:'s

forgot A todo list app that indexes your app to find TODO:'s Usage to list all your todos forgot list list all your todos ignoring search in ./target,

2 Oct 6, 2022

Cork is a simple command-line calculator, mainly targeted towards people who deal with hex numbers

Cork is a simple command-line calculator, mainly targeted towards people who deal with hex numbers. It deals only with integer arithmetic. Expressions may involve mixed bases (limited to decimal, hexadecimal, octal and binary numbers). The global output format may be set to a particular radix - by default it is hex.