merge ours with no_namespace

Author: lcnbr

examples/pattern_match.rs

@@ -12,6 +12,15 @@ fn main() {
 
     println!("> Matching pattern {} to {}:", pat_expr, expr.as_view());
 
+    // simple match
+    for m in expr.pattern_match(&pattern, None, None) {
+        for (wc, v) in m {
+            println!("\t{} = {}", wc, v);
+        }
+        println!();
+    }
+
+    // advanced match
     let mut it = expr.pattern_match(&pattern, None, None);
     while let Some(m) = it.next_detailed() {
         println!(

examples/tree_replace.rs

@@ -13,7 +13,7 @@ fn main() {
     println!("> Matching pattern {} to {}:", pat_expr, expr);
 
     for x in expr.pattern_match(&pattern, None, None) {
-        println!("\t x_ = {}", x.get(&symb!("x_")).unwrap().to_atom());
+        println!("\t x_ = {}", x.get(&symb!("x_")).unwrap());
     }
 
     println!("> Matching pattern {} to {}:", pat_expr, expr);

src/api/python.rs

@@ -1166,10 +1166,11 @@ impl PythonTransformer {
         py.allow_threads(|| {
             Workspace::get_local()
                 .with(|workspace| {
-                    self.expr.substitute_wildcards(
+                    self.expr.replace_wildcards_with_matches_impl(
                         workspace,
                         &mut out,
-                        &MatchStack::new(&Condition::default(), &MatchSettings::default()),
+                        &MatchStack::new(),
+                        true,
                         None,
                     )
                 })
@@ -2067,7 +2068,7 @@ impl TryFrom<Relation> for PatternRestriction {
                         WildcardRestriction::Filter(Box::new(move |m| {
                             m.to_atom()
                                 .pattern_match(&pattern, Some(&cond), Some(&settings))
-                                .next()
+                                .next_detailed()
                                 .is_some()
                         })),
                     )))
@@ -4072,6 +4073,7 @@ impl PythonExpression {
     /// x^2 1
     /// 1 5
     /// ```
+    #[pyo3(signature = (*x,))]
     pub fn coefficient_list(
         &self,
         x: Bound<'_, PyTuple>,
@@ -5261,11 +5263,12 @@ impl PythonExpression {
     }
 
     /// Canonize (products of) tensors in the expression by relabeling repeated indices.
-    /// The tensors must be written as functions, with its indices are the arguments.
-    /// The repeated indices should be provided in `contracted_indices`.
+    /// The tensors must be written as functions, with its indices as the arguments.
+    /// Subexpressions, constants and open indices are supported.
     ///
     /// If the contracted indices are distinguishable (for example in their dimension),
-    /// you can provide an optional group marker for each index using `index_group`.
+    /// you can provide a group marker as the second element in the tuple of the index
+    /// specification.
     /// This makes sure that an index will not be renamed to an index from a different group.
     ///
     /// Examples
@@ -5276,38 +5279,20 @@ impl PythonExpression {
     /// >>>
     /// >>> e = g(mu2, mu3)*fc(mu4, mu2, k1, mu4, k1, mu3)
     /// >>>
-    /// >>> print(e.canonize_tensors([mu1, mu2, mu3, mu4]))
+    /// >>> print(e.canonize_tensors([(mu1, 0), (mu2, 0), (mu3, 0), (mu4, 0)]))
     /// yields `g(mu1,mu2)*fc(mu1,mu3,mu2,k1,mu3,k1)`.
-    #[pyo3(signature = (contracted_indices, index_group=None))]
     fn canonize_tensors(
         &self,
-        contracted_indices: Vec<ConvertibleToExpression>,
-        index_group: Option<Vec<ConvertibleToExpression>>,
+        contracted_indices: Vec<(ConvertibleToExpression, ConvertibleToExpression)>,
     ) -> PyResult<Self> {
         let contracted_indices = contracted_indices
             .into_iter()
-            .map(|x| x.to_expression().expr)
+            .map(|x| (x.0.to_expression().expr, x.1.to_expression().expr))
             .collect::<Vec<_>>();
-        let contracted_indices = contracted_indices
-            .iter()
-            .map(|x| x.as_view())
-            .collect::<Vec<_>>();
-
-        let index_group = index_group.map(|x| {
-            x.into_iter()
-                .map(|x| x.to_expression().expr)
-                .collect::<Vec<_>>()
-        });
-        let index_group = index_group
-            .as_ref()
-            .map(|x| x.iter().map(|x| x.as_view()).collect::<Vec<_>>());
 
         let r = self
             .expr
-            .canonize_tensors(
-                &contracted_indices,
-                index_group.as_ref().map(|x| x.as_slice()),
-            )
+            .canonize_tensors(&contracted_indices)
             .map_err(|e| {
                 exceptions::PyValueError::new_err(format!("Could not canonize tensors: {}", e))
             })?;
@@ -5891,7 +5876,7 @@ impl PythonMatchIterator {
         self.with_dependent_mut(|_, i| {
             i.next().map(|m| {
                 m.into_iter()
-                    .map(|(k, v)| (Atom::new_var(k).into(), { v.to_atom().into() }))
+                    .map(|(k, v)| (Atom::new_var(k).into(), { v.into() }))
                     .collect()
             })
         })
@@ -10354,7 +10339,7 @@ impl PythonExpressionEvaluator {
         (function_name,
         filename,
         library_name,
-        inline_asm = true,
+        inline_asm = "default",
         optimization_level = 3,
         compiler_path = None,
     ))]
@@ -10363,7 +10348,7 @@ impl PythonExpressionEvaluator {
         function_name: &str,
         filename: &str,
         library_name: &str,
-        inline_asm: bool,
+        inline_asm: &str,
         optimization_level: u8,
         compiler_path: Option<&str>,
     ) -> PyResult<PythonCompiledExpressionEvaluator> {
@@ -10373,19 +10358,22 @@ impl PythonExpressionEvaluator {
             options.compiler = compiler_path.to_string();
         }
 
+        let inline_asm = match inline_asm.to_lowercase().as_str() {
+            "default" => InlineASM::default(),
+            "x64" => InlineASM::X64,
+            "aarch64" => InlineASM::AArch64,
+            "none" => InlineASM::None,
+            _ => {
+                return Err(exceptions::PyValueError::new_err(
+                    "Invalid inline assembly type specified.",
+                ))
+            }
+        };
+
         Ok(PythonCompiledExpressionEvaluator {
             eval: self
                 .eval
-                .export_cpp(
-                    filename,
-                    function_name,
-                    true,
-                    if inline_asm {
-                        InlineASM::X64
-                    } else {
-                        InlineASM::None
-                    },
-                )
+                .export_cpp(filename, function_name, true, inline_asm)
                 .map_err(|e| exceptions::PyValueError::new_err(format!("Export error: {}", e)))?
                 .compile(library_name, options)
                 .map_err(|e| {

src/atom/core.rs

@@ -1025,11 +1025,12 @@ pub trait AtomCore {
     }
 
     /// Canonize (products of) tensors in the expression by relabeling repeated indices.
-    /// The tensors must be written as functions, with its indices are the arguments.
-    /// The repeated indices should be provided in `contracted_indices`.
+    /// The tensors must be written as functions, with its indices as the arguments.
+    /// Subexpressions, constants and open indices are supported.
     ///
     /// If the contracted indices are distinguishable (for example in their dimension),
-    /// you can provide an optional group marker for each index using `index_group`.
+    /// you can provide a group marker as the second element in the tuple of the index
+    /// specification.
     /// This makes sure that an index will not be renamed to an index from a different group.
     ///
     /// Example
@@ -1042,23 +1043,25 @@ pub trait AtomCore {
     /// let _ = Symbol::new_with_attributes("fc", &[FunctionAttribute::Cyclesymmetric]).unwrap();
     /// let a = Atom::parse("fs(mu2,mu3)*fc(mu4,mu2,k1,mu4,k1,mu3)").unwrap();
     ///
-    /// let mu1 = Atom::parse("mu1").unwrap();
-    /// let mu2 = Atom::parse("mu2").unwrap();
-    /// let mu3 = Atom::parse("mu3").unwrap();
-    /// let mu4 = Atom::parse("mu4").unwrap();
+    /// let mu1 = (Atom::parse("mu1").unwrap(), 0);
+    /// let mu2 = (Atom::parse("mu2").unwrap(), 0);
+    /// let mu3 = (Atom::parse("mu3").unwrap(), 0);
+    /// let mu4 = (Atom::parse("mu4").unwrap(), 0);
     ///
-    /// let r = a.canonize_tensors(&[mu1.as_view(), mu2.as_view(), mu3.as_view(), mu4.as_view()], None).unwrap();
+    /// let r = a.canonize_tensors(&[mu1, mu2, mu3 ,mu4]).unwrap();
     /// println!("{}", r);
     /// # }
     /// ```
     /// yields `fs(mu1,mu2)*fc(mu1,k1,mu3,k1,mu2,mu3)`.
-    fn canonize_tensors(
+    fn canonize_tensors<T: AtomCore, G: Ord + std::hash::Hash>(
         &self,
-        contracted_indices: &[AtomView],
-        index_group: Option<&[AtomView]>,
+        indices: &[(T, G)],
     ) -> Result<Atom, String> {
-        self.as_atom_view()
-            .canonize_tensors(contracted_indices, index_group)
+        let indices = indices
+            .iter()
+            .map(|(i, g)| (i.as_atom_view(), g))
+            .collect::<Vec<_>>();
+        self.as_atom_view().canonize_tensors(&indices)
     }
 
     fn to_pattern(&self) -> Pattern {
@@ -1318,16 +1321,16 @@ pub trait AtomCore {
     /// let mut iter = expr.pattern_match(&pattern, None, None);
     /// let result = iter.next().unwrap();
     /// assert_eq!(
-    ///     result.get(&Symbol::new("x_")).unwrap().to_atom(),
-    ///     Atom::new_num(1)
+    ///     result.get(&Symbol::new("x_")).unwrap(),
+    ///     &Atom::new_num(1)
     /// );
     /// ```
-    fn pattern_match<'a>(
+    fn pattern_match<'a: 'b, 'b>(
         &'a self,
-        pattern: &'a Pattern,
-        conditions: Option<&'a Condition<PatternRestriction>>,
-        settings: Option<&'a MatchSettings>,
-    ) -> PatternAtomTreeIterator<'a, 'a> {
+        pattern: &'b Pattern,
+        conditions: Option<&'b Condition<PatternRestriction>>,
+        settings: Option<&'b MatchSettings>,
+    ) -> PatternAtomTreeIterator<'a, 'b> {
         PatternAtomTreeIterator::new(pattern, self.as_atom_view(), conditions, settings)
     }
 }

src/coefficient.rs

@@ -27,6 +27,7 @@ use crate::{
         atom::AtomField,
         finite_field::{
             FiniteField, FiniteFieldCore, FiniteFieldElement, FiniteFieldWorkspace, ToFiniteField,
+            Zp64,
         },
         float::{Float, NumericalFloatLike, Real, SingleFloat},
         integer::{Integer, IntegerRing, Z},
@@ -63,6 +64,14 @@ pub enum Coefficient {
     RationalPolynomial(RationalPolynomial<IntegerRing, u16>),
 }
 
+impl Coefficient {
+    /// Construct a coefficient from a finite field element.
+    pub fn from_finite_field(field: Zp64, element: FiniteFieldElement<u64>) -> Self {
+        let index = State::get_or_insert_finite_field(field);
+        Coefficient::FiniteField(element, index)
+    }
+}
+
 impl From<i64> for Coefficient {
     fn from(value: i64) -> Self {
         Coefficient::Rational(value.into())

src/domains.rs

@@ -141,7 +141,7 @@ pub trait Ring: Clone + PartialEq + Eq + Hash + Debug + Display {
     fn zero(&self) -> Self::Element;
     fn one(&self) -> Self::Element;
     /// Return the nth element by computing `n * 1`.
-    fn nth(&self, n: u64) -> Self::Element;
+    fn nth(&self, n: Integer) -> Self::Element;
     fn pow(&self, b: &Self::Element, e: u64) -> Self::Element;
     fn is_zero(a: &Self::Element) -> bool;
     fn is_one(&self, a: &Self::Element) -> bool;
@@ -151,6 +151,10 @@ pub trait Ring: Clone + PartialEq + Eq + Hash + Debug + Display {
     /// The number of elements in the ring. 0 is used for infinite rings.
     fn size(&self) -> Integer;
 
+    /// Return the result of dividing `a` by `b`, if possible and if the result is unique.
+    /// For example, in [Z](type@integer::Z), `4/2` is possible but `3/2` is not.
+    fn try_div(&self, a: &Self::Element, b: &Self::Element) -> Option<Self::Element>;
+
     fn sample(&self, rng: &mut impl rand::RngCore, range: (i64, i64)) -> Self::Element;
     /// Format a ring element with custom [PrintOptions] and [PrintState].
     fn format<W: std::fmt::Write>(
@@ -299,7 +303,7 @@ impl<R: Ring, C: Clone + Borrow<R>> Ring for WrappedRingElement<R, C> {
         }
     }
 
-    fn nth(&self, n: u64) -> Self::Element {
+    fn nth(&self, n: Integer) -> Self::Element {
         WrappedRingElement {
             ring: self.ring.clone(),
             element: self.ring().nth(n),
@@ -349,6 +353,13 @@ impl<R: Ring, C: Clone + Borrow<R>> Ring for WrappedRingElement<R, C> {
     ) -> Result<bool, Error> {
         self.ring().format(&element.element, opts, state, f)
     }
+
+    fn try_div(&self, a: &Self::Element, b: &Self::Element) -> Option<Self::Element> {
+        Some(WrappedRingElement {
+            ring: self.ring.clone(),
+            element: self.ring().try_div(&a.element, &b.element)?,
+        })
+    }
 }
 
 impl<R: Ring, C: Clone + Borrow<R>> Debug for WrappedRingElement<R, C> {