public AlgebExpression(AlgebExpression tree)
{
left = tree.left; op = tree.op; right = tree.right; value = tree.value;
}
/// <summary>
/// only for multiplication canceling
/// </summary>
/// <param name="right"></param>
/// <returns></returns>
private bool CanCancelWith(AlgebExpression tree)
{
if (this.IsDivisibleBy(tree))
return true;
else if (this.op == Operation.Value || tree.op == Operation.Value)
return false;
if (this.op == Operation.Multiplication)
return this.left.CanCancelWith(tree)
|| this.right.CanCancelWith(tree);
if (tree.op == Operation.Multiplication)
return tree.CanCancelWith(this.right)
|| tree.CanCancelWith(this.left);
return false;
}
private bool IsPartOf(AlgebExpression bigTree)
{
if (this == bigTree)
return true;
if (bigTree.op == Operation.Value)
return false;
return
this.IsPartOf(bigTree.left)
|| this.IsPartOf(bigTree.right);
}
public AlgebExpression(AlgebExpression l, Operation o, AlgebExpression r)
{
left = l; op = o; right = r;
}
public bool IsDivisibleBy(AlgebExpression tree)
{
if (tree == null || this == null)
return false;
if (this.op == Operation.Value && tree.op == Operation.Value && this.value.Value.Pow >= tree.value.Value.Pow)
return this.value.Value.Pow >= tree.value.Value.Pow;
if (this.op == Operation.Value)
return false;
if (this == tree)
return true;
else
{
if (this.op == Operation.Multiplication)
return
this.left.IsDivisibleBy(tree)
|| this.right.IsDivisibleBy(tree);
if (this.op == Operation.Addition || this.op == Operation.Subtraction)
{
var newThis = this.SubtructionToNegAddition();
tree = tree.SubtructionToNegAddition();
return (newThis.left.IsDivisibleBy(tree)
&& newThis.right.IsDivisibleBy(tree));
}
}
return false;
}
private static AlgebExpression SimplifyDivsion(AlgebExpression currTree, ref AlgebExpression bigTree, bool rtnBig)
{
if (currTree.op == Operation.Value)
return currTree;
currTree.left = SimplifyDivsion(currTree.left, ref bigTree, false);
currTree.right = SimplifyDivsion(currTree.right, ref bigTree, false);
if (currTree.op == Operation.Division)
{
if (currTree.left.IsDivisibleBy(currTree.right))
return SimplifyDivsion((currTree.left / currTree.right), ref bigTree, false);
if (currTree.IsPartOf(bigTree))
bigTree = (bigTree * currTree.right).Factor();
}
return rtnBig ? bigTree : currTree;
}
public AlgebExpression SimplifyMultiplication()
{
if (op == Operation.Value)
return this;
left = left.SimplifyMultiplication();
right = right.SimplifyMultiplication();
if (op == Operation.Multiplication)
return left * right;
return this;
}
public AlgebExpression SubtructionToNegAddition()
{
if (this.op == Operation.Value)
return value;
this.left = left.SubtructionToNegAddition();
this.right = right.SubtructionToNegAddition();
if (this.op == Operation.Subtraction)
return new AlgebExpression(left, Operation.Addition, right * -1);
return this;
}
public AlgebExpression LeftAlignAddition()
{
if (this.op == Operation.Equality)
{
var leftleft = left.LeftAlignAddition();
return new AlgebExpression(this.left.LeftAlignAddition(), Operation.Equality, right.LeftAlignAddition());
}
if (this.op == Operation.Value)
return this;
if (this.op != Operation.Addition)
throw new InvalidOperationException("to align addition all ops must be addition");
if (this.right.op == Operation.Value)
return left.LeftAlignAddition() + right;
if (this.left.op == Operation.Value)
return right.LeftAlignAddition() + left;
if (left.op == Operation.Addition && right.op == Operation.Addition)
{
left = left.LeftAlignAddition();
right = right.LeftAlignAddition();
if (this.right.op == Operation.Value)
return left.LeftAlignAddition() + right;
if (this.left.op == Operation.Value)
return right.LeftAlignAddition() + left;
return new AlgebExpression
(((left.left + right.right)
+ left.right)
+ right.left)
.LeftAlignAddition();
}
else
{
throw new InvalidOperationException("to align addition all ops must be addition");
}
throw new Exception("sumthing went wrong");
}
