Struct Equation 

pub struct Equation {
    pub lhs: Box<dyn Expr>,
    pub rhs: Box<dyn Expr>,
}

Fields

lhs: Box<dyn Expr>

rhs: Box<dyn Expr>

Implementations

impl Equation

pub fn into_new(lhs: &Box<dyn Expr>, rhs: &Box<dyn Expr>) -> Equation

pub fn new(lhs: &dyn Expr, rhs: &dyn Expr) -> Equation

pub fn new_box(lhs: Box<dyn Expr>, rhs: Box<dyn Expr>) -> Box<dyn Expr>

pub fn from_str(s: &str) -> Result<Equation, Error>

impl Equation

pub fn solve<'a, S: IntoIterator<Item = &'a dyn Expr>>( &self, exprs: S, ) -> Result<Equation, SolvingError>

Trait Implementations

impl Clone for Equation

fn clone(&self) -> Equation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Equation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Equation

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Equation

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

Formats the value using the given formatter.

impl DivAssign<&(dyn Expr + 'static)> for Equation

fn div_assign(&mut self, rhs: &dyn Expr)

Performs the /= operation.

impl Expr for Equation

fn name(&self) -> String

fn get_ref<'a>(&'a self) -> &'a dyn Expr

fn for_each_arg(&self, f: &mut dyn FnMut(&dyn Arg))

fn from_args(&self, args: Vec<Box<dyn Arg>>) -> Box<dyn Expr>

fn clone_box(&self) -> Box<dyn Expr>

fn str(&self) -> String

fn as_expr(&self) -> Option<Box<dyn Expr>>

fn args(&self) -> Vec<Box<dyn Arg>>

fn args_map_exprs( &self, _f: &dyn Fn(&dyn Expr) -> Box<dyn Arg>, ) -> Vec<Box<dyn Arg>>

fn as_arg(&self) -> Box<dyn Arg>

fn as_function(&self) -> Option<&Func>

fn equals(&self, other: &dyn Expr) -> bool

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

fn as_eq(&self) -> Option<Equation>

fn as_mul(&self) -> Option<&Mul>

fn as_pow(&self) -> Option<&Pow>

fn as_f64(&self) -> Option<f64>

fn to_cpp(&self) -> String

fn simplify(&self) -> Box<dyn Expr>

fn simplify_with_dimension(&self, dim: usize) -> Box<dyn Expr>

fn as_int(&self) -> Option<Integer>

fn pow(&self, exponent: &Box<dyn Expr>) -> Box<dyn Expr>

fn ipow(&self, exponent: isize) -> Box<dyn Expr>

fn sqrt(&self) -> Box<dyn Expr>

fn get_exponent(&self) -> (Box<dyn Expr>, Box<dyn Expr>)

fn diff(&self, var: &str, order: usize) -> Box<dyn Expr>

fn subs(&self, substitutions: &[[Box<dyn Expr>; 2]]) -> Box<dyn Expr>

fn has(&self, expr: &dyn Expr) -> bool

fn has_box(&self, expr: Box<dyn Expr>) -> bool

fn expand(&self) -> Box<dyn Expr>

Expands an expression. For example: (x + y) * z -> xz + yz

fn factor(&self, factors: &[&dyn Expr]) -> Box<dyn Expr>

Factorizes an expression For example: factor(ax + cx + zy, [x]) -> (a + c)x + zy

fn is_one(&self) -> bool

fn is_neg_one(&self) -> bool

fn is_number(&self) -> bool

fn is_negative_number(&self) -> bool

fn is_zero(&self) -> bool

fn known_expr(&self) -> KnownExpr<'_>

fn terms<'a>(&'a self) -> Box<dyn Iterator<Item = &'a dyn Expr> + 'a>

fn get_coeff(&self) -> (Rational, Box<dyn Expr>)

fn compare(&self, other: &dyn Expr) -> Option<Ordering>

fn evaluate(&self, vars: Option<HashMap<Symbol, BoxExpr>>) -> BoxExpr

impl FromStr for Equation

type Err = ParseEquationError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl JsonSchema for Equation

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(_generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for Equation

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 Serialize for Equation

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl SubAssign<&(dyn Expr + 'static)> for Equation

fn sub_assign(&mut self, rhs: &dyn Expr)

Performs the -= operation.