public override Operand Copy()
{
NaturalLog copy = new NaturalLog();
copy.LeftSuccessor = LeftSuccessor.Copy();
return(copy);
}
public override Operand Simplify()
{
Subtraction simplifiedExpression = new Subtraction();
simplifiedExpression.LeftSuccessor = LeftSuccessor.Simplify();
simplifiedExpression.RightSuccessor = RightSuccessor.Simplify();
if (simplifiedExpression.LeftSuccessor is Integer && !(simplifiedExpression.LeftSuccessor is PI)) // Left is not PI and a number.
{
// In this scenario the right sub tree can be an expression still.
if (simplifiedExpression.RightSuccessor is Integer && !(simplifiedExpression.RightSuccessor is PI)) // Right not PI and a number.
{
// We have 2 numbers so we can safely calculate.
double difference = Convert.ToDouble(simplifiedExpression.LeftSuccessor.Data) - Convert.ToDouble(simplifiedExpression.RightSuccessor.Data);
return(new RealNumber(difference));
}
// Left can be 0 and that means the right is negative and we leave the expression tree as 0 - right expression
// to not have to worry about unary or binary operator of subtraction.
}
else if (simplifiedExpression.RightSuccessor is Integer && !(simplifiedExpression.RightSuccessor is PI)) // Left was either an expression or it is PI.
{ // Thus we have to ensure that the Right is not PI or crash.
// This case means that left is not a number. And we thus should be
// able to return the negative of the right expression.
if (Convert.ToDouble(simplifiedExpression.RightSuccessor.Data) == 0.0)
{
return(simplifiedExpression.LeftSuccessor.Simplify());
}
}
return(simplifiedExpression);
}
/// <summary>
/// The quotient rule
///
/// (f / g)' = (gf' - g'f) / g^2
///
/// </summary>
/// <returns>A division operator object holding respective expressions.</returns>
public override Operand Differentiate()
{
// Create gf'
Multiplication leftNumerator = new Multiplication();
leftNumerator.LeftSuccessor = RightSuccessor.Copy();
leftNumerator.RightSuccessor = LeftSuccessor.Differentiate();
// Create g'f
Multiplication rightNumerator = new Multiplication();
rightNumerator.LeftSuccessor = RightSuccessor.Differentiate();
rightNumerator.RightSuccessor = LeftSuccessor.Copy();
// Create the numrator of previous terms gf' - g'f
Subtraction derivativeNumerator = new Subtraction();
derivativeNumerator.LeftSuccessor = leftNumerator;
derivativeNumerator.RightSuccessor = rightNumerator;
// Create g^2 of a new copy of g.
Power derivativeDenominator = new Power();
derivativeDenominator.LeftSuccessor = RightSuccessor.Copy();
derivativeDenominator.RightSuccessor = new Integer(2);
// Create the final result and assign. (f / g)' = (gf' - g'f) / g^2
Division derivative = new Division();
derivative.LeftSuccessor = derivativeNumerator;
derivative.RightSuccessor = derivativeDenominator;
return(derivative);
}
public override Operand Differentiate()
{
// (f(x))^b where b is a natural number even.
// The general power rule but combined with the
// chain rule. b * (f(x))^(b - 1) * f'(x)
// b
Operand power = RightSuccessor.Copy();
// b - 1
Integer newPower = new Integer(Convert.ToDouble(power.Data) - 1);
// f(x)^(b - 1)
Power onePowerLess = new Power();
onePowerLess.LeftSuccessor = LeftSuccessor.Copy();
onePowerLess.RightSuccessor = newPower;
// f'
Operand derivativeOfF = LeftSuccessor.Differentiate();
// b * f(x)^(b - 1)
Multiplication intermediaryResult = new Multiplication();
intermediaryResult.LeftSuccessor = power;
intermediaryResult.RightSuccessor = onePowerLess;
// (b * f(x)^(b - 1)) * f'
Multiplication derivative = new Multiplication();
derivative.LeftSuccessor = intermediaryResult;
derivative.RightSuccessor = derivativeOfF;
return(derivative);
}
public override Operand Simplify()
{
NaturalLog simplifiedExpression = new NaturalLog();
simplifiedExpression.LeftSuccessor = LeftSuccessor.Simplify();
return(simplifiedExpression);
}
public override Operand Simplify()
{
// Try to simplify as much as possible.
Division simplifiedExpression = new Division();
simplifiedExpression.LeftSuccessor = LeftSuccessor.Simplify();
simplifiedExpression.RightSuccessor = RightSuccessor.Simplify();
// When we divide by 1, we can just return
// the numerator of the division.
if (simplifiedExpression.RightSuccessor is Integer && !(simplifiedExpression.RightSuccessor is PI)) // If a number but not PI.
{
// The denominator = 1, thus we can return the numerator.
if (Convert.ToDouble(simplifiedExpression.RightSuccessor.Data) == 1) // If the number is 1, we simplify it to just the simplification of the left branch.
{
return(simplifiedExpression.LeftSuccessor.Simplify());
}
}
else if (simplifiedExpression.LeftSuccessor is Integer && !(simplifiedExpression.LeftSuccessor is PI)) // The right was either not a number or PI.
{ // We ensured that the left is not PI
// Check if the numerator is 0
// if so we can return a number 0.
if (Convert.ToDouble(simplifiedExpression.LeftSuccessor.Data) == 0.0)
{
return(new RealNumber(0.0));
}
}
return(simplifiedExpression);
}
public override Operand Copy()
{
Cosine copy = new Cosine();
copy.LeftSuccessor = LeftSuccessor.Copy();
return(copy);
}
public override Operand Copy()
{
Exp copy = new Exp();
copy.LeftSuccessor = LeftSuccessor.Copy();
return(copy);
}
public override Operand Simplify()
{
Cosine simplifiedExpression = new Cosine();
simplifiedExpression.LeftSuccessor = LeftSuccessor.Simplify();
return(simplifiedExpression);
}
public override Operand Simplify()
{
Addition simplifiedExpression = new Addition();
simplifiedExpression.LeftSuccessor = LeftSuccessor.Simplify();
simplifiedExpression.RightSuccessor = RightSuccessor.Simplify();
if (simplifiedExpression.LeftSuccessor is Integer && !(simplifiedExpression.LeftSuccessor is PI)) // Must not be PI or crash.
{
// If the right is also a number, we can simplify the two by calculating the result.
// and return a new operand object holding the result as data up to the previous call.
if (simplifiedExpression.RightSuccessor is Integer && !(simplifiedExpression.RightSuccessor is PI)) // Must not be PI or crash, or loss of info if we simplify perhaps.
{
// These will always be non PI numbers either int or real.
double addition = Convert.ToDouble(simplifiedExpression.LeftSuccessor.Data) + Convert.ToDouble(simplifiedExpression.RightSuccessor.Data);
return(new RealNumber(addition));
}
else if (Convert.ToDouble(simplifiedExpression.LeftSuccessor.Data) == 0.0) // This left is never PI, if it is 0 we can simplify right safely.
{
return(simplifiedExpression.RightSuccessor.Simplify());
}
}
else if (simplifiedExpression.RightSuccessor is Integer && !(simplifiedExpression.RightSuccessor is PI)) // Right must not be PI or it'll crash.
{
if (Convert.ToDouble(simplifiedExpression.RightSuccessor.Data) == 0)
{
return(simplifiedExpression.LeftSuccessor.Simplify());
}
}
return(simplifiedExpression);
}
public override bool Calculate()
{
bool leftResult = LeftSuccessor.Calculate();
bool rightResult = RightSuccessor.Calculate();
return(!(leftResult && rightResult));
}
public override Operand Copy()
{
Power copy = new Power();
copy.LeftSuccessor = LeftSuccessor.Copy();
copy.RightSuccessor = RightSuccessor.Copy();
return(copy);
}
public override Operand Copy()
{
Division copy = new Division();
copy.LeftSuccessor = LeftSuccessor.Copy();
copy.RightSuccessor = RightSuccessor.Copy();
return(copy);
}
public override Operand Copy()
{
Multiplication copy = new Multiplication();
copy.LeftSuccessor = LeftSuccessor.Copy();
copy.RightSuccessor = RightSuccessor.Copy();
return(copy);
}
public override Proposition Copy()
{
Negation copy = new Negation();
copy.LeftSuccessor = LeftSuccessor.Copy();
return(copy);
}
public override Operand Copy()
{
Subtraction copy = new Subtraction();
copy.LeftSuccessor = LeftSuccessor.Copy();
copy.RightSuccessor = RightSuccessor.Copy();
return(copy);
}
public override Proposition Copy()
{
Conjunction copy = new Conjunction();
copy.LeftSuccessor = LeftSuccessor.Copy();
copy.RightSuccessor = RightSuccessor.Copy();
return(copy);
}
/// <summary>
/// (f + g)' = f' + g'
/// Meaning we differentiate both the left and right sub tree first
/// and return an addition operator with the differentiated sub trees
/// as it's successors
/// </summary>
/// <returns>
/// An addition operator object with both left
/// and right successor differentiated.
/// </returns>
public override Operand Differentiate()
{
Addition derivative = new Addition();
derivative.LeftSuccessor = LeftSuccessor.Differentiate();
derivative.RightSuccessor = RightSuccessor.Differentiate();
return(derivative);
}
/// <summary>
/// This returns the result set of: (A\B) U (B\A) U (A Intersection B)
///
/// Example:
///
/// A = { A, B }
/// B = { A, C }
///
/// A\B = { B } || The elements that are in A but not in B
/// B\A = { C } || The elements that are in B but not in A
/// A Intersection B = { A } || The elements that are in both A and B
///
/// result = { B, C, A }! All unique variables from two different sets.
/// </summary>
/// <returns>A list representing the set of all unique variables in the proposition formula.</returns>
public override List <Proposition> GetVariables()
{
List <Proposition> leftChildVariables = LeftSuccessor.GetVariables();
List <Proposition> rightChildVariables = RightSuccessor.GetVariables();
return(leftChildVariables.Except(rightChildVariables). // Set difference gets applied { A } \ { B }
Union(rightChildVariables.Except(leftChildVariables)). // { B } \ { A }
Union(leftChildVariables.Intersect(rightChildVariables)).ToList()); // { A } Intersection { B }, resulting in a set containing all unique elements (unordered though)
}
public override Proposition Copy()
{
Nand copy = new Nand();
copy.LeftSuccessor = LeftSuccessor.Copy();
copy.RightSuccessor = RightSuccessor.Copy();
return(copy);
}
public override bool Calculate()
{
if (LeftSuccessor.Calculate() == true && (RightSuccessor.Calculate() == false))
{
return(false);
}
return(true);
}
public override Proposition Copy()
{
BiImplication copy = new BiImplication();
copy.LeftSuccessor = LeftSuccessor.Copy();
copy.RightSuccessor = RightSuccessor.Copy();
return(copy);
}
/// <summary>
/// (f - g)' = f'- g'
/// Meaning we differentiate both the left and right sub tree first
/// and return a subtraction operator with the differentiated sub trees
/// as it's successors
/// </summary>
/// <returns>
/// A subtraction operator object with both left
/// and right successor differentiated.
/// </returns>
public override Operand Differentiate()
{
Operand leftDerivative = LeftSuccessor.Differentiate();
Operand rightDerivative = RightSuccessor.Differentiate();
Subtraction derivative = new Subtraction();
derivative.LeftSuccessor = leftDerivative;
derivative.RightSuccessor = rightDerivative;
return(derivative);
}
public override Proposition Nandify()
{
if (LeftSuccessor.GetType() != typeof(Proposition))
{
LeftSuccessor = LeftSuccessor.Nandify();
}
if (RightSuccessor.GetType() != typeof(Proposition))
{
RightSuccessor = RightSuccessor.Nandify();
}
return(this);
}
public override string ToPrefixString()
{
if (LeftSuccessor == null || RightSuccessor == null)
{
throw new NullReferenceException("Both left and right successor must not be null!");
}
string result = $"{Data}(";
result += LeftSuccessor.ToPrefixString();
result += ", ";
result += RightSuccessor.ToPrefixString();
result += ")";
return(result);
}
public override Operand Differentiate()
{
// (e^u)' = e^u * u'
// e^u
Exp outerFunction = (Exp)Copy();
// u'
Operand innerDerivative = LeftSuccessor.Differentiate();
// e^u * u'
Multiplication derivative = new Multiplication();
derivative.LeftSuccessor = outerFunction;
derivative.RightSuccessor = innerDerivative;
return(derivative);
}
public override string ToPrefixString()
{
if (LeftSuccessor == null)
{
throw new NullReferenceException("A predicate is required to be set");
}
string result = $"{Data}{GetBoundVariable()}.";
result += "(";
result += LeftSuccessor.ToPrefixString();
result += ")";
return(result);
}
public override Operand Simplify()
{
if (!(RightSuccessor is PI)) // Ensure the power is not PI or it would crash.
{
if (Convert.ToDouble(RightSuccessor.Data) == 1.0) // If it's 1 we return the simplified version of left.
{
return(LeftSuccessor.Simplify());
}
return(Copy()); // Otherwise just the copy.
}
else // All other cases, just return the copy.
{
return(Copy());
}
}
public override Proposition Nandify()
{
// ~(A) == ~(A & A) == A % A
Nand nand = new Nand();
Proposition nandifiedLeft = LeftSuccessor;
if (LeftSuccessor.GetType() != typeof(Proposition))
{
nandifiedLeft = LeftSuccessor.Nandify();
}
nand.LeftSuccessor = nandifiedLeft;
nand.RightSuccessor = nandifiedLeft;
return(nand);
}
public override Operand Differentiate()
{
// Derivative of sin(u) = cos(u) * u'
// c(u)
Cosine outerDerivative = new Cosine();
outerDerivative.LeftSuccessor = LeftSuccessor.Copy();
// Now for u' we call it's differentiate method.
Operand innerDerivative = LeftSuccessor.Differentiate();
// c(u) * u'
Multiplication derivative = new Multiplication();
derivative.LeftSuccessor = outerDerivative;
derivative.RightSuccessor = innerDerivative;
return(derivative);
}
