public static bool O3(List<MathObject> uElts, List<MathObject> vElts)
{
if (uElts.IsEmpty()) return true;
if (vElts.IsEmpty()) return false;
var u = uElts.First();
var v = vElts.First();
return (!(u == v)) ?
Compare(u, v) :
O3(uElts.Cdr(), vElts.Cdr());
}
public static bool equal(List<MathObject> a, List<MathObject> b)
{
if (a.Count == 0 && b.Count == 0) return true;
if (a.Count == 0) return false;
if (b.Count == 0) return false;
if (a[0] == b[0]) return equal(a.Cdr(), b.Cdr());
return false;
}
//////////////////////////////////////////////////////////////////////
static List<MathObject> MergeSums(List<MathObject> pElts, List<MathObject> qElts)
{
if (pElts.Count == 0) return qElts;
if (qElts.Count == 0) return pElts;
var p = pElts[0];
var ps = pElts.Cdr();
var q = qElts[0];
var qs = qElts.Cdr();
var res = RecursiveSimplify(new List<MathObject>() { p, q });
if (res.Count == 0) return MergeSums(ps, qs);
if (res.Count == 1) return MergeSums(ps, qs).Cons(res[0]);
if (ListUtils.equal(res, new List<MathObject>() { p, q }))
return MergeSums(ps, qElts).Cons(p);
if (ListUtils.equal(res, new List<MathObject>() { q, p }))
return MergeSums(pElts, qs).Cons(q);
throw new Exception();
}
static List<MathObject> RecursiveSimplify(List<MathObject> elts)
{
if (elts.Count == 2)
{
if (elts[0] is Sum && elts[1] is Sum)
return MergeSums(
((Sum)elts[0]).elts,
((Sum)elts[1]).elts);
if (elts[0] is Sum)
return MergeSums(
((Sum)elts[0]).elts,
new List<MathObject>() { elts[1] });
if (elts[1] is Sum)
return MergeSums(
new List<MathObject>() { elts[0] },
((Sum)elts[1]).elts);
//////////////////////////////////////////////////////////////////////
if (elts[0] is DoubleFloat && elts[1] is Number)
return SimplifyDoubleNumberSum((DoubleFloat)elts[0], (Number)elts[1]);
if (elts[0] is Number && elts[1] is DoubleFloat)
return SimplifyDoubleNumberSum((DoubleFloat)elts[1], (Number)elts[0]);
//////////////////////////////////////////////////////////////////////
if ((elts[0] is Integer || elts[0] is Fraction)
&&
(elts[1] is Integer || elts[1] is Fraction))
{
var P =
Rational.SimplifyRNE(new Sum(elts[0], elts[1]));
if (P is Integer && ((Integer)P).val == 0)
return new List<MathObject>() { };
return new List<MathObject>() { P };
}
if (elts[0] is Integer && elts[1] is Integer)
{
var res = ((Integer)elts[0]).val + ((Integer)elts[1]).val;
return res == 0 ?
new List<MathObject>() :
new List<MathObject>() { new Integer(res) };
}
if (elts[0] is Integer && ((Integer)elts[0]).val == 0)
return new List<MathObject>() { elts[1] };
if (elts[1] is Integer && ((Integer)elts[1]).val == 0)
return new List<MathObject>() { elts[0] };
var p = elts[0];
var q = elts[1];
if (OrderRelation.Term(p) == OrderRelation.Term(q))
{
var res =
new Product(
OrderRelation.Term(p),
new Sum(
OrderRelation.Const(p),
OrderRelation.Const(q)).Simplify()
).Simplify();
if (res is Integer && ((Integer)res).val == 0)
return new List<MathObject>() { };
else
return new List<MathObject>() { res };
}
if (OrderRelation.Compare(q, p))
return new List<MathObject>() { q, p };
return new List<MathObject>() { p, q };
}
if (elts[0] is Sum)
return
MergeSums(
((Sum)elts[0]).elts, RecursiveSimplify(elts.Cdr()));
return MergeSums(
new List<MathObject>() { elts[0] }, RecursiveSimplify(elts.Cdr()));
}
public static List<MathObject> RecursiveSimplify(List<MathObject> elts)
{
if (elts.Count == 2)
{
if (elts[0] is Product && elts[1] is Product)
return MergeProducts(
((Product)elts[0]).elts,
((Product)elts[1]).elts);
if (elts[0] is Product)
return MergeProducts(
((Product)elts[0]).elts,
new List<MathObject>() { elts[1] });
if (elts[1] is Product)
return MergeProducts(
new List<MathObject>() { elts[0] },
((Product)elts[1]).elts);
//////////////////////////////////////////////////////////////////////
if (elts[0] is DoubleFloat && elts[1] is Number)
return SimplifyDoubleNumberProduct((DoubleFloat)elts[0], (Number)elts[1]);
if (elts[0] is Number && elts[1] is DoubleFloat)
return SimplifyDoubleNumberProduct((DoubleFloat)elts[1], (Number)elts[0]);
//////////////////////////////////////////////////////////////////////
if ((elts[0] is Integer || elts[0] is Fraction)
&&
(elts[1] is Integer || elts[1] is Fraction))
{
var P =
Rational.SimplifyRNE(new Product(elts[0], elts[1]));
if (P is Integer && ((Integer)P).val == 1)
return new List<MathObject>() { };
return new List<MathObject>() { P };
}
if (elts[0] == new Integer(1))
return new List<MathObject>() { elts[1] };
if (elts[1] == new Integer(1))
return new List<MathObject>() { elts[0] };
var p = elts[0];
var q = elts[1];
if (OrderRelation.Base(p) == OrderRelation.Base(q))
{
var res = OrderRelation.Base(p) ^ (OrderRelation.Exponent(p) + OrderRelation.Exponent(q));
if (res is Integer && ((Integer)res).val == 1)
return new List<MathObject>() { };
else
return new List<MathObject>() { res };
}
if (OrderRelation.Compare(q, p))
return new List<MathObject>() { q, p };
return new List<MathObject>() { p, q };
}
if (elts[0] is Product)
return
MergeProducts(
((Product)elts[0]).elts,
RecursiveSimplify(elts.Cdr()));
return MergeProducts(
new List<MathObject>() { elts[0] },
RecursiveSimplify(elts.Cdr()));
throw new Exception();
}
