third_party/rust_crates/vendor/cassowary/src/operators.rs

use ::std::ops;
use {
    Term,
    Variable,
    Expression,
    WeightedRelation,
    PartialConstraint,
    Constraint
};

// Relation

impl ops::BitOr<WeightedRelation> for f64 {
    type Output = PartialConstraint;
    fn bitor(self, r: WeightedRelation) -> PartialConstraint {
        PartialConstraint(self.into(), r)
    }
}
impl ops::BitOr<WeightedRelation> for f32 {
    type Output = PartialConstraint;
    fn bitor(self, r: WeightedRelation) -> PartialConstraint {
        (self as f64).bitor(r)
    }
}
impl ops::BitOr<WeightedRelation> for Variable {
    type Output = PartialConstraint;
    fn bitor(self, r: WeightedRelation) -> PartialConstraint {
        PartialConstraint(self.into(), r)
    }
}
impl ops::BitOr<WeightedRelation> for Term {
    type Output = PartialConstraint;
    fn bitor(self, r: WeightedRelation) -> PartialConstraint {
        PartialConstraint(self.into(), r)
    }
}
impl ops::BitOr<WeightedRelation> for Expression {
    type Output = PartialConstraint;
    fn bitor(self, r: WeightedRelation) -> PartialConstraint {
        PartialConstraint(self.into(), r)
    }
}

impl ops::BitOr<f64> for PartialConstraint {
    type Output = Constraint;
    fn bitor(self, rhs: f64) -> Constraint {
        let (op, s) = self.1.into();
        Constraint::new(self.0 - rhs, op, s)
    }
}
impl ops::BitOr<f32> for PartialConstraint {
    type Output = Constraint;
    fn bitor(self, rhs: f32) -> Constraint {
        self.bitor(rhs as f64)
    }
}
impl ops::BitOr<Variable> for PartialConstraint {
    type Output = Constraint;
    fn bitor(self, rhs: Variable) -> Constraint {
        let (op, s) = self.1.into();
        Constraint::new(self.0 - rhs, op, s)
    }
}
impl ops::BitOr<Term> for PartialConstraint {
    type Output = Constraint;
    fn bitor(self, rhs: Term) -> Constraint {
        let (op, s) = self.1.into();
        Constraint::new(self.0 - rhs, op, s)
    }
}
impl ops::BitOr<Expression> for PartialConstraint {
    type Output = Constraint;
    fn bitor(self, rhs: Expression) -> Constraint {
        let (op, s) = self.1.into();
        Constraint::new(self.0 - rhs, op, s)
    }
}

// Variable

impl ops::Add<f64> for Variable {
    type Output = Expression;
    fn add(self, v: f64) -> Expression {
        Expression::new(vec![Term::new(self, 1.0)], v)
    }
}

impl ops::Add<f32> for Variable {
    type Output = Expression;
    fn add(self, v: f32) -> Expression {
        self.add(v as f64)
    }
}

impl ops::Add<Variable> for f64 {
    type Output = Expression;
    fn add(self, v: Variable) -> Expression {
        Expression::new(vec![Term::new(v, 1.0)], self)
    }
}

impl ops::Add<Variable> for f32 {
    type Output = Expression;
    fn add(self, v: Variable) -> Expression {
        (self as f64).add(v)
    }
}

impl ops::Add<Variable> for Variable {
    type Output = Expression;
    fn add(self, v: Variable) -> Expression {
        Expression::new(vec![Term::new(self, 1.0), Term::new(v, 1.0)], 0.0)
    }
}

impl ops::Add<Term> for Variable {
    type Output = Expression;
    fn add(self, t: Term) -> Expression {
        Expression::new(vec![Term::new(self, 1.0), t], 0.0)
    }
}

impl ops::Add<Variable> for Term {
    type Output = Expression;
    fn add(self, v: Variable) -> Expression {
        Expression::new(vec![self, Term::new(v, 1.0)], 0.0)
    }
}

impl ops::Add<Expression> for Variable {
    type Output = Expression;
    fn add(self, mut e: Expression) -> Expression {
        e.terms.push(Term::new(self, 1.0));
        e
    }
}

impl ops::Add<Variable> for Expression {
    type Output = Expression;
    fn add(mut self, v: Variable) -> Expression {
        self.terms.push(Term::new(v, 1.0));
        self
    }
}

impl ops::Neg for Variable {
    type Output = Term;
    fn neg(self) -> Term {
        Term::new(self, -1.0)
    }
}

impl ops::Sub<f64> for Variable {
    type Output = Expression;
    fn sub(self, v: f64) -> Expression {
        Expression::new(vec![Term::new(self, 1.0)], -v)
    }
}

impl ops::Sub<f32> for Variable {
    type Output = Expression;
    fn sub(self, v: f32) -> Expression {
        self.sub(v as f64)
    }
}

impl ops::Sub<Variable> for f64 {
    type Output = Expression;
    fn sub(self, v: Variable) -> Expression {
        Expression::new(vec![Term::new(v, -1.0)], self)
    }
}

impl ops::Sub<Variable> for f32 {
    type Output = Expression;
    fn sub(self, v: Variable) -> Expression {
        (self as f64).sub(v)
    }
}

impl ops::Sub<Variable> for Variable {
    type Output = Expression;
    fn sub(self, v: Variable) -> Expression {
        Expression::new(vec![Term::new(self, 1.0), Term::new(v, -1.0)], 0.0)
    }
}

impl ops::Sub<Term> for Variable {
    type Output = Expression;
    fn sub(self, t: Term) -> Expression {
        Expression::new(vec![Term::new(self, 1.0), -t], 0.0)
    }
}

impl ops::Sub<Variable> for Term {
    type Output = Expression;
    fn sub(self, v: Variable) -> Expression {
        Expression::new(vec![self, Term::new(v, -1.0)], 0.0)
    }
}

impl ops::Sub<Expression> for Variable {
    type Output = Expression;
    fn sub(self, mut e: Expression) -> Expression {
        e.negate();
        e.terms.push(Term::new(self, 1.0));
        e
    }
}

impl ops::Sub<Variable> for Expression {
    type Output = Expression;
    fn sub(mut self, v: Variable) -> Expression {
        self.terms.push(Term::new(v, -1.0));
        self
    }
}

impl ops::Mul<f64> for Variable {
    type Output = Term;
    fn mul(self, v: f64) -> Term {
        Term::new(self, v)
    }
}

impl ops::Mul<f32> for Variable {
    type Output = Term;
    fn mul(self, v: f32) -> Term {
        self.mul(v as f64)
    }
}

impl ops::Mul<Variable> for f64 {
    type Output = Term;
    fn mul(self, v: Variable) -> Term {
        Term::new(v, self)
    }
}

impl ops::Mul<Variable> for f32 {
    type Output = Term;
    fn mul(self, v: Variable) -> Term {
        (self as f64).mul(v)
    }
}

impl ops::Div<f64> for Variable {
    type Output = Term;
    fn div(self, v: f64) -> Term {
        Term::new(self, 1.0 / v)
    }
}

impl ops::Div<f32> for Variable {
    type Output = Term;
    fn div(self, v: f32) -> Term {
        self.div(v as f64)
    }
}

// Term

impl ops::Mul<f64> for Term {
    type Output = Term;
    fn mul(mut self, v: f64) -> Term {
        self.coefficient *= v;
        self
    }
}

impl ops::Mul<f32> for Term {
    type Output = Term;
    fn mul(self, v: f32) -> Term {
        self.mul(v as f64)
    }
}

impl ops::Mul<Term> for f64 {
    type Output = Term;
    fn mul(self, mut t: Term) -> Term {
        t.coefficient *= self;
        t
    }
}

impl ops::Mul<Term> for f32 {
    type Output = Term;
    fn mul(self, t: Term) -> Term {
        (self as f64).mul(t)
    }
}

impl ops::Div<f64> for Term {
    type Output = Term;
    fn div(mut self, v: f64) -> Term {
        self.coefficient /= v;
        self
    }
}

impl ops::Div<f32> for Term {
    type Output = Term;
    fn div(self, v: f32) -> Term {
        self.div(v as f64)
    }
}

impl ops::Add<f64> for Term {
    type Output = Expression;
    fn add(self, v: f64) -> Expression {
        Expression::new(vec![self], v)
    }
}

impl ops::Add<f32> for Term {
    type Output = Expression;
    fn add(self, v: f32) -> Expression {
        self.add(v as f64)
    }
}

impl ops::Add<Term> for f64 {
    type Output = Expression;
    fn add(self, t: Term) -> Expression {
        Expression::new(vec![t], self)
    }
}

impl ops::Add<Term> for f32 {
    type Output = Expression;
    fn add(self, t: Term) -> Expression {
        (self as f64).add(t)
    }
}

impl ops::Add<Term> for Term {
    type Output = Expression;
    fn add(self, t: Term) -> Expression {
        Expression::new(vec![self, t], 0.0)
    }
}

impl ops::Add<Expression> for Term {
    type Output = Expression;
    fn add(self, mut e: Expression) -> Expression {
        e.terms.push(self);
        e
    }
}

impl ops::Add<Term> for Expression {
    type Output = Expression;
    fn add(mut self, t: Term) -> Expression {
        self.terms.push(t);
        self
    }
}

impl ops::Neg for Term {
    type Output = Term;
    fn neg(mut self) -> Term {
        self.coefficient = -self.coefficient;
        self
    }
}

impl ops::Sub<f64> for Term {
    type Output = Expression;
    fn sub(self, v: f64) -> Expression {
        Expression::new(vec![self], -v)
    }
}

impl ops::Sub<f32> for Term {
    type Output = Expression;
    fn sub(self, v: f32) -> Expression {
        self.sub(v as f64)
    }
}

impl ops::Sub<Term> for f64 {
    type Output = Expression;
    fn sub(self, t: Term) -> Expression {
        Expression::new(vec![-t], self)
    }
}

impl ops::Sub<Term> for f32 {
    type Output = Expression;
    fn sub(self, t: Term) -> Expression {
        (self as f64).sub(t)
    }
}

impl ops::Sub<Term> for Term {
    type Output = Expression;
    fn sub(self, t: Term) -> Expression {
        Expression::new(vec![self, -t], 0.0)
    }
}

impl ops::Sub<Expression> for Term {
    type Output = Expression;
    fn sub(self, mut e: Expression) -> Expression {
        e.negate();
        e.terms.push(self);
        e
    }
}

impl ops::Sub<Term> for Expression {
    type Output = Expression;
    fn sub(mut self, t: Term) -> Expression {
        self.terms.push(-t);
        self
    }
}

// Expression

impl ops::Mul<f64> for Expression {
    type Output = Expression;
    fn mul(mut self, v: f64) -> Expression {
        self.constant *= v;
        for t in &mut self.terms {
            *t = *t * v;
        }
        self
    }
}

impl ops::Mul<f32> for Expression {
    type Output = Expression;
    fn mul(self, v: f32) -> Expression {
        self.mul(v as f64)
    }
}

impl ops::Mul<Expression> for f64 {
    type Output = Expression;
    fn mul(self, mut e: Expression) -> Expression {
        e.constant *= self;
        for t in &mut e.terms {
            *t = *t * self;
        }
        e
    }
}

impl ops::Mul<Expression> for f32 {
    type Output = Expression;
    fn mul(self, e: Expression) -> Expression {
        (self as f64).mul(e)
    }
}

impl ops::Div<f64> for Expression {
    type Output = Expression;
    fn div(mut self, v: f64) -> Expression {
        self.constant /= v;
        for t in &mut self.terms {
            *t = *t / v;
        }
        self
    }
}

impl ops::Div<f32> for Expression {
    type Output = Expression;
    fn div(self, v: f32) -> Expression {
        self.div(v as f64)
    }
}

impl ops::Add<f64> for Expression {
    type Output = Expression;
    fn add(mut self, v: f64) -> Expression {
        self.constant += v;
        self
    }
}

impl ops::Add<f32> for Expression {
    type Output = Expression;
    fn add(self, v: f32) -> Expression {
        self.add(v as f64)
    }
}

impl ops::Add<Expression> for f64 {
    type Output = Expression;
    fn add(self, mut e: Expression) -> Expression {
        e.constant += self;
        e
    }
}

impl ops::Add<Expression> for f32 {
    type Output = Expression;
    fn add(self, e: Expression) -> Expression {
        (self as f64).add(e)
    }
}

impl ops::Add<Expression> for Expression {
    type Output = Expression;
    fn add(mut self, mut e: Expression) -> Expression {
        self.terms.append(&mut e.terms);
        self.constant += e.constant;
        self
    }
}

impl ops::Neg for Expression {
    type Output = Expression;
    fn neg(mut self) -> Expression {
        self.negate();
        self
    }
}

impl ops::Sub<f64> for Expression {
    type Output = Expression;
    fn sub(mut self, v: f64) -> Expression {
        self.constant -= v;
        self
    }
}

impl ops::Sub<f32> for Expression {
    type Output = Expression;
    fn sub(self, v: f32) -> Expression {
        self.sub(v as f64)
    }
}

impl ops::Sub<Expression> for f64 {
    type Output = Expression;
    fn sub(self, mut e: Expression) -> Expression {
        e.negate();
        e.constant += self;
        e
    }
}

impl ops::Sub<Expression> for f32 {
    type Output = Expression;
    fn sub(self, e: Expression) -> Expression {
        (self as f64).sub(e)
    }
}

impl ops::Sub<Expression> for Expression {
    type Output = Expression;
    fn sub(mut self, mut e: Expression) -> Expression {
        e.negate();
        self.terms.append(&mut e.terms);
        self.constant += e.constant;
        self
    }
}