public void QuantityTwoMinus_a_raisedTo1DividedBy3Test()
{
var actual = DivideOp.Create(PowerOp.Create(SubtractOp.Create(new Two(), new Identifier("a")), new One()), Literal.Create(3)).Simplify();
var expected = ExprParser.ParseOrThrow("(2-a)^1/3").Simplify();
Assert.AreEqual(expected, actual);
}
public void PowerOpTest()
{
var actual = PowerOp.Create(Two, D);
Assert.AreEqual(ExprParser.ParseOrThrow("2^d"), actual);
Assert.AreEqual(Two.Raise(D), actual);
}
public void TwoMinus_a_PowerOf1Test()
{
var actual = SubtractOp.Create(new Two(), PowerOp.Create(new Identifier("a"), new One()));
var expected = ExprParser.ParseOrThrow("2-a^1");
Assert.AreEqual(expected, actual);
}
public void RaisedToNumberThenAddTest()
{
var actual = AddOp.Create(PowerOp.Create(A, One), Two);
Assert.AreEqual(ExprParser.ParseOrThrow("a^1+2"), actual);
Assert.AreEqual(A.Raise(One) + Two, actual.Simplify());
}
public void Test1()
{
const string input = "-(2-a)^1+3";
var actual = AddOp.Create(NegativeOp.Create(PowerOp.Create(SubtractOp.Create(new Two(), new Identifier("a")), new One())), Literal.Create(3)).Simplify();
var expected = ExprParser.ParseOrThrow(input);
Assert.AreEqual(expected.Simplify(), actual);
}
public void QuantityTwoMinus_a_raisedToQuantity1Plus3Test()
{
const string input = "(2-a)^(1+3)";
var actual = PowerOp.Create(SubtractOp.Create(new Two(), new Identifier("a")), AddOp.Create(new One(), Literal.Create(3))).Simplify();
var expected = ExprParser.ParseOrThrow(input).Simplify();
Assert.AreEqual(expected, actual);
}
public void InvertLiteralTest()
{
var one = new One();
Assert.AreEqual(one.Invert(), PowerOp.Create(new One(), new NegativeOne()));
var two = new Two();
Assert.AreEqual(two.Invert(), PowerOp.Create(new Two(), new NegativeOne()));
}
public void TwoXRaiseToTwoX()
{
var x = new Identifier("x");
var TwoX = MultiplyOp.Create(2, x);
var test = TwoX.Raise(TwoX);
Assert.IsTrue(test is MultiplyOp m && m.Left == PowerOp.Create(4, x));
Assert.AreEqual(test, MultiplyOp.Create(PowerOp.Create(4, x), PowerOp.Create(x, TwoX)));
}
public void RaisedToNegativeTest()
{
var d = -De;
var actual = PowerOp.Create(Two, d);
Assert.AreEqual(ExprParser.ParseOrThrow("2 ^-de"), actual);
Assert.AreEqual(-De, -De.Simplify());
Assert.AreEqual(Two.Raise(d), actual.Simplify());
}
public void DecimalTest()
{
var onePthree = ExprParser.ParseOrThrow("1.3");
Assert.AreEqual(onePthree, DivideOp.Create(13, 10));
var actual = AddOp.Create(PowerOp.Create(A, onePthree), Two);
Assert.AreEqual(ExprParser.ParseOrThrow("a^1.3+2"), actual);
Assert.AreEqual(A.Raise(onePthree) + Two, actual.Simplify());
}
public void FractionRaiseToFraction()
{
var twentyFive = Literal.Create(25);
var thirtyTwo = Literal.Create(32);
var oneTenth = DivideOp.Create(1, 10);
var result = (thirtyTwo / twentyFive).Raise(oneTenth);
var actual = SqrtOp.Create(2) / PowerOp.Create(5, DivideOp.Create(1, 5));
Assert.AreEqual(result, actual);
}
public void Test3()
{
const string input = "-a/b^1+3-a/b^1";
var term1 = DivideOp.Create(NegativeOp.Create(new Identifier("a")), PowerOp.Create(new Identifier("b"), new One()));
var term2 = Literal.Create(3);
var term3 = DivideOp.Create(new Identifier("a"), PowerOp.Create(new Identifier("b"), new One()));
var actual = SubtractOp.Create(AddOp.Create(term1, term2), term3).Simplify();
var expected = ExprParser.ParseOrThrow(input);
Assert.AreEqual(expected.Simplify(), actual);
}
public void InvertPowerOpTest()
{
var a = new Identifier("a");
var neg = a.Raise(-new One());
Assert.AreEqual(neg.Invert(), a);
var b = new Identifier("b").Raise(new Two());
Assert.AreEqual(b.Invert(), PowerOp.Create(new Identifier(nameof(b)), -2));
var negB = new Identifier(nameof(b)).Raise(-new Two());
Assert.AreEqual(negB.Invert(), PowerOp.Create(new Identifier(nameof(b)), 2));
}
public void LiteralFactorOfBigNumber()
{
var newlit = ExprParser.ParseOrThrow("2069366877425482173897306373270574575520870902460429264486400000");
if (newlit is Literal lit)
{
var expected = lit.Factor();
var actual = new[] { PowerOp.Create(2, 77), PowerOp.Create(3, 52), PowerOp.Create(5, 5), PowerOp.Create(7, 14) };
Assert.IsTrue(expected.ContentEquals(actual));
}
else
{
Assert.Fail($"Type is not Literal");
}
}
public IEnumerable <object[]> GetData(MethodInfo methodInfo)
{
for (int j = 0; j < 100; j++)
{
var d = randomizer.Next(10, 50);
var tempArr = new Expr[d];
BigInteger total = 1;
for (int i = 0; i < d; i++)
{
var val = data[randomizer.Next(4)];
total = total * val;
tempArr[i] = Literal.Create(val);
}
var actual = tempArr.GroupBy((e) => e).Select((g) => g.Count() == 1 ? g.Key : PowerOp.Create(g.Key, g.Count()));
var expected = Literal.Create(total).Factor();
yield return(new object[] { total.ToString(), actual, expected });
}
}
public void InvertIdenterfierTest()
{
var a = new Identifier("a");
Assert.AreEqual(a.Invert(), PowerOp.Create(a, -1));
}
public void InvertSubtractOpTest()
{
var aNb = new Identifier("a") - new Identifier("b");
Assert.AreEqual(aNb.Invert(), PowerOp.Create(aNb, -1));
}
public void InvertAddOpTest()
{
var aPb = new Identifier("a") + new Identifier("b");
Assert.AreEqual(aPb.Invert(), PowerOp.Create(aPb, -1));
}
public void TwoxRaiseTo3()
{
var d = ExprParser.ParseOrThrow("(2*x)^3").Simplify();
Assert.AreEqual(d, MultiplyOp.Create(8, PowerOp.Create(new Identifier("x"), 3)));
}
public void TwoXRaiseTox()
{
var x = new Identifier("x");
Assert.AreEqual(MultiplyOp.Create(2, x).Raise(x), MultiplyOp.Create(PowerOp.Create(2, x), PowerOp.Create(x, x)));
}
public void ParseSciNotWithParenTest2()
{
var f = ExprParser.ParseOrThrow("-(1.2340000)E(-14)");
Assert.AreEqual(f, (new NegativeOne() - (Literal.Create(234) / Literal.Create(1000))) * PowerOp.Create(10, -14));
}
public void SciNotSmallE()
{
var f = ExprParser.ParseOrThrow("-(1.2340000)e(-14)");
Assert.AreEqual(f, (new NegativeOne() - (Literal.Create(234) / Literal.Create(1000))) * PowerOp.Create(10, -14));
}
public static Expr Root(this Expr @base, Expr root) => PowerOp.Create(@base, DivideOp.Create(1, root));
Left.Factor().Concat(Right.Factor()).ToLookup(f => f).Select(g => (b: g.Key, e: g.Count())).Select(pair => pair.e > 1 ? PowerOp.Create(pair.b, pair.e) : pair.b);
public static Expr RaiseToNegativeOne(this Expr expr) => PowerOp.Create(expr, new NegativeOne());
public void RaiseToANumber()
{
Assert.AreEqual(X.Raise(new Two()).Simplify(), PowerOp.Create(X, 2));
}
public void Power()
{
Assert.AreEqual(i1.Raise(i3), PowerOp.Create(i1, i3));
}
public void MutiplyToSelf()
{
Assert.AreEqual(i1 * i1, PowerOp.Create(i1, 2));
}
public void InvertNegativeValueTest()
{
var a = -new Identifier("a");
Assert.AreEqual(a.Invert(), PowerOp.Create(a, -1));
}
