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)); }