Symbolica

https://github.com/symbolica-dev/symbolica
Admin
Symbolica is a software project likely focused on symbolic computation or related fields, hosted on...
Tokens:4,045
Snippets:34
Trust Score:6.7
Update:8 months ago
Show doc for...
Tokens:
Raw
### Numerical Integration in Rust

Source: https://github.com/symbolica-dev/symbolica/blob/main/lib/numerica/Readme.md

Provides an example of numerical integration using the Vegas algorithm in Rust. It shows how to integrate a function and get statistics about the integral.

```rust
```rust
let f = |x: &[f64]| (x[0] * std::f64::consts::PI).sin() + x[1];
let mut grid = Grid::Continuous(ContinuousGrid::new(2, 128, 100, None, false));
let mut rng = MonteCarloRng::new(0, 0);
let mut sample = Sample::new();
for iteration in 1..20 {
     for _ in 0..10_000 {
         grid.sample(&mut rng, &mut sample);
    
         if let Sample::Continuous(_cont_weight, xs) = &sample {
             grid.add_training_sample(&sample, f(xs)).unwrap();
         }
     }
    
     grid.update(1.5, 1.5);
    
     println!(
         "Integral at iteration {}: {}",
         iteration,
         grid.get_statistics().format_uncertainty()
     );
}
```
```

--------------------------------

### Symbolica Pattern Matching Example in Python

Source: https://github.com/symbolica-dev/symbolica/blob/main/Readme.md

Demonstrates Symbolica's pattern matching capabilities in Python. It shows how to define symbolic variables, create an expression, and use the replace_all method with wildcard variables (ending in '_') to substitute subexpressions.

```python
from symbolica import *
x, y, w1_, w2_, f = S('x','y','w1_','w2_', 'f')
e = f(3,x)*y**2+5
r = e.replace_all(f(w1_,w2_), f(w1_ - 1, w2_**2))
print(r)
```

--------------------------------

### Solve Integer Relations in Rust

Source: https://github.com/symbolica-dev/symbolica/blob/main/lib/numerica/Readme.md

Demonstrates solving integer relations using the PSLQ and LLL basis reduction algorithms in Rust. It provides examples of how to find integer coefficients that satisfy a given equation.

```rust
```rust
let result = Integer::solve_integer_relation(
    &[F64::from(-32.0177), F64::from(3.1416), F64::from(2.7183)],
    F64::from(1e-4),
    1,
    Some(Integer::from(100000u64)),
    None,
)
.unwrap();

assert_eq!(result, &[1, 5, 6]);
```
```

```rust
```rust
let v1 = Vector::new(vec![1.into(), 0.into(), 0.into(), 31416.into()], Z);
let v2 = Vector::new(vec![0.into(), 1.into(), 0.into(), 27183.into()], Z);
let v3 = Vector::new(vec![0.into(), 0.into(), 1.into(), (-320177).into()], Z);

let basis = Vector::basis_reduction(&[v1, v2, v3], (3, 4).into());

assert_eq!(basis[0].into_vec(), [5, 6, 1, 1]);
```
```

--------------------------------

### Install Symbolica for Python

Source: https://github.com/symbolica-dev/symbolica/blob/main/Readme.md

Installs the Symbolica library for Python versions 3.5 and above using pip. This is the standard method for Python package installation.

```shell
pip install symbolica
```

--------------------------------

### Generate Unique Graphs with Specific Edge Attachments in Rust

Source: https://github.com/symbolica-dev/symbolica/blob/main/lib/graphica/Readme.md

This example demonstrates how to generate unique graphs with two external edges, specific edge data ('g'), and nodes with defined edge attachments using Graphica's `generate` function. It utilizes `HalfEdge` for defining edge types and `GenerationSettings` to control graph properties like maximum loops and self-loops. The output is a Mermaid string representation of the generated graph.

```rust
let g = HalfEdge::undirected("g");
let q = HalfEdge::incoming("q");
let gs = Graph::<_, &str>::generate(
    &[(1, g), (2, g)],
    &[vec![g, g, g], vec![q.flip(), q, g], vec![g, g, g, g]],
    GenerationSettings::new()
        .max_loops(2)
        .max_bridges(0)
        .allow_self_loops(true),
)
.unwrap();

let r = gs.keys().next().unwrap().to_mermaid();
println!("{}", r);
```

--------------------------------

### Canonize Graphs and Detect Isomorphisms in Rust

Source: https://github.com/symbolica-dev/symbolica/blob/main/lib/graphica/Readme.md

This Rust code snippet illustrates how to use Graphica's canonization feature, based on McKay's algorithm, to canonize a graph and determine its automorphism group size. It involves manually constructing a graph with nodes and edges, then calling the `canonize` method. The example asserts properties of the canonical representation and prints the graph in DOT format.

```rust
let mut g = Graph::new();
let n0 = g.add_node(1);
let n1 = g.add_node(0);
let n2 = g.add_node(1);
let n3 = g.add_node(0);
let n4 = g.add_node(2);
let n5 = g.add_node(0);
let n6 = g.add_node(1);
let n7 = g.add_node(0);
let n8 = g.add_node(1);

g.add_edge(n0, n1, false, 0).unwrap();
g.add_edge(n0, n3, false, 0).unwrap();
g.add_edge(n1, n2, false, 0).unwrap();
g.add_edge(n1, n3, false, 0).unwrap();
g.add_edge(n1, n4, false, 0).unwrap();
g.add_edge(n1, n5, false, 0).unwrap();
g.add_edge(n2, n5, false, 0).unwrap();
g.add_edge(n3, n4, false, 0).unwrap();
g.add_edge(n3, n6, false, 0).unwrap();
g.add_edge(n3, n7, false, 0).unwrap();
g.add_edge(n4, n5, false, 0).unwrap();
g.add_edge(n4, n7, false, 0).unwrap();
g.add_edge(n5, n7, false, 0).unwrap();
g.add_edge(n5, n8, false, 0).unwrap();
g.add_edge(n6, n7, false, 0).unwrap();
g.add_edge(n7, n8, false, 0).unwrap();

let c = g.canonize();

assert_eq!(c.orbit_generators.len(), 2);
assert_eq!(c.automorphism_group_size, 8);

println!("{}", c.graph.to_dot());
```

--------------------------------

### Symbolica Linear System Solving in Python

Source: https://github.com/symbolica-dev/symbolica/blob/main/Readme.md

Illustrates how to solve a linear system of equations with Symbolica in Python. It defines symbolic variables and uses the Expression.solve_linear_system method to find the solutions for 'x' and 'y' in terms of a parameter 'c'.

```python
from symbolica import *
x, y, c, f = S('x', 'y', 'c', 'f')

x_r, y_r = Expression.solve_linear_system(
    [f(c)*x + y + c, y + c**2], [x, y])
print('x =', x_r, ', y =', y_r)
```

--------------------------------

### Solve Linear System in Rust

Source: https://github.com/symbolica-dev/symbolica/blob/main/lib/numerica/Readme.md

Demonstrates solving a linear system of equations using the Numerica library in Rust. It shows how to solve the system over rational numbers and finite fields.

```rust
```rust
let a = Matrix::from_linear(
    vec![
        1.into(), 2.into(), 3.into(),
        4.into(), 5.into(), 16.into(),
        7.into(), 8.into(), 9.into(),
    ],
    3, 3, Q,
)
.unwrap();

let b = Matrix::new_vec(vec![1.into(), 2.into(), 3.into()], Q);

let r = a.solve(&b).unwrap();
assert_eq!(r.into_vec(), [(-1, 3), (2, 3), (0, 1)]);
```
```

```rust
```rust
let z_7 = Zp::new(7);

let a = Matrix::from_linear(
    vec![
        z_7.to_element(5), z_7.to_element(8),
        z_7.to_element(2), z_7.to_element(1),
    ],
    2, 2, z_7,
)
.unwrap();

let r = a.inv();
assert_eq!(r.into_vec(), [z_7.to_element(4), z_7.to_element(3), z_7.to_element(2), z_7.to_element(0)]);
```
```

--------------------------------

### Error-tracking Floating Points in Rust

Source: https://github.com/symbolica-dev/symbolica/blob/main/lib/numerica/Readme.md

Illustrates the use of `ErrorPropagatingFloat` to track and propagate errors in floating-point calculations. It demonstrates how to wrap `f64` and `Float` to monitor the precision of results.

```rust
```rust
let a = ErrorPropagatingFloat::new(Float::with_val(200, 1e-50), 60.);
let r = (a.exp() - a.one()) / a; // large cancellation
assert_eq!(format!("{r}"), "1.000000000");
assert_eq!(r.get_precision(), Some(10.205999132796238));
```
```

--------------------------------

### Automatic Differentiation in Rust

Source: https://github.com/symbolica-dev/symbolica/blob/main/lib/numerica/Readme.md

Shows how to perform automatic differentiation using dual numbers in Rust. It creates a dual number with multiple variables and demonstrates how to compute derivatives.

```rust
```rust
create_hyperdual_single_derivative!(Dual, 3);

fn main() {
    let x = Dual::<Rational>::new_variable(0, (1, 1).into());
    let y = Dual::new_variable(1, (2, 1).into());
    let z = Dual::new_variable(2, (3, 1).into());

    let t3 = x * y * z;

    println!("{}", t3.inv());
}
```
```

--------------------------------

### Symbolica Series Expansion in Python

Source: https://github.com/symbolica-dev/symbolica/blob/main/Readme.md

Shows how to perform a series expansion of a mathematical expression using Symbolica in Python. The .series() method is used to compute the expansion of 'exp(5+x)/(1-x)' around x=0 up to the third order.

```python
from symbolica import *
e = E('exp(5+x)/(1-x)').series(S('x'), 0, 3)

print(e)
```

--------------------------------

### Symbolica Rational Arithmetic in Python

Source: https://github.com/symbolica-dev/symbolica/blob/main/Readme.md

Demonstrates Symbolica's advanced rational arithmetic capabilities in Python. The .to_rational_polynomial() method is used to convert a complex rational expression into a simplified rational polynomial form.

```python
from symbolica import *
p = E('(x*y^2*5+5)^2/(2*x+5)+(x+4)/(6*x^2+1)').to_rational_polynomial()
print(p)
```

--------------------------------

### Add Symbolica to Rust Project Dependencies

Source: https://github.com/symbolica-dev/symbolica/blob/main/Readme.md

Includes Symbolica as a library dependency in a Rust project by adding it to the Cargo.toml file. This allows for direct use of Symbolica's capabilities within Rust code.

```toml
[dependencies]
symbolica = "1.3"
```
Tokens:
Raw