Numcore: a math interpreter and evaluator

Numcore allows you to easily parse strings into math expressions and evaluate them.

Numcore is part of Numerus.

Features

• Binary and unary operators
• Supports multiple value types:
  • Bool,
  • Int,
  • Float,
  • Complex,
  • Vector
• Built-in functions
• Built-in constants
• User-defined functions: f(x,y) = xsin(y)+ysin(x)
• User-defined var: a = pi/2 or b = a+2
• Define you own functions with macros.
• Understands ambiguous syntax, like: g(x) = pisinx
• Recursion: f(x) = branch(x<=2, 1, f(x-1)+f(x-2))
• Serde support
• No panicking

Much more will be implemented in future releases!

Use Guide

Evaluating simple static expressions:

use numcore::*;

assert_eq!(eval("2+2").unwrap(), Value::from(4));
assert_eq!(eval("sin(pi)").unwrap(), Value::from(0));
assert_eq!(eval("re(10+3i)").unwrap(), Value::from(10));

Using contexts:

use numcore::*;

let mut context = Context::default();
// Declaring a function
let res = eval_with_mutable_context(
    "f(x) = branch(x<=2, 1, f(x-1) + f(x-2))",
    &mut context
).unwrap();

// Result is None
assert_eq!(res, None);
// Calling the function. We could just use eval_with_static_context at this point
let res = eval_with_mutable_context("f(10)", &mut context).unwrap();

assert_eq!(res, Some(Value::from(55)));

Values

Values are contained inside the Value enum, which provides useful functions to access the contained data:

use numcore::Value;

let value = Value::Float(1.0);

assert_eq!(value.as_bool().unwrap(), true);
assert_eq!(value.as_int().unwrap(), 1);
assert_eq!(value.as_float().unwrap(), 1.0);
assert_eq!(value.as_complex().unwrap(), num::complex::Complex::new(1.0, 0.0));
assert_eq!(value.as_vector(), vec![Value::Float(1.0)]);

// Assign type implicitly:
let implicit = Value::from(1.0);

assert_eq!(value, implicit);

Note that, even thought the initial value was a float, it has been cast into ints and bools. This was possible since the value had no decimal part and it was a one. If these conditions were not met, the cast would have failed.

Operators

Binary operators:

Unary operators:

Functions

Context

Contexts allows you keep track of user-defined functions and variables, as well as settings. They can be created as follows:

use numcore::*;

let mut my_context = Context::new(settings::Rounding::Round(8));

Serde

You can use the optional feature serde_support to let all the public structs derive Serialize and Deserialize.

[dependencies]
num = { version = "<version>", features = [ "serde_support" ] }

License and contribution

Differently from Numerus, Numcore is licensed under a MIT License.

Numcore is currently under heavy development, but feel free to open issues and pull requests for any problems or ideas you come up with.

IMPORTANT: after staging files use the npm run commit command to commit and then follow the prompts. Use all lowercase and imperative descriptions. This ensures that all commits follow the same format and help to keep a clean commit history.