Symbolica

Perform easy mathematical manipulations on expressions and create expressions in a format very close to Python’s own notation:

from symbolica import Expression

x, y, w_ = Expression.vars('x', 'y', 'w_')
f = Expression.fun("f")
b = Expression.parse("x^2+2*x*y+y")

e1 = f(x, f(x,y))*f(5) * b
print('e1 =', e1)

e2 = 1/(x*y+1)
print('d/dx e2 =', e2.derivative(x))

e3 = e1.replace_all(f(w_,y), f(w_**2))
print('e3 =', e3)

e1 = (y+x^2+2*x*y)*f(5)*f(x,f(x,y))
d/dx e2 = -y*(x*y+1)^-2
e3 = (y+x^2+2*x*y)*f(5)*f(x,f(x^2))

Perform low-level operations with ultimate flexiblity:

use symbolica::{
    printer::{PrintOptions, RationalPolynomialPrinter},
    representations::Atom,
    rings::{
        integer::IntegerRing, rational::RationalField, rational_polynomial::RationalPolynomial,
    },
    state::{State, Workspace},
};

fn main() {
    let mut state = State::new();
    let workspace = Workspace::default();

    let expr = Atom::parse(
        "(x*y^2*5+5)^2/(2*x+5)+(x+4)/(6*x^2+1)",
        &mut state,
        &workspace,
    )
    .unwrap();
    let rat: RationalPolynomial<IntegerRing, u8> = expr
        .as_view()
        .to_rational_polynomial(
            &workspace,
            &state,
            RationalField::new(),
            IntegerRing::new(),
            None,
        )
        .unwrap();
    println!(
        "{}",
        RationalPolynomialPrinter::new(&rat, &state, PrintOptions::default())
    );
}

Perform blazing fast polynomial arithmetic:

int main()
{
    const char *in = "(x*y^2*5+5)^2/(2*x+5)+(x+4)/(6*x^2+1)";

    Symbolica *s = init();
    set_vars(s, "x,y");
    const char *out = simplify(s, in, 0ull, 0);
    std::cout << out <<  std::endl;

    drop(s);

    return 0;
}