public override Term CheckAddReduce(Term t) { if (t.GetType() == typeof(Real)) { return(new Real((IsAddInverse ? -1 : 1) * Value + (t.IsAddInverse ? -1 : 1) * ((Real)t).Value)); } return(null); }
public override Term Reduce() { // cases to handle: // 1.) inner is power // 2.) inner is equal to base // 3.) inner is multiplication or division ? (this should probably not be reduced) Term inner = Parameters[0].Reduce(); if (inner.GetType() == typeof(Power)) { Function finner = inner as Function; if (Parameters.Length > 1) { return((finner.Parameters[1] * new Logarithm(IsAddInverse, IsMulInverse, finner.Parameters[0], Parameters[1].Reduce())).Reduce()); } else { return((finner.Parameters[1] * new Logarithm(IsAddInverse, IsMulInverse, finner.Parameters[0])).Reduce()); } } if (inner.Type == TermType.Symbol) { if (Parameters.Length == 1) { if (Parameters[0].GetType() == typeof(Constant) && ((Constant)Parameters[0]).Name == Constant.ConstType.E) { return(1); } } else { if (Parameters[1].Reduce() == inner) { return(1); } } } if (Parameters.Length > 1) { return(new Logarithm(IsAddInverse, IsMulInverse, inner, Parameters[1].Reduce())); } else { return(new Logarithm(IsAddInverse, IsMulInverse, inner)); } }
public override Term CheckAddReduce(Term t) { if (t.GetType() == typeof(Logarithm)) { Logarithm tAsLogarithm = t as Logarithm; if (Parameters.Length == 1 && tAsLogarithm.Parameters.Length == 1) { return(new Logarithm((Parameters[0] * tAsLogarithm.Parameters[0]).Reduce())); } else if (Parameters.Length == 2 && tAsLogarithm.Parameters.Length == 2 && Parameters[1] == tAsLogarithm.Parameters[1]) { return(new Logarithm((Parameters[0] * tAsLogarithm.Parameters[0]).Reduce(), Parameters[1])); } } return(null); }
public override Term CheckAddReduce(Term t) { if (t.GetType() == typeof(Variable)) { if (((Variable)t).Name == Name) { if (t.IsAddInverse && IsAddInverse) { return(2 * t); } if (t.IsAddInverse || IsAddInverse) { return(0); } return(2 * t); } } return(null); }
public override Term CheckAddReduce(Term t) { if (t.GetType() == typeof(Constant)) { if (((Constant)t).Name == this.Name) { if (t.IsAddInverse && IsAddInverse) { return(2 * t); } if (t.IsAddInverse || IsAddInverse) { return(0); } return(2 * t); } } return(null); }
public override Term CheckAddReduce(Term t) { if (t.GetType() == typeof(Multiplication)) { Multiplication cMult = (Multiplication)t; List <Term> a = Parameters.ToList(), b = cMult.Parameters.ToList(); List <Term> commonTerms = new List <Term>(); for (int i = 0; i < a.Count; i++) { for (int k = 0; k < b.Count; k++) { if (a[i] == b[k]) { commonTerms.Add(a[i]); a.RemoveAt(i); b.RemoveAt(k); i--; break; } } } if (a.Count == 0) { a.Add(1); } if (b.Count == 0) { a.Add(1); } commonTerms.Add(new Addition((a.Count == 1) ? a[0] : new Multiplication(a.ToArray()), (b.Count == 1) ? b[0] : new Multiplication(b.ToArray())).Reduce()); for (int i = 0; i < commonTerms.Count; i++) { if (commonTerms[i].GetType() == typeof(Real) && ((Real)commonTerms[i]).Value == 0) { return(0); } } if (commonTerms.Count == 1) { Term term = commonTerms[0]; if (IsMulInverse) { term.IsMulInverse = !commonTerms[0].IsMulInverse; } if (IsMulInverse) { term.IsAddInverse = !commonTerms[0].IsAddInverse; } return(term); } return(new Multiplication(IsAddInverse, IsMulInverse, commonTerms.ToArray())); } if (Parameters.Any(x => x == t)) { IEnumerable <Term> terms = Parameters.Where(x => x != t); return(new Multiplication(IsAddInverse, IsMulInverse, t, new Addition(terms.Count() > 1 ? new Multiplication(terms.ToArray()) : terms.First(), 1).Reduce())); } return(null); }