Exemplo n.º 1
0
 public static Expr Create(BigInteger value)
 {
     if (value == 0) return new Zero();
     if (value == 1) return new One();
     if (value < 0) NegativeOp.Create(Create(-value));
     return new Literal(value);
 }
    public void ExprTest()
    {
        const string input  = "12 * 3 + foo(-3, x)() * (2 + 1)";
        var          actual = AddOp.Create(
            MultiplyOp.Create(
                Literal.Create(12),
                Literal.Create(3)
                ),
            MultiplyOp.Create(
                Call.Create(
                    Call.Create(
                        new Identifier("foo"),
                        NegativeOp.Create(Literal.Create(3)),
                        new Identifier("x")
                        )
                    ),
                AddOp.Create(
                    new Two(),
                    new One()
                    )
                )
            ).Simplify();
        var expected = ExprParser.ParseOrThrow(input);

        Assert.AreEqual(expected.Simplify(), actual);
    }
    public void CreateNegativeZeroTest()
    {
        var zero         = new Zero();
        var negativezero = NegativeOp.Create(0);

        Assert.AreEqual(zero, negativezero);
    }
    public void Test4()
    {
        var d       = ExprParser.ParseOrThrow("2*4/3-4");
        var dsimped = d.Simplify();

        Assert.AreEqual(dsimped, NegativeOp.Create(DivideOp.Create(4, 3)));
    }
    public void AddToNegativeLiteralTest()
    {
        var actual1 = SubtractOp.Create(new Identifier("x"), 1);
        var actual2 = SubtractOp.Create(1, new Identifier("x"));

        Assert.AreEqual(X + new NegativeOne(), actual1);
        Assert.AreEqual(One + NegativeOp.Create(X), actual2);
    }
Exemplo n.º 6
0
 public static Expr ToExpr(this BigInteger i)
 {
     if (i < 0)
     {
         return(NegativeOp.Create(Literal.Create(BigInteger.Abs(i))));
     }
     return(Literal.Create(i));
 }
    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 SubtractToNegativeLiteralTest()
    {
        var num     = new One();
        var actual1 = AddOp.Create(new Identifier("x"), 1);
        var actual2 = AddOp.Create(1, new Identifier("x"));

        Assert.AreEqual(X - NegativeOp.Create(num), actual1);
        Assert.AreEqual(num - NegativeOp.Create(X), actual2);
    }
    public void SqrtN16()
    {
        var NegSixteen   = NegativeOp.Create(Literal.Create(16));
        var sqrt         = NegSixteen.Sqrt();
        var four         = Literal.Create(4);
        var sqrtOfNegOne = SqrtOp.Create(-1).Simplify();
        var expected     = four * sqrtOfNegOne;

        Assert.AreEqual(sqrt, expected);
    }
    public void NegateDivideTest()
    {
        const string input  = "- (1/3)";
        var          actual = NegativeOp.Create(
            DivideOp.Create(new One(), Literal.Create(3))
            ).Simplify();
        var expected = ExprParser.ParseOrThrow(input);

        Assert.AreEqual(expected, actual);
    }
    public void NegativeBeforeMultiplyTest()
    {
        const string input  = "-12*3";
        var          actual = MultiplyOp.Create(
            NegativeOp.Create(Literal.Create(12)),
            Literal.Create(3)
            ).Simplify();
        var expected = ExprParser.ParseOrThrow(input);

        Assert.AreEqual(expected.Simplify(), actual);
    }
    public void NegativeBeforeSubtractTest()
    {
        const string input  = "-12 - 3";
        var          actual = SubtractOp.Create(
            NegativeOp.Create(Literal.Create(12)),
            Literal.Create(3)
            ).Simplify();
        var expected = ExprParser.ParseOrThrow(input).Simplify();

        Assert.AreEqual(expected, 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 FunctionMethodNegateParamTest()
    {
        const string input  = "foo(-3, x)()";
        var          actual =
            Call.Create(
                Call.Create(
                    new Identifier("foo"),
                    NegativeOp.Create(Literal.Create(3)),
                    new Identifier("x")
                    )).Simplify();
        var expected = ExprParser.ParseOrThrow(input);

        Assert.AreEqual(expected, actual);
    }
Exemplo n.º 15
0
 public static Expr Create(BigInteger value)
 {
     if (value == 0)
     {
         return(new Zero());
     }
     if (value == 1)
     {
         return(new One());
     }
     if (value < 0)
     {
         NegativeOp.Create(Create(-value));
     }
     return(new Literal(value));
 }
Exemplo n.º 16
0
 public static Expr Create(decimal value)
 {
     if (value == 0)
     {
         return(new Zero());
     }
     if (value == 1)
     {
         return(new One());
     }
     if (value < 0)
     {
         NegativeOp.Create(Create(-value));
     }
     return(new Dec(value));
 }
Exemplo n.º 17
0
        public void InvertDivisionOpTest()
        {
            var a       = new Identifier("a");
            var b       = new Identifier("b");
            var actual1 = new One() / a;

            Assert.AreEqual(actual1.Invert(), a);
            var actual2 = DivideOp.Create(-new One(), a);

            Assert.AreEqual(actual2.Invert(), -a);
            var actual3 = DivideOp.Create(a, b);

            Assert.AreEqual(actual3.Invert(), DivideOp.Create(b, a));
            var actual4 = DivideOp.Create(NegativeOp.Create(a), b);

            Assert.AreEqual(actual4.Invert(), DivideOp.Create(-b, a));
        }
    public void NegativeFractionRootOfFive()
    {
        var d = ExprParser.ParseOrThrow("-(1/2)^5").Simplify();

        Assert.AreEqual(d, NegativeOp.Create(DivideOp.Create(1, 32)));
    }