simsym 0.1.0

A simple symbolic computation library.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

# simsym

A simple symbolic computation library for Rust, with exact rational arithmetic.

## Quick start

```rust
use simsym::prelude::*;

let x = symbol("x");
let y = symbol("y");

// Operators
let f = x.pow(2) + rational(2, 1) * x * y + sin(y);

// Macro DSL
let g = expr!(x^2 + 2*x*y + sin(y));

let df_dx = f.clone().diff(x);
let grad = f.gradient(&[x, y]);

let exact = f.eval(&[(x, rational(1, 2)), (y, rational(1, 3))])?;
let approx = f.eval_f64(&[(x, 0.5), (y, 1.0 / 3.0)])?;
let approx32 = f.eval_f32(&[(x, 0.5f32)])?;

let F = f.integrate(x)?; // symbolic when a rule applies
let area = f.integrate_definite(x, rational(0, 1), rational(1, 1), &[])?;

// Numeric fallback
let num = integrate_numeric(&sin(x), x, 0.0, std::f64::consts::PI, &[], NumericOptions::default())?;
```

## Features

- Expression AST with `+ - * / ^`, full circular & hyperbolic trig (`sin`…`acsch`), plus `exp`, `ln`
- Exact `Rational` constants (`i64` ratios); `From`/`TryFrom` for all integer primitives and `f32`/`f64`
- Simplification (algebraic folding, some like-term merging)
- Partial derivatives and gradients / Hessians
- Symbolic integration for polynomials and common elementary forms
- Definite integrals (symbolic antiderivative or adaptive Simpson)
- `expr!` procedural macro

## Limitations

Symbolic integration is **rule-based** (polynomials, affine trig/exp, `e^x×P`, parts, `sin^n`/`cos^n` reduction, partial fractions for low-degree `P/Q` including `atan` terms, `sin·cos` products, etc.) — not a full Risch algorithm. See [docs/INTEGRATION.md](docs/INTEGRATION.md) for the algorithm stack. When `integrate` returns `IntegrateError::NoRule`, use `integrate_numeric` or `integrate_definite` (which falls back automatically).

Transcendental functions are not supported in exact `eval`; use `eval_f64` or `eval_f32`.

## Examples

```bash
cargo run --example calculus
cargo run --example multivar
cargo run --example numeric_integral
```

## Optional features

Cargo features (enabled by default):

| Feature | Enables |
|---------|---------|
| `simplify` | [`Expr::simplify`](https://docs.rs/simsym/latest/simsym/struct.Expr.html#method.simplify) |
| `diff` | [`Expr::diff`](https://docs.rs/simsym/latest/simsym/struct.Expr.html#method.diff), `gradient`, `hessian` |
| `integrate` | [`Expr::integrate`](https://docs.rs/simsym/latest/simsym/struct.Expr.html#method.integrate), `integrate_definite` (implies `diff`) |

Minimal build (AST + rationals + evaluation only):

```bash
cargo build --no-default-features
```

Other optional features:

- `serde` — serialize rationals as `(numer, denom)`
- `bigint` — [`BigRational`](src/rational_big.rs) / [`Constant::Wide`](src/constant.rs) for coefficients beyond `i64`; `From<i128>` etc. for [`Expr`](src/expr.rs)