Enum AtomOrView

pub enum AtomOrView<'a> {
    Atom(Atom),
    View(AtomView<'a>),
}

A copy-on-write structure for Atom and AtomView.

Variants

Atom(Atom)

View(AtomView<'a>)

Implementations

impl<'a> AtomOrView<'a>

pub fn into_owned(self) -> Atom

pub fn as_view(&'a self) -> AtomView<'a>

pub fn as_mut(&mut self) -> &mut Atom

Trait Implementations

impl AtomCore for AtomOrView<'_>

fn as_atom_view(&self) -> AtomView<'_>

Take a view of the atom.

fn export<W: Write>(&self, dest: W) -> Result<(), Error>

Export the atom and state to a binary stream. It can be loaded with Atom::import.

fn get_symbol(&self) -> Option<Symbol>

Get the symbol of a variable or function.

fn collect<E: Exponent>( &self, x: impl AtomCore, key_map: Option<Box<dyn Fn(AtomView<'_>, &mut Atom)>>, coeff_map: Option<Box<dyn Fn(AtomView<'_>, &mut Atom)>>, ) -> Atom

Collect terms involving the same power of x, where x is a variable or function, e.g.

fn collect_symbol<E: Exponent>( &self, x: Symbol, key_map: Option<Box<dyn Fn(AtomView<'_>, &mut Atom)>>, coeff_map: Option<Box<dyn Fn(AtomView<'_>, &mut Atom)>>, ) -> Atom

Collect terms involving the same power of variables or functions with the name x, e.g.

fn collect_multiple<E: Exponent>( &self, xs: &[impl AtomCore], key_map: Option<Box<dyn Fn(AtomView<'_>, &mut Atom)>>, coeff_map: Option<Box<dyn Fn(AtomView<'_>, &mut Atom)>>, ) -> Atom

Collect terms involving the same power of x, where x is a variable or function, e.g.

fn collect_factors(&self) -> Atom

Collect common factors from (nested) sums.

fn coefficient_list<E: Exponent>( &self, xs: &[impl AtomCore], ) -> Vec<(Atom, Atom)>

Collect terms involving the same power of x in xs, where xs is a list of indeterminates. Return the list of key-coefficient pairs

fn coefficient<T: AtomCore>(&self, x: T) -> Atom

Collect terms involving the literal occurrence of x.

fn together(&self) -> Atom

Write the expression over a common denominator.

fn apart(&self, x: Symbol) -> Atom

Write the expression as a sum of terms with minimal denominators in x.

fn apart_multivariate(&self) -> Atom

Write the expression as a sum of terms with minimal denominators in all variables. This method computes a Groebner basis and may therefore be slow for large inputs.

fn cancel(&self) -> Atom

Cancel all common factors between numerators and denominators. Any non-canceling parts of the expression will not be rewritten.

fn factor(&self) -> Atom

Factor the expression over the rationals.

fn collect_num(&self) -> Atom

Collect numerical factors by removing the numerical content from additions. For example, -2*x + 4*x^2 + 6*x^3 will be transformed into -2*(x - 2*x^2 - 3*x^3).

fn expand(&self) -> Atom

Expand an expression. The function AtomCore::expand_via_poly may be faster.

fn expand_via_poly<E: Exponent, T: AtomCore>( &self, var: impl Into<Option<T>>, ) -> Atom

Expand the expression by converting it to a polynomial, optionally only in the indeterminate var. The parameter E should be a numerical type that fits the largest exponent in the expanded expression. Often, u8 or u16 is sufficient.

fn expand_in<T: AtomCore>(&self, var: T) -> Atom

Expand an expression in the variable var. The function AtomCore::expand_via_poly may be faster.

fn expand_in_symbol(&self, var: Symbol) -> Atom

Expand an expression in the variable var.

fn expand_into<T: AtomCore>( &self, var: impl Into<Option<T>>, out: &mut Atom, ) -> bool

Expand an expression, returning true iff the expression changed.

fn expand_num(&self) -> Atom

Distribute numbers in the expression, for example: 2*(x+y) -> 2*x+2*y.

fn is_expanded<T: AtomCore>(&self, var: Option<T>) -> bool

Check if the expression is expanded, optionally in only the variable or function var.

fn derivative(&self, x: Symbol) -> Atom

Take a derivative of the expression with respect to x.

fn derivative_into(&self, x: Symbol, out: &mut Atom) -> bool

Take a derivative of the expression with respect to x and write the result in out. Returns true if the derivative is non-zero.

fn series<T: AtomCore>( &self, x: Symbol, expansion_point: T, depth: Rational, depth_is_absolute: bool, ) -> Result<Series<AtomField>, &'static str>

Series expand in x around expansion_point to depth depth.

fn nsolve<N: SingleFloat + Real + PartialOrd>( &self, x: Symbol, init: N, prec: N, max_iterations: usize, ) -> Result<N, String>

Find the root of a function in x numerically over the reals using Newton’s method.

fn nsolve_system<N: SingleFloat + Real + PartialOrd + InternalOrdering + Eq + Hash, T: AtomCore>( system: &[T], vars: &[Symbol], init: &[N], prec: N, max_iterations: usize, ) -> Result<Vec<N>, String>

Solve a non-linear system numerically over the reals using Newton’s method.

fn solve_linear_system<E: PositiveExponent, T1: AtomCore, T2: AtomCore>( system: &[T1], vars: &[T2], ) -> Result<Vec<Atom>, String>

Solve a system that is linear in vars, if possible. Each expression in system is understood to yield 0.

fn system_to_matrix<E: PositiveExponent, T1: AtomCore, T2: AtomCore>( system: &[T1], vars: &[T2], ) -> Result<(Matrix<RationalPolynomialField<Z, E>>, Matrix<RationalPolynomialField<Z, E>>), String>

Convert a system of linear equations to a matrix representation, returning the matrix and the right-hand side.

fn evaluate<A: AtomCore + KeyLookup, T: Real, F: Fn(&Rational) -> T + Copy>( &self, coeff_map: F, const_map: &HashMap<A, T>, function_map: &HashMap<Symbol, EvaluationFn<A, T>>, ) -> Result<T, String>

Evaluate a (nested) expression a single time. For repeated evaluations, use Self::evaluator() and convert to an optimized version or generate a compiled version of your expression.

fn to_evaluation_tree( &self, fn_map: &FunctionMap<Complex<Rational>>, params: &[Atom], ) -> Result<EvalTree<Complex<Rational>>, String>

Convert nested expressions to a tree suitable for repeated evaluations with different values for params. All variables and all user functions in the expression must occur in the map.

fn evaluator( &self, fn_map: &FunctionMap<Complex<Rational>>, params: &[Atom], optimization_settings: OptimizationSettings, ) -> Result<ExpressionEvaluator<Complex<Rational>>, String>

Create an efficient evaluator for a (nested) expression. All free parameters must appear in params and all other variables and user functions in the expression must occur in the function map. The function map may have nested expressions.

fn evaluator_multiple<A: AtomCore>( exprs: &[A], fn_map: &FunctionMap<Complex<Rational>>, params: &[Atom], optimization_settings: OptimizationSettings, ) -> Result<ExpressionEvaluator<Complex<Rational>>, String>

Convert nested expressions to a tree suitable for repeated evaluations with different values for params. All variables and all user functions in the expression must occur in the map.

fn zero_test(&self, iterations: usize, tolerance: f64) -> ConditionResult

Check if the expression could be 0, using (potentially) numerical sampling with a given tolerance and number of iterations.

fn set_coefficient_ring(&self, vars: &Arc<Vec<Variable>>) -> Atom

Set the coefficient ring to the multivariate rational polynomial with vars variables.

fn coefficients_to_float(&self, decimal_prec: u32) -> Atom

Convert all coefficients to floats with a given precision decimal_prec. The precision of floating point coefficients in the input will be truncated to decimal_prec.

fn coefficients_to_float_into(&self, decimal_prec: u32, out: &mut Atom)

Convert all coefficients to floats with a given precision decimal_prec. The precision of floating point coefficients in the input will be truncated to decimal_prec.

fn conjugate(&self) -> Atom

Complex conjugate all numbers in the expression.

fn map_coefficient<F: Fn(CoefficientView<'_>) -> Coefficient + Copy>( &self, f: F, ) -> Atom

Map all coefficients using a given function.

fn map_coefficient_into<F: Fn(CoefficientView<'_>) -> Coefficient + Copy>( &self, f: F, out: &mut Atom, )

Map all coefficients using a given function.

fn rationalize_coefficients(&self, relative_error: &Rational) -> Atom

Map all floating point and rational coefficients to the best rational approximation in the interval [self*(1-relative_error),self*(1+relative_error)].

fn to_polynomial<R: EuclideanDomain + ConvertToRing, E: Exponent>( &self, field: &R, var_map: impl Into<Option<Arc<Vec<Variable>>>>, ) -> MultivariatePolynomial<R, E>

Convert the atom to a polynomial, optionally in the variable ordering specified by var_map. If new variables are encountered, they are added to the variable map. Similarly, non-polynomial parts are automatically defined as a new independent variable in the polynomial.

fn to_polynomial_in_vars<E: Exponent>( &self, var_map: &Arc<Vec<Variable>>, ) -> MultivariatePolynomial<AtomField, E>

Convert the atom to a polynomial in specific variables. All other parts will be collected into the coefficient, which is a general expression.

fn to_rational_polynomial<R: EuclideanDomain + ConvertToRing, RO: EuclideanDomain + PolynomialGCD<E>, E: PositiveExponent>( &self, field: &R, out_field: &RO, var_map: impl Into<Option<Arc<Vec<Variable>>>>, ) -> RationalPolynomial<RO, E>

where RationalPolynomial<RO, E>: FromNumeratorAndDenominator<R, RO, E> + FromNumeratorAndDenominator<RO, RO, E>,

Convert the atom to a rational polynomial, optionally in the variable ordering specified by var_map. If new variables are encountered, they are added to the variable map. Similarly, non-rational polynomial parts are automatically defined as a new independent variable in the rational polynomial.

fn to_factorized_rational_polynomial<R: EuclideanDomain + ConvertToRing, RO: EuclideanDomain + PolynomialGCD<E>, E: PositiveExponent>( &self, field: &R, out_field: &RO, var_map: impl Into<Option<Arc<Vec<Variable>>>>, ) -> FactorizedRationalPolynomial<RO, E>

where FactorizedRationalPolynomial<RO, E>: FromNumeratorAndFactorizedDenominator<R, RO, E> + FromNumeratorAndFactorizedDenominator<RO, RO, E>, MultivariatePolynomial<RO, E>: Factorize,

Convert the atom to a rational polynomial with factorized denominators, optionally in the variable ordering specified by var_map. If new variables are encountered, they are added to the variable map. Similarly, non-rational polynomial parts are automatically defined as a new independent variable in the rational polynomial.

fn format<W: Write>( &self, fmt: &mut W, opts: &PrintOptions, print_state: PrintState, ) -> Result<bool, Error>

Format the atom.

fn printer(&self, opts: PrintOptions) -> AtomPrinter<'_>

Construct a printer for the atom with special options.

fn to_canonical_string(&self) -> String

Print the atom in a form that is unique and independent of any implementation details.

fn map_terms_single_core(&self, f: impl Fn(AtomView<'_>) -> Atom) -> Atom

Map the function f over all terms.

fn map_terms( &self, f: impl Fn(AtomView<'_>) -> Atom + Send + Sync, n_cores: usize, ) -> Atom

Map the function f over all terms, using parallel execution with n_cores cores.

fn map_terms_with_pool( &self, f: impl Fn(AtomView<'_>) -> Atom + Send + Sync, p: &ThreadPool, ) -> Atom

Map the function f over all terms, using parallel execution with n_cores cores.

fn canonize_tensors<T: AtomCore, G: Ord + Hash>( &self, indices: &[(T, G)], ) -> Result<Atom, String>

Canonize (products of) tensors in the expression by relabeling repeated indices. The tensors must be written as functions, with its indices as the arguments. Subexpressions, constants and open indices are supported.

fn to_pattern(&self) -> Pattern

fn get_all_symbols(&self, include_function_symbols: bool) -> HashSet<Symbol>

Get all symbols in the expression, optionally including function symbols.

fn get_all_indeterminates(&self, enter_functions: bool) -> HashSet<AtomView<'_>>

Get all variables and functions in the expression.

fn contains_symbol(&self, s: Symbol) -> bool

Returns true iff self contains the symbol s.

fn contains<T: AtomCore>(&self, s: T) -> bool

Returns true iff self contains a literally.

fn is_polynomial( &self, allow_not_expanded: bool, allow_negative_powers: bool, ) -> Option<HashSet<AtomView<'_>>>

Check if the expression can be considered a polynomial in some variables, including redefinitions. For example f(x)+y is considered a polynomial in f(x) and y, whereas f(x)+x is not a polynomial.

fn replace<'b, P: Into<BorrowedOrOwned<'b, Pattern>>>( &self, pattern: P, ) -> ReplaceBuilder<'_, 'b>

Replace all occurrences of the pattern. The right-hand side is either another pattern, or a function that maps the matched wildcards to a new expression.

fn replace_multiple<T: BorrowReplacement>(&self, replacements: &[T]) -> Atom

Replace all occurrences of the patterns, where replacements are tested in the order that they are given. To repeatedly replace multiple patterns, wrap the call in [Atom::replace_map].

fn replace_multiple_into<T: BorrowReplacement>( &self, replacements: &[T], out: &mut Atom, ) -> bool

Replace all occurrences of the patterns, where replacements are tested in the order that they are given. Returns true iff a match was found.

fn replace_map<F: FnMut(AtomView<'_>, &Context, &mut Atom) -> bool>( &self, m: F, ) -> Atom

Replace part of an expression by calling the map m on each subexpression. The function m must return true if the expression was replaced and must write the new expression to out. A Context object is passed to the function, which contains information about the current position in the expression.

fn visitor<F: FnMut(AtomView<'_>) -> bool>(&self, v: &mut F)

Call the function v for every subexpression. If v returns true, the subexpressions of the current expression will be visited.

fn pattern_match<'a: 'b, 'b, C: Into<Option<&'b Condition<PatternRestriction>>>, S: Into<Option<&'b MatchSettings>>>( &'a self, pattern: &'b Pattern, conditions: C, settings: S, ) -> PatternAtomTreeIterator<'a, 'b>

Return an iterator over matched expressions.

fn terms(&self) -> impl Iterator<Item = AtomView<'_>>

Return an iterator over all terms in the expression.

fn children(&self) -> impl Iterator<Item = AtomView<'_>>

Return an iterator over the children of the atom.

impl<'a> Clone for AtomOrView<'a>

fn clone(&self) -> AtomOrView<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for AtomOrView<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for AtomOrView<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> From<&'a Atom> for AtomOrView<'a>

fn from(a: &'a Atom) -> AtomOrView<'a>

Converts to this type from the input type.

impl<'a> From<&AtomView<'a>> for AtomOrView<'a>

fn from(a: &AtomView<'a>) -> AtomOrView<'a>

Converts to this type from the input type.

impl<'a> From<&'a Symbol> for AtomOrView<'a>

fn from(s: &'a Symbol) -> AtomOrView<'a>

Converts to this type from the input type.

impl<'a> From<Atom> for AtomOrView<'a>

fn from(a: Atom) -> AtomOrView<'a>

Converts to this type from the input type.

impl<'a> From<AtomView<'a>> for AtomOrView<'a>

fn from(a: AtomView<'a>) -> AtomOrView<'a>

Converts to this type from the input type.

impl<'a> From<Symbol> for AtomOrView<'a>

fn from(s: Symbol) -> AtomOrView<'a>

Converts to this type from the input type.

impl<'a, T> From<T> for AtomOrView<'a>

where T: Into<Coefficient>,

fn from(v: T) -> AtomOrView<'a>

Converts to this type from the input type.

impl Hash for AtomOrView<'_>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for AtomOrView<'_>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for AtomOrView<'_>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for AtomOrView<'_>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for AtomOrView<'_>