Crate math_utils_lib

This crate provides a number of math utilities:

• parsing and evaluating expressions containing matrices and vectors
• solving equations (use feature high-prec-solve for a precision of 13, standard precision is 8)
• exporting a LaTeX document from a collection of parsed expressions or solved equations (see StepType)

Precision (PREC):

Use feature high-prec for a precision of 13, standard precision is 8. The precision is used to solve equations at the set precision. The actual output precision for printing is the defined precision - 2.

Important Rules:

Vectors and matrices can be written out in an expression (e.g [3, 5, 7] or [[3, 4, 5], [3, 4, 5], [2, 6, 7]])
Variable Names can only start with an alphabetic letter or a \ (see Variable)
See OpType for all allowed operations and functions.

This crate has not hit 1.0.0 yet, breaking changes are bound to happen!

Examples

(if you want to use “?” for error handling in your application, have a look at MathLibError)

Evaluations:

let res = quick_eval("3*3".to_string(), vec![])?;

assert_eq!(res, Value::Scalar(9.));

let x = Variable {
    name: "x".to_string(),
    value: Value::Scalar(3.)
};
let res = quick_eval("3x".to_string(), vec![x])?;

assert_eq!(res, Value::Scalar(9.));

let a = Variable {
    name: "A".to_string(),
    value: Value::Vector(vec![3., 5., 8.])
};
let res = quick_eval("3A".to_string(), vec![a])?;

assert_eq!(res, Value::Vector(vec![9., 15., 24.]));

let a = Variable {
    name: "A".to_string(),
    value: Value::Vector(vec![3., 5., 8.])
};
let b = Variable {
    name: "B".to_string(),
    value: Value::Matrix(vec![vec![2., 0., 0.], vec![0., 2., 0.], vec![0., 0., 1.]])
};
let res = quick_eval("B*A".to_string(), vec![a, b])?;

assert_eq!(res, Value::Vector(vec![6., 10., 8.]));

Equations:

let equation = "x^2=9".to_string();

let res = quick_solve(equation, "x".to_string(), vec![])?;

let res_rounded = res.iter().map(|x| Value::Scalar((x.get_scalar()*1000.).round()/1000.)).collect::<Vec<Value>>();

assert_eq!(res_rounded, vec![Value::Scalar(3.), Value::Scalar(-3.)]);

LaTeX:

let expression = "((25x^3-96x^2+512x+384)/(x^4+2x^3+90x^2-128x+1664)^(1.5))/(-sqrt(1-((32-x+x^2)/(((x-1)^2+25)(x^2+64)))^2))".to_string();
let parsed = parse(expression)?;
let vars = vec![Variable {
    name: "x".to_string(),
    value: Value::Scalar(-0.655639)
}];
let result = eval(&parsed, &vars)?;
let var_assign = StepType::Calc((Binary::Value(Value::Scalar(-0.655639)), Value::Scalar(-0.655639), Some("x".to_string())));
let step = StepType::Calc((parsed, result, None));
export(vec![var_assign, step], "export".to_string(), ExportType::Png);

Output (export-1.png):

Re-exports

• pub use basetypes::Value;
• pub use basetypes::Variable;
• pub use latex_export::export;
• pub use latex_export::ExportType;
• pub use latex_export::StepType;
• pub use parser::parse;
• pub use parser::eval;
• pub use roots::find_roots;
• pub use errors::MathLibError;

Modules

• basetypes
• errors
• latex_export
• parser
• roots

Constants

• PREC
  defines the precision used by the equation solver and the printing precision, which is PREC-2.

Functions

• quick_eval
  evaluates a given expression using the given variables (e and pi are provided by the function). If you just want the Binary Tree, have a look at parse().
• quick_solve
  solves a given equation towards a given Variable Name (solve_var). It can additionaly be provided with other variables. If you just want a root finder, have a look at find_roots().