anchor.diff:    Constraint _createConstraint(
         EquationMember /* rhs */ value, Relation relation) {
       if (value is ConstantMember) {
  -      return new Constraint(new Expression(
  -          new List.from(this.terms), this.constant - value.value), relation);
  +      return new Constraint(
  +          new Expression(new List.from(terms), constant - value.value),
  +          relation);
       }
   
       if (value is Variable) {
  -      var newTerms = new List<Term>.from(this.terms)
  -        ..add(new Term(value, -1.0));
  -      return new Constraint(new Expression(newTerms, this.constant), relation);
  +      var newTerms = new List<Term>.from(terms)..add(new Term(value, -1.0));
  +      return new Constraint(new Expression(newTerms, constant), relation);
       }
   
       if (value is Term) {
  -      var newTerms = new List<Term>.from(this.terms)
  +      var newTerms = new List<Term>.from(terms)
           ..add(new Term(value.variable, -value.coefficient));
  -      return new Constraint(new Expression(newTerms, this.constant), relation);
  +      return new Constraint(new Expression(newTerms, constant), relation);
       }
   
       if (value is Expression) {
  -      var newTerms = value.terms.fold(new List<Term>.from(this.terms),
  +      var newTerms = value.terms.fold(new List<Term>.from(terms),
             (list, t) => list..add(new Term(t.variable, -t.coefficient)));
         return new Constraint(
  -          new Expression(newTerms, this.constant - value.constant), relation);
  +          new Expression(newTerms, constant - value.constant), relation);
       }
   
       assert(false);
  
positive.code: 
    Expression operator -(EquationMember m) {
      if (m is ConstantMember) {
        return new Expression(new List.from(this.terms), this.constant - m.value);
      }
  
      if (m is Variable) {
        return new Expression(
            new List.from(this.terms)..add(new Term(m, -1.0)), this.constant);
      }
  
      if (m is Term) {
        return new Expression(new List.from(this.terms)
          ..add(new Term(m.variable, -m.coefficient)), this.constant);
      }
  
      if (m is Expression) {
        var copiedTerms = new List<Term>.from(this.terms);
        m.terms.forEach(
            (t) => copiedTerms.add(new Term(t.variable, -t.coefficient)));
        return new Expression(copiedTerms, this.constant - m.constant);
      }
  
      assert(false);
  
negative.code:   }
  
    EquationMember operator *(double m) {
      var newTerms = terms.fold(new List<Term>(), (list, term) => list
        ..add(new Term(term.variable, term.coefficient * m)));
      return new Expression(newTerms, constant * m);
    }
  
    EquationMember operator /(double m) {
      var newTerms = terms.fold(new List<Term>(), (list, term) => list
        ..add(new Term(term.variable, term.coefficient / m)));
      return new Expression(newTerms, constant / m);
    }
  }
  