Merge branch 'main' into feature/qr_decomposition

benruijl · Jan 30, 2025 · c95152b · c95152b
2 parents 943ed5c + ff6d2f4
commit c95152b
Show file tree

Hide file tree

Showing 65 changed files with 3,371 additions and 1,953 deletions.
diff --git a/examples/builder.rs b/examples/builder.rs
@@ -1,7 +1,7 @@
-use symbolica::{fun, symb};
+use symbolica::{fun, symbol};
 
 fn main() {
-    let (x, y, f) = symb!("x", "y", "f");
+    let (x, y, f) = symbol!("x", "y", "f");
 
     let f = fun!(f, x, y, 2);
 

diff --git a/examples/coefficient_ring.rs b/examples/coefficient_ring.rs
@@ -1,19 +1,17 @@
 use std::sync::Arc;
 
-use symbolica::atom::{Atom, AtomCore, Symbol};
+use symbolica::{atom::AtomCore, parse, symbol};
 
 fn main() {
-    let expr = Atom::parse("x*z+x*(y+2)^-1*(y+z+1)").unwrap();
+    let expr = parse!("x*z+x*(y+2)^-1*(y+z+1)").unwrap();
     println!("> In: {}", expr);
 
-    let expr_yz = expr.set_coefficient_ring(&Arc::new(vec![
-        Symbol::new("y").into(),
-        Symbol::new("z").into(),
-    ]));
+    let expr_yz =
+        expr.set_coefficient_ring(&Arc::new(vec![symbol!("y").into(), symbol!("z").into()]));
     println!("> Coefficient ring y,z: {}", expr_yz);
 
     // the coefficient must downgrade from y,z to y
-    let expr_y = expr_yz.set_coefficient_ring(&Arc::new(vec![Symbol::new("y").into()]));
+    let expr_y = expr_yz.set_coefficient_ring(&Arc::new(vec![symbol!("y").into()]));
     println!("> Coefficient ring y: {}", expr_y);
 
     // the coefficient must downgrade from y,z to y

diff --git a/examples/collect.rs b/examples/collect.rs
@@ -1,13 +1,13 @@
 use symbolica::{
-    atom::{Atom, AtomCore, Symbol},
-    fun,
+    atom::{Atom, AtomCore},
+    fun, parse, symbol,
 };
 
 fn main() {
-    let input = Atom::parse("x*(1+a)+x*5*y+f(5,x)+2+y^2+x^2 + x^3").unwrap();
-    let x = Atom::new_var(Symbol::new("x"));
-    let key = Symbol::new("key");
-    let coeff = Symbol::new("val");
+    let input = parse!("x*(1+a)+x*5*y+f(5,x)+2+y^2+x^2 + x^3").unwrap();
+    let x = Atom::new_var(symbol!("x"));
+    let key = symbol!("key");
+    let coeff = symbol!("val");
 
     let r = input.coefficient_list::<i8, _>(std::slice::from_ref(&x));
 

diff --git a/examples/derivative.rs b/examples/derivative.rs
@@ -1,7 +1,7 @@
-use symbolica::atom::{Atom, AtomCore, Symbol};
+use symbolica::{atom::AtomCore, parse, symbol};
 
 fn main() {
-    let x = Symbol::new("x");
+    let x = symbol!("x");
     let inputs = [
         "(1+2*x)^(5+x)",
         "log(2*x) + exp(3*x) + sin(4*x) + cos(y*x)",
@@ -10,7 +10,7 @@ fn main() {
     ];
 
     for input in inputs {
-        let input = Atom::parse(input).unwrap();
+        let input = parse!(input).unwrap();
 
         let a = input.derivative(x);
 

diff --git a/examples/evaluate.rs b/examples/evaluate.rs
@@ -1,14 +1,15 @@
 use ahash::HashMap;
 use symbolica::atom::Atom;
-use symbolica::atom::{AtomCore, Symbol};
+use symbolica::atom::AtomCore;
 use symbolica::evaluate::EvaluationFn;
+use symbolica::{parse, symbol};
 
 fn main() {
-    let x = Symbol::new("x");
-    let f = Symbol::new("f");
-    let g = Symbol::new("g");
-    let p0 = Atom::parse("p(0)").unwrap();
-    let a = Atom::parse("x*cos(x) + f(x, 1)^2 + g(g(x)) + p(0)").unwrap();
+    let x = symbol!("x");
+    let f = symbol!("f");
+    let g = symbol!("g");
+    let p0 = parse!("p(0)").unwrap();
+    let a = parse!("x*cos(x) + f(x, 1)^2 + g(g(x)) + p(0)").unwrap();
 
     let mut const_map = HashMap::default();
     let mut fn_map: HashMap<_, _> = HashMap::default();

diff --git a/examples/expansion.rs b/examples/expansion.rs
@@ -1,7 +1,7 @@
-use symbolica::atom::{Atom, AtomCore};
+use symbolica::{atom::AtomCore, parse};
 
 fn main() {
-    let input = Atom::parse("(1+x)^3").unwrap();
+    let input = parse!("(1+x)^3").unwrap();
 
     let o = input.expand();
 

diff --git a/examples/factorization.rs b/examples/factorization.rs
@@ -1,13 +1,15 @@
 use std::sync::Arc;
 
 use symbolica::{
-    atom::{Atom, AtomCore, Symbol},
+    atom::AtomCore,
     domains::{finite_field::Zp, integer::Z},
+    parse,
     poly::{factor::Factorize, polynomial::MultivariatePolynomial, Variable},
+    symbol,
 };
 
 fn factor_ff_univariate() {
-    let exp = Atom::parse("x^100-1").unwrap().expand();
+    let exp = parse!("x^100-1").unwrap().expand();
 
     let field = Zp::new(17);
     let poly: MultivariatePolynomial<_, u8> = exp.to_polynomial(&field, None);
@@ -22,13 +24,13 @@ fn factor_ff_univariate() {
 
 fn factor_ff_bivariate() {
     let order = Arc::new(vec![
-        Variable::Symbol(Symbol::new("x")),
-        Variable::Symbol(Symbol::new("y")),
+        Variable::Symbol(symbol!("x")),
+        Variable::Symbol(symbol!("y")),
     ]);
 
     let input = "((y+1)*x^2+x*y+1)*((y^2+2)*x^2+y+1)";
 
-    let exp = Atom::parse(input).unwrap().expand();
+    let exp = parse!(input).unwrap().expand();
 
     let field = Zp::new(17);
     let poly: MultivariatePolynomial<Zp, u8> = exp.to_polynomial(&field, Some(order));
@@ -40,7 +42,7 @@ fn factor_ff_bivariate() {
 }
 
 fn factor_ff_square_free() {
-    let exp = Atom::parse("(1+x)*(1+x^2)^2*(x^4+1)^3").unwrap().expand();
+    let exp = parse!("(1+x)*(1+x^2)^2*(x^4+1)^3").unwrap().expand();
 
     let field = Zp::new(3);
     let poly: MultivariatePolynomial<_, u8> = exp.to_polynomial(&field, None);
@@ -54,7 +56,7 @@ fn factor_ff_square_free() {
 }
 
 fn factor_square_free() {
-    let exp = Atom::parse("3*(2*x^2+y)(x^3+y)^2(1+4*y)^2(1+x)")
+    let exp = parse!("3*(2*x^2+y)(x^3+y)^2(1+4*y)^2(1+x)")
         .unwrap()
         .expand();
 
@@ -69,7 +71,7 @@ fn factor_square_free() {
 }
 
 fn factor_univariate_1() {
-    let exp = Atom::parse("2*(4 + 3*x)*(3 + 2*x + 3*x^2)*(3 + 8*x^2)*(4 + x + x^16)")
+    let exp = parse!("2*(4 + 3*x)*(3 + 2*x + 3*x^2)*(3 + 8*x^2)*(4 + x + x^16)")
         .unwrap()
         .expand();
 
@@ -84,7 +86,7 @@ fn factor_univariate_1() {
 }
 
 fn factor_univariate_2() {
-    let exp = Atom::parse("(x+1)(x+2)(x+3)^3(x+4)(x+5)(x^2+6)(x^3+7)(x+8)^2(x^4+9)(x^5+x+10)")
+    let exp = parse!("(x+1)(x+2)(x+3)^3(x+4)(x+5)(x^2+6)(x^3+7)(x+8)^2(x^4+9)(x^5+x+10)")
         .unwrap()
         .expand();
 
@@ -100,13 +102,13 @@ fn factor_univariate_2() {
 
 fn factor_bivariate() {
     let order = Arc::new(vec![
-        Variable::Symbol(Symbol::new("x")),
-        Variable::Symbol(Symbol::new("y")),
+        Variable::Symbol(symbol!("x")),
+        Variable::Symbol(symbol!("y")),
     ]);
 
     let input = "(x^2+y+x+1)(3*x+y^2+4)*(6*x*(y+1)+y+5)*(7*x*y+4)";
 
-    let exp = Atom::parse(input).unwrap().expand();
+    let exp = parse!(input).unwrap().expand();
 
     let poly: MultivariatePolynomial<_, u8> = exp.to_polynomial(&Z, Some(order));
 
@@ -118,15 +120,15 @@ fn factor_bivariate() {
 
 fn factor_multivariate() {
     let order = Arc::new(vec![
-        Variable::Symbol(Symbol::new("x")),
-        Variable::Symbol(Symbol::new("y")),
-        Variable::Symbol(Symbol::new("z")),
-        Variable::Symbol(Symbol::new("w")),
+        Variable::Symbol(symbol!("x")),
+        Variable::Symbol(symbol!("y")),
+        Variable::Symbol(symbol!("z")),
+        Variable::Symbol(symbol!("w")),
     ]);
 
     let input = "(x*(2+2*y+2*z)+1)*(x*(4+z^2)+y+3)*(x*(w+w^2+4+y)+w+5)";
 
-    let exp = Atom::parse(input).unwrap().expand();
+    let exp = parse!(input).unwrap().expand();
 
     let poly: MultivariatePolynomial<_, u8> = exp.to_polynomial(&Z, Some(order));
 

diff --git a/examples/fibonacci.rs b/examples/fibonacci.rs
@@ -1,27 +1,28 @@
 use symbolica::{
-    atom::{Atom, AtomCore, AtomView, Symbol},
-    id::{Match, Pattern, WildcardRestriction},
+    atom::{Atom, AtomCore, AtomView},
+    id::{Match, WildcardRestriction},
+    parse, symbol,
 };
 
 fn main() {
     // prepare all patterns
-    let pattern = Pattern::parse("f(x_)").unwrap();
-    let rhs = Pattern::parse("f(x_ - 1) + f(x_ - 2)").unwrap();
-    let lhs_zero_pat = Pattern::parse("f(0)").unwrap();
-    let lhs_one_pat = Pattern::parse("f(1)").unwrap();
+    let pattern = parse!("f(x_)").unwrap().to_pattern();
+    let rhs = parse!("f(x_ - 1) + f(x_ - 2)").unwrap().to_pattern();
+    let lhs_zero_pat = parse!("f(0)").unwrap().to_pattern();
+    let lhs_one_pat = parse!("f(1)").unwrap().to_pattern();
     let rhs_one = Atom::new_num(1).to_pattern();
 
     // prepare the pattern restriction `x_ > 1`
     let restrictions = (
-        Symbol::new("x_"),
+        symbol!("x_"),
         WildcardRestriction::Filter(Box::new(|v: &Match| match v {
             Match::Single(AtomView::Num(n)) => !n.is_one() && !n.is_zero(),
             _ => false,
         })),
     )
         .into();
 
-    let mut target = Atom::parse("f(10)").unwrap();
+    let mut target = parse!("f(10)").unwrap();
 
     println!(
         "> Repeated calls of f(x_) = f(x_ - 1) + f(x_ - 2) on {}:",

diff --git a/examples/fuel_backend.rs b/examples/fuel_backend.rs
@@ -5,10 +5,10 @@ use std::{
 
 use smartstring::{LazyCompact, SmartString};
 use symbolica::{
-    atom::Symbol,
     domains::{integer::Z, rational::Q, rational_polynomial::RationalPolynomial, SelfRing},
     parser::Token,
     printer::{PrintOptions, PrintState},
+    symbol,
 };
 
 fn main() {
@@ -36,7 +36,7 @@ fn main() {
         );
     }
 
-    let vars: Arc<Vec<_>> = Arc::new(var_names.iter().map(|v| Symbol::new(v).into()).collect());
+    let vars: Arc<Vec<_>> = Arc::new(var_names.iter().map(|v| symbol!(v).into()).collect());
 
     let print_opt = PrintOptions::file();
 

diff --git a/examples/groebner_basis.rs b/examples/groebner_basis.rs
@@ -1,12 +1,14 @@
 use symbolica::{
-    atom::{Atom, AtomCore, Symbol},
+    atom::AtomCore,
     domains::finite_field::Zp,
+    parse,
     poly::{groebner::GroebnerBasis, polynomial::MultivariatePolynomial, GrevLexOrder},
+    symbol,
 };
 
 fn main() {
     for x in 'a'..='z' {
-        Symbol::new(x.to_string());
+        symbol!(x.to_string());
     }
 
     // cyclic-4
@@ -20,7 +22,7 @@ fn main() {
     let ideal: Vec<MultivariatePolynomial<_, u16>> = polys
         .iter()
         .map(|x| {
-            let a = Atom::parse(x).unwrap().expand();
+            let a = parse!(x).unwrap().expand();
             a.to_polynomial(&Zp::new(13), None)
         })
         .collect();

diff --git a/examples/nested_evaluation.rs b/examples/nested_evaluation.rs
@@ -1,52 +1,45 @@
 use symbolica::{
-    atom::{Atom, AtomCore, Symbol},
+    atom::{Atom, AtomCore},
     domains::rational::Rational,
     evaluate::{CompileOptions, FunctionMap, InlineASM, OptimizationSettings},
+    parse, symbol,
 };
 
 fn main() {
-    let e1 = Atom::parse("x + pi + cos(x) + f(g(x+1),h(x*2)) + p(1,x)").unwrap();
-    let e2 = Atom::parse("x + h(x*2) + cos(x)").unwrap();
-    let f = Atom::parse("y^2 + z^2*y^2").unwrap();
-    let g = Atom::parse("i(y+7)+x*i(y+7)*(y-1)").unwrap();
-    let h = Atom::parse("y*(1+x*(1+x^2)) + y^2*(1+x*(1+x^2))^2 + 3*(1+x^2)").unwrap();
-    let i = Atom::parse("y - 1").unwrap();
-    let p1 = Atom::parse("3*z^3 + 4*z^2 + 6*z +8").unwrap();
+    let e1 = parse!("x + pi + cos(x) + f(g(x+1),h(x*2)) + p(1,x)").unwrap();
+    let e2 = parse!("x + h(x*2) + cos(x)").unwrap();
+    let f = parse!("y^2 + z^2*y^2").unwrap();
+    let g = parse!("i(y+7)+x*i(y+7)*(y-1)").unwrap();
+    let h = parse!("y*(1+x*(1+x^2)) + y^2*(1+x*(1+x^2))^2 + 3*(1+x^2)").unwrap();
+    let i = parse!("y - 1").unwrap();
+    let p1 = parse!("3*z^3 + 4*z^2 + 6*z +8").unwrap();
 
     let mut fn_map = FunctionMap::new();
 
-    fn_map.add_constant(
-        Atom::new_var(Symbol::new("pi")),
-        Rational::from((22, 7)).into(),
-    );
+    fn_map.add_constant(Atom::new_var(symbol!("pi")), Rational::from((22, 7)).into());
     fn_map
         .add_tagged_function(
-            Symbol::new("p"),
+            symbol!("p"),
             vec![Atom::new_num(1).into()],
             "p1".to_string(),
-            vec![Symbol::new("z")],
+            vec![symbol!("z")],
             p1,
         )
         .unwrap();
     fn_map
-        .add_function(
-            Symbol::new("f"),
-            "f".to_string(),
-            vec![Symbol::new("y"), Symbol::new("z")],
-            f,
-        )
+        .add_function(symbol!("f"), "f".to_string(), vec![symbol!("y"), symbol!("z")], f)
         .unwrap();
     fn_map
-        .add_function(Symbol::new("g"), "g".to_string(), vec![Symbol::new("y")], g)
+        .add_function(symbol!("g"), "g".to_string(), vec![symbol!("y")], g)
         .unwrap();
     fn_map
-        .add_function(Symbol::new("h"), "h".to_string(), vec![Symbol::new("y")], h)
+        .add_function(symbol!("h"), "h".to_string(), vec![symbol!("y")], h)
         .unwrap();
     fn_map
-        .add_function(Symbol::new("i"), "i".to_string(), vec![Symbol::new("y")], i)
+        .add_function(symbol!("i"), "i".to_string(), vec![symbol!("y")], i)
         .unwrap();
 
-    let params = vec![Atom::parse("x").unwrap()];
+    let params = vec![parse!("x").unwrap()];
 
     let evaluator = Atom::evaluator_multiple(
         &[e1.as_view(), e2.as_view()],

diff --git a/examples/optimize.rs b/examples/optimize.rs
diff --git a/examples/optimize_multiple.rs b/examples/optimize_multiple.rs
diff --git a/examples/partial_fraction.rs b/examples/partial_fraction.rs
@@ -1,17 +1,17 @@
 use std::sync::Arc;
 
 use symbolica::{
-    atom::Symbol,
     domains::{
         factorized_rational_polynomial::FactorizedRationalPolynomial, integer::Z,
         rational_polynomial::RationalPolynomial,
     },
     parser::Token,
+    symbol,
 };
 
 fn univariate() {
     let var_names = vec!["x".into(), "y".into()];
-    let var_map = Arc::new(var_names.iter().map(|n| Symbol::new(n).into()).collect());
+    let var_map = Arc::new(var_names.iter().map(|n| symbol!(n).into()).collect());
 
     let rat: RationalPolynomial<_, u8> = Token::parse("1/((x+1)*(x+2)(x^3+2x+1))")
         .unwrap()
@@ -26,7 +26,7 @@ fn univariate() {
 
 fn multivariate() {
     let var_names = vec!["x".into(), "y".into()];
-    let var_map = Arc::new(var_names.iter().map(|n| Symbol::new(n).into()).collect());
+    let var_map = Arc::new(var_names.iter().map(|n| symbol!(n).into()).collect());
 
     let rat: FactorizedRationalPolynomial<_, u8> = Token::parse("1/((x+y)*(x^2+x*y+1)(x+1))")
         .unwrap()