Struct Equation 

pub struct Equation {
    pub lhs: Ex,
    pub rhs: Ex,
}

A symbolic equation lhs = rhs.

Examples

use symplex::prelude::*;
use symplex::eq::Equation;

let ctx = Context::new();
let x = ctx.symbol("x");
let eq = Equation::new(&x + 1, ctx.int(5));
assert_eq!(format!("{eq}"), "x + 1 = 5");

Fields

lhs: Ex

Left-hand side of the equation.

rhs: Ex

Right-hand side of the equation.

Implementations

impl Equation

pub fn new(lhs: Ex, rhs: Ex) -> Self

Create a new equation lhs = rhs.

Panics

Panics if the two sides belong to different contexts.

pub fn lhs(&self) -> &Ex

The left-hand side.

pub fn rhs(&self) -> &Ex

The right-hand side.

pub fn swap(&self) -> Equation

The equation rhs = lhs.

use symplex::prelude::*;

let ctx = Context::new();
let x = ctx.symbol("x");
let eq = Equation::new(ctx.int(5), &x + 1).swap();
assert_eq!(format!("{eq}"), "x + 1 = 5");

pub fn apply(&self, f: impl Fn(&Ex) -> Ex) -> Equation

Apply the same function to both sides.

use symplex::prelude::*;

let ctx = Context::new();
let x = ctx.symbol("x");
let eq = Equation::new(x.exp(), ctx.int(2)).apply(|s| s.ln());
assert_eq!(format!("{}", eq.simplify()), "x = ln(2)");

pub fn to_zero_equation(&self) -> Equation

Move everything to the left: the equation lhs - rhs = 0.

For the bare expression lhs - rhs use to_expr (or the ZeroForm trait, which the solvers accept).

use symplex::prelude::*;

let ctx = Context::new();
let x = ctx.symbol("x");
let eq = Equation::new(x.powi(2), &x + 2).to_zero_equation();
assert_eq!(format!("{eq}"), "x^2 - x - 2 = 0");

pub fn solve(&self, var: &Ex) -> Result<Vec<Ex>, SymplexError>

Solve this equation for var, returning the solution values.

Internally computes lhs - rhs and solves for zero.

Examples

use symplex::prelude::*;
use symplex::eq::Equation;

let ctx = Context::new();
let x = ctx.symbol("x");
let eq = Equation::new(&x + 1, ctx.int(5));
let roots = eq.solve(&x).unwrap();
assert_eq!(format!("{}", roots[0]), "4");

pub fn solve_for(&self, var: &Ex) -> Result<Vec<Equation>, SymplexError>

Solve for var, returning each solution as an equation var = value.

This is the form you want when the result feeds further substitution or display; solve returns the bare values.

use symplex::prelude::*;

let ctx = Context::new();
let x = ctx.symbol("x");
let sols = Equation::new(x.powi(2), ctx.int(4)).solve_for(&x).unwrap();
let mut shown: Vec<String> = sols.iter().map(|e| format!("{e}")).collect();
shown.sort();
assert_eq!(shown, vec!["x = -2", "x = 2"]);

pub fn solve_or_empty(&self, var: &Ex) -> Vec<Ex>

Solve this equation, returning empty vec on failure.

pub fn subs(&self, old: &Ex, new: &Ex) -> Equation

Substitute a variable in both sides.

pub fn subs_i64(&self, old: &Ex, val: i64) -> Equation

Substitute an integer value in both sides.

pub fn simplify(&self) -> Equation

Simplify both sides.

pub fn expand(&self) -> Equation

Expand both sides.

pub fn eval(&self) -> Equation

Evaluate both sides.

pub fn is_satisfied(&self) -> Option<bool>

Check if the equation is satisfied (both sides mathematically equal).

Three-valued via Ex::equals; same as is_identity.

pub fn is_identity(&self) -> Option<bool>

Does the equation hold for all values of its symbols?

Some(true) when lhs − rhs simplifies to zero, Some(false) when the two sides are provably different (e.g. they differ by a nonzero constant), None when undetermined — see Ex::equals.

use symplex::prelude::*;

let ctx = Context::new();
let x = ctx.symbol("x");
let pyth = Equation::new(&x.sin().powi(2) + &x.cos().powi(2), ctx.one());
assert_eq!(pyth.is_identity(), Some(true));
assert_eq!(Equation::new(&x + 1, x.clone()).is_identity(), Some(false));
assert_eq!(Equation::new(x.clone(), ctx.int(3)).is_identity(), None);

pub fn to_expr(&self) -> Ex

Convert to a single expression lhs - rhs.

Trait Implementations

impl Add for Equation

type Output = Equation

The resulting type after applying the + operator.

fn add(self, rhs: Equation) -> Equation

Performs the + operation.

impl Add<&Equation> for &Equation

type Output = Equation

The resulting type after applying the + operator.

fn add(self, rhs: &Equation) -> Equation

Performs the + operation.

impl<T: ToEx> Add<T> for &Equation

type Output = Equation

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Equation

Performs the + operation.

impl<T: ToEx> Add<T> for Equation

type Output = Equation

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Equation

Performs the + operation.

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

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

Formats the value using the given formatter.

impl Div for Equation

type Output = Equation

The resulting type after applying the / operator.

fn div(self, rhs: Equation) -> Equation

Performs the / operation.

impl Div<&Equation> for &Equation

type Output = Equation

The resulting type after applying the / operator.

fn div(self, rhs: &Equation) -> Equation

Performs the / operation.

impl<T: ToEx> Div<T> for &Equation

type Output = Equation

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Equation

Performs the / operation.

impl<T: ToEx> Div<T> for Equation

type Output = Equation

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Equation

Performs the / operation.

impl Eq for Equation

impl Mul for Equation

type Output = Equation

The resulting type after applying the * operator.

fn mul(self, rhs: Equation) -> Equation

Performs the * operation.

impl Mul<&Equation> for &Equation

type Output = Equation

The resulting type after applying the * operator.

fn mul(self, rhs: &Equation) -> Equation

Performs the * operation.

impl<T: ToEx> Mul<T> for &Equation

type Output = Equation

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Equation

Performs the * operation.

impl<T: ToEx> Mul<T> for Equation

type Output = Equation

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Equation

Performs the * operation.

impl Neg for &Equation

type Output = Equation

The resulting type after applying the - operator.

fn neg(self) -> Equation

Performs the unary - operation.

impl Neg for Equation

type Output = Equation

The resulting type after applying the - operator.

fn neg(self) -> Equation

Performs the unary - operation.

impl PartialEq for Equation

Structural equality: both sides are the same arena nodes.

x + 1 = 5 and 1 + x = 5 are equal (same canonical form); x + 1 = 5 and x = 4 are not, even though they are equivalent.

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

Equality operator ==.

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

Inequality operator !=.

impl Sub for Equation

type Output = Equation

The resulting type after applying the - operator.

fn sub(self, rhs: Equation) -> Equation

Performs the - operation.

impl Sub<&Equation> for &Equation

type Output = Equation

The resulting type after applying the - operator.

fn sub(self, rhs: &Equation) -> Equation

Performs the - operation.

impl<T: ToEx> Sub<T> for &Equation

type Output = Equation

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Equation

Performs the - operation.

impl<T: ToEx> Sub<T> for Equation

type Output = Equation

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Equation

Performs the - operation.

impl ZeroForm for Equation

fn to_zero_form(&self) -> Ex

Return the expression that equals zero when the equation holds.