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);
}