public void ExecuteTest6()
{
var exp = new Div(new Sqrt(new Number(-16)), new Number(2));
var expected = new Complex(0, 2);
Assert.Equal(expected, exp.Execute());
}
public void ExecuteTest3()
{
var exp = new Div(new Number(3), new ComplexNumber(2, 4));
var expected = new Complex(0.3, -0.6);
Assert.Equal(expected, exp.Execute());
}
public void ExecuteTest4()
{
var exp = new Div(new ComplexNumber(3, 2), new Number(2));
var expected = new Complex(1.5, 1);
Assert.Equal(expected, exp.Execute());
}
public void ExecuteTest2()
{
var exp = new Div(new ComplexNumber(3, 2), new ComplexNumber(2, 4));
var expected = new Complex(0.7, -0.4);
Assert.Equal(expected, exp.Execute());
}
public void PartialDerivativeTest1()
{
// (y + x ^ 2) / x
IExpression exp = new Div(new Add(new Variable("y"), new Pow(new Variable("x"), new Number(2))), new Variable("x"));
IExpression deriv = exp.Differentiate();
Assert.AreEqual("(((1 * (2 * (x ^ (2 - 1)))) * x) - ((y + (x ^ 2)) * 1)) / (x ^ 2)", deriv.ToString());
}
public void DerivativeTest1()
{
IExpression exp = new Div(new Number(1), new Variable("x"));
IExpression deriv = exp.Differentiate();
Assert.AreEqual("-(1 * 1) / (x ^ 2)", deriv.ToString());
}
public void DerivativeTest2()
{
// sin(x) / x
IExpression exp = new Div(new Sin(new Variable("x")), new Variable("x"));
IExpression deriv = exp.Differentiate();
Assert.AreEqual("(((cos(x) * 1) * x) - (sin(x) * 1)) / (x ^ 2)", deriv.ToString());
}
public void ResultTypeComplexNumberComplexNumberTest()
{
var exp = new Div(new ComplexNumber(3, 2), new ComplexNumber(2, 4));
Assert.Equal(ExpressionResultType.Number | ExpressionResultType.ComplexNumber, exp.LeftType);
Assert.Equal(ExpressionResultType.Number | ExpressionResultType.ComplexNumber, exp.RightType);
Assert.Equal(ExpressionResultType.ComplexNumber, exp.ResultType);
}
public void DerivativeTest3()
{
// (2x) / (3x)
Number num1 = new Number(2);
Variable x = new Variable("x");
Mul mul1 = new Mul(num1, x);
Number num2 = new Number(3);
Mul mul2 = new Mul(num2, x.Clone());
IExpression exp = new Div(mul1, mul2);
IExpression deriv = exp.Differentiate();
Assert.AreEqual("(((2 * 1) * (3 * x)) - ((2 * x) * (3 * 1))) / ((3 * x) ^ 2)", deriv.ToString());
num1.Value = 4;
num2.Value = 5;
Assert.AreEqual("(4 * x) / (5 * x)", exp.ToString());
Assert.AreEqual("(((2 * 1) * (3 * x)) - ((2 * x) * (3 * 1))) / ((3 * x) ^ 2)", deriv.ToString());
}
public void MulDiffl_NumDivVar_MulNum()
{
// (2 / x) * 2
var mul = new Mul(new Div(new Number(2), new Variable("x")), new Number(2));
var expected = new Div(new Number(4), new Variable("x"));
SimpleTest(mul, expected);
}
public void DivTwoNumbers()
{
var div = new Div(new Number(8), new Number(2));
var expected = new Number(4);
SimpleTest(div, expected);
}
public void DivDiff_VarMulNum_DivNum()
{
// (x * 2) / 4
var div = new Div(new Mul(new Variable("x"), new Number(2)), new Number(4));
var expected = new Div(new Variable("x"), new Number(2));
SimpleTest(div, expected);
}
public void DivDiff_NumDivVar_DivNum()
{
// (2 / x) / 2
var div = new Div(new Div(new Number(2), new Variable("x")), new Number(2));
var expected = new Div(new Number(1), new Variable("x"));
SimpleTest(div, expected);
}
public void DivDiffNumDiv_VarDivNum_()
{
// 2 / (x / 2)
var div = new Div(new Number(2), new Div(new Variable("x"), new Number(2)));
var expected = new Div(new Number(4), new Variable("x"));
SimpleTest(div, expected);
}
public void DivByZero()
{
var div = new Div(new Variable("x"), new Number(0));
Assert.Throws<DivideByZeroException>(() => SimpleTest(div, null));
}
public void ZeroDivByZero()
{
var div = new Div(new Number(0), new Number(0));
var expected = new Number(double.NaN);
SimpleTest(div, expected);
}
public void DivByOne()
{
var div = new Div(new Variable("x"), new Number(1));
var expected = new Variable("x");
SimpleTest(div, expected);
}
public void DivDerivativeTest2()
{
// sin(x) / x
var exp = new Div(new Sin(new Variable("x")), new Variable("x"));
var deriv = Differentiate(exp);
Assert.Equal("((cos(x) * 1 * x) - (sin(x) * 1)) / (x ^ 2)", deriv.ToString());
}
public void DivDiffNumDiv_NumDivVar_()
{
// 2 / (2 / x)
var div = new Div(new Number(2), new Div(new Number(2), new Variable("x")));
var expected = new Variable("x");
SimpleTest(div, expected);
}
public void DivDerivativeTest3()
{
// (2x) / (3x)
var num1 = new Number(2);
var x = new Variable("x");
var mul1 = new Mul(num1, x);
var num2 = new Number(3);
var mul2 = new Mul(num2, x.Clone());
var exp = new Div(mul1, mul2);
var deriv = Differentiate(exp);
Assert.Equal("((2 * 1 * 3 * x) - (2 * x * 3 * 1)) / ((3 * x) ^ 2)", deriv.ToString());
num1.Value = 4;
num2.Value = 5;
Assert.Equal("(4 * x) / (5 * x)", exp.ToString());
Assert.Equal("((2 * 1 * 3 * x) - (2 * x * 3 * 1)) / ((3 * x) ^ 2)", deriv.ToString());
}
public void DivDiffNumDiv_VarMulNum_()
{
// 2 / (2 * x)
var div = new Div(new Number(2), new Mul(new Variable("x"), new Number(2)));
var expected = new Div(new Number(1), new Variable("x"));
SimpleTest(div, expected);
}
public void DivPartialDerivativeTest1()
{
// (y + x ^ 2) / x
var exp = new Div(new Add(new Variable("y"), new Pow(new Variable("x"), new Number(2))), new Variable("x"));
var deriv = Differentiate(exp);
Assert.Equal("((1 * 2 * (x ^ (2 - 1)) * x) - ((y + (x ^ 2)) * 1)) / (x ^ 2)", deriv.ToString());
}
public void DivDiff_NumMulVar_DivNum()
{
// (2 * x) / 4
var div = new Div(new Mul(new Number(2), new Variable("x")), new Number(4));
var expected = new Div(new Variable("x"), new Number(2));
SimpleTest(div, expected);
}
public void DivPartialDerivativeTest3()
{
var exp = new Div(new Variable("y"), new Variable("x"));
var deriv = Differentiate(exp, new Variable("y"));
Assert.Equal("1 / x", deriv.ToString());
}
public void DivSameVars()
{
var x = new Variable("x");
var div = new Div(x, x);
var expected = new Number(1);
SimpleTest(div, expected);
}
public void DivPartialDerivativeTest4()
{
// (x + 1) / x
var exp = new Div(new Add(new Variable("x"), new Number(1)), new Variable("x"));
var deriv = Differentiate(exp, new Variable("y"));
Assert.Equal("0", deriv.ToString());
}
public void DivZero()
{
var div = new Div(new Number(0), new Variable("x"));
var expected = new Number(0);
SimpleTest(div, expected);
}
private IExpression SimplifyDiv(Div div)
{
// 0 / x
if (div.Left.Equals(zero) && !div.Right.Equals(zero))
return zero;
// x / 0
if (div.Right.Equals(zero) && !div.Left.Equals(zero))
throw new DivideByZeroException();
// x / 1
if (div.Right.Equals(one))
return div.Left;
if (div.Left is Number && div.Right is Number)
return new Number((double)div.Calculate());
// (2 * x) / 2
// (x * 2) / 2
if (div.Left is Mul && div.Right is Number)
{
var bracketMul = div.Left as Mul;
var firstNumber = div.Right as Number;
if (bracketMul.Left is Number)
{
var secondNumber = bracketMul.Left as Number;
var result = new Div(bracketMul.Right, new Number((double)firstNumber.Calculate() / (double)secondNumber.Calculate()));
return _Simplify(result);
}
if (bracketMul.Right is Number)
{
var secondNumber = bracketMul.Right as Number;
var result = new Div(bracketMul.Left, new Number((double)firstNumber.Calculate() / (double)secondNumber.Calculate()));
return _Simplify(result);
}
}
// 2 / (2 * x)
// 2 / (x * 2)
else if (div.Right is Mul && div.Left is Number)
{
var bracketMul = div.Right as Mul;
var firstNumber = div.Left as Number;
if (bracketMul.Left is Number)
{
var secondNumber = bracketMul.Left as Number;
var result = new Div(new Number((double)firstNumber.Calculate() / (double)secondNumber.Calculate()), bracketMul.Right);
return _Simplify(result);
}
if (bracketMul.Right is Number)
{
var secondNumber = bracketMul.Right as Number;
var result = new Div(new Number((double)firstNumber.Calculate() / (double)secondNumber.Calculate()), bracketMul.Left);
return _Simplify(result);
}
}
// (2 / x) / 2
// (x / 2) / 2
else if (div.Left is Div && div.Right is Number)
{
var bracketDiv = div.Left as Div;
var firstNumber = div.Right as Number;
if (bracketDiv.Left is Number)
{
var secondNumber = bracketDiv.Left as Number;
var result = new Div(new Number((double)firstNumber.Calculate() / (double)secondNumber.Calculate()), bracketDiv.Right);
return _Simplify(result);
}
if (bracketDiv.Right is Number)
{
var secondNumber = bracketDiv.Right as Number;
var result = new Div(bracketDiv.Left, new Number((double)firstNumber.Calculate() * (double)secondNumber.Calculate()));
return _Simplify(result);
}
}
// 2 / (2 / x)
// 2 / (x / 2)
else if (div.Right is Div && div.Left is Number)
{
var bracketDiv = div.Right as Div;
var firstNumber = div.Left as Number;
if (bracketDiv.Left is Number)
{
var secondNumber = bracketDiv.Left as Number;
var result = new Mul(new Number((double)firstNumber.Calculate() / (double)secondNumber.Calculate()), bracketDiv.Right);
return _Simplify(result);
}
if (bracketDiv.Right is Number)
{
var secondNumber = bracketDiv.Right as Number;
var result = new Div(new Number((double)firstNumber.Calculate() * (double)secondNumber.Calculate()), bracketDiv.Left);
return _Simplify(result);
}
}
return div;
}
public void MulDiffNumMul_NumDivVar_()
{
// 2 * (2 / x)
var mul = new Mul(new Number(2), new Div(new Number(2), new Variable("x")));
var expected = new Div(new Number(4), new Variable("x"));
SimpleTest(mul, expected);
}
private IExpression SimplifyMul(Mul mul)
{
// mul by zero
if (mul.Left.Equals(zero) || mul.Right.Equals(zero))
return zero;
// mul by 1
if (mul.Left.Equals(one))
return mul.Right;
if (mul.Right.Equals(one))
return mul.Left;
if (mul.Left is Number && mul.Right is Number)
return new Number((double)mul.Calculate());
// 2 * (2 * x)
// 2 * (x * 2)
// (2 * x) * 2
// (x * 2) * 2
Mul bracketMul = null;
Number firstNumber = null;
if (mul.Left is Mul && mul.Right is Number)
{
bracketMul = mul.Left as Mul;
firstNumber = mul.Right as Number;
}
else if (mul.Right is Mul && mul.Left is Number)
{
bracketMul = mul.Right as Mul;
firstNumber = mul.Left as Number;
}
if (bracketMul != null)
{
if (bracketMul.Left is Number)
{
var secondNumber = bracketMul.Left as Number;
var result = new Mul(new Number(firstNumber.Value * secondNumber.Value), bracketMul.Right);
return _Simplify(result);
}
if (bracketMul.Right is Number)
{
var secondNumber = bracketMul.Right as Number;
var result = new Mul(new Number(firstNumber.Value * secondNumber.Value), bracketMul.Left);
return _Simplify(result);
}
}
// 2 * (2 / x)
// 2 * (x / 2)
// (2 / x) * 2
// (x / 2) * 2
Div bracketDiv = null;
if (mul.Left is Div && mul.Right is Number)
{
bracketDiv = mul.Left as Div;
firstNumber = mul.Right as Number;
}
else if (mul.Right is Div && mul.Left is Number)
{
bracketDiv = mul.Right as Div;
firstNumber = mul.Left as Number;
}
if (bracketDiv != null)
{
if (bracketDiv.Left is Number)
{
var secondNumber = bracketDiv.Left as Number;
var result = new Div(new Number(firstNumber.Value * secondNumber.Value), bracketDiv.Right);
return _Simplify(result);
}
if (bracketDiv.Right is Number)
{
var secondNumber = bracketDiv.Right as Number;
var result = new Mul(new Number(firstNumber.Value / secondNumber.Value), bracketDiv.Left);
return _Simplify(result);
}
}
return mul;
}
