Struct Rational 

pub struct Rational {
    pub num: isize,
    pub denom: isize,
}

Fields

num: isize

denom: isize

Implementations

impl Rational

pub fn new(num: isize, denom: isize) -> Self

pub fn new_box(num: isize, denom: isize) -> Box<dyn Expr>

pub fn one() -> Self

pub fn zero() -> Self

pub fn invert(&mut self)

impl Rational

pub fn from_float<N: Float + ToString>(value: N) -> Rational

Trait Implementations

impl Add<&Integer> for &Rational

type Output = Box<dyn Expr>

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> Self::Output

Performs the + operation.

impl Add<&Rational> for &Integer

type Output = Box<dyn Expr>

The resulting type after applying the + operator.

fn add(self, rhs: &Rational) -> Self::Output

Performs the + operation.

impl Add for &Rational

type Output = Rational

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl Add for Rational

type Output = Rational

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl AddAssign for Rational

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for Rational

fn clone(&self) -> Rational

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Rational

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

Formats the value using the given formatter.

impl Div for Rational

type Output = Rational

The resulting type after applying the / operator.

fn div(self, rhs: Rational) -> Self::Output

Performs the / operation.

impl DivAssign<&Rational> for Rational

fn div_assign(&mut self, rhs: &Rational)

Performs the /= operation.

impl DivAssign for Rational

fn div_assign(&mut self, rhs: Rational)

Performs the /= operation.

impl Expr for Rational

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

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 to_cpp(&self) -> String

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

fn is_one(&self) -> bool

fn is_zero(&self) -> bool

fn is_neg_one(&self) -> bool

fn is_number(&self) -> bool

fn is_negative_number(&self) -> bool

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

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

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 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 name(&self) -> String

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 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 From<&Rational> for (Rational, Box<dyn Expr>)

fn from(r: &Rational) -> Self

Converts to this type from the input type.

impl From<&Rational> for f64

fn from(_: &Rational) -> Self

Converts to this type from the input type.

impl From<&str> for Rational

fn from(value: &str) -> Self

Converts to this type from the input type.

impl<N: ToInteger> From<N> for Rational

fn from(value: N) -> Self

Converts to this type from the input type.

impl From<Rational> for f64

fn from(_: Rational) -> Self

Converts to this type from the input type.

impl FromStr for Rational

type Err = ParseRationalError

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<I: ToPrimitive> Mul<I> for Rational

type Output = Rational

The resulting type after applying the * operator.

fn mul(self, rhs: I) -> Self::Output

Performs the * operation.

impl Mul for Rational

type Output = Rational

The resulting type after applying the * operator.

fn mul(self, rhs: Rational) -> Self::Output

Performs the * operation.

impl<I: ToPrimitive> MulAssign<&I> for Rational

fn mul_assign(&mut self, rhs: &I)

Performs the *= operation.

impl MulAssign<&Rational> for Rational

fn mul_assign(&mut self, rhs: &Rational)

Performs the *= operation.

impl Neg for &Rational

type Output = Rational

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Ord for Rational

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<T: Copy + Into<Rational>> PartialEq<T> for Rational

fn eq(&self, other: &T) -> 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<T: Copy + Into<Rational>> PartialOrd<T> for Rational

fn partial_cmp(&self, other: &T) -> 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<N: NumCast> Sub<N> for Rational

type Output = Box<dyn Expr>

The resulting type after applying the - operator.

fn sub(self, rhs: N) -> Self::Output

Performs the - operation.

impl Sub for Rational

type Output = Rational

The resulting type after applying the - operator.

fn sub(self, rhs: Rational) -> Self::Output

Performs the - operation.

impl Copy for Rational

impl Eq for Rational