Exemple #1
0
 public override IBuildIntention <ISubtractOperation> GetBuildIntention(IConversionContext context)
 {
     var(toBuild, maker) = SubtractOperation.Create();
     return(new BuildIntention <ISubtractOperation>(toBuild, () =>
     {
         maker.Build(Left.GetOrThrow().ConvertElementOrThrow(context), Right.GetOrThrow().ConvertElementOrThrow(context));
     }));
 }
Exemple #2
0
        public void SubtractNumbers()
        {
            SubtractOperation op = SubtractOperation.Instance;

            Assert.AreEqual(1 - 2, op.Apply(1, 2));
            Assert.AreEqual(1.2 - 3.4, op.Apply(1.2, 3.4));
            Assert.AreEqual(1 - 2.3, op.Apply(1, 2.3));
            Assert.AreEqual(1.2 - 3, op.Apply(1.2, 3));
        }
Exemple #3
0
        public void CheckSubtract()
        {
            SubtractRequest subtractRequest = new SubtractRequest()
            {
                a = 10, b = 7
            };

            _repositoryMock.Setup(x => x.Subtract(subtractRequest.a, subtractRequest.b)).Returns(3);

            IOperation subtractOperation = new SubtractOperation(_logger, _repositoryMock.Object);

            var result = (SubtractResponse)subtractOperation.Execute(subtractRequest);

            Assert.AreEqual(3, result.Result);
        }
Exemple #4
0
        public void SubtractVectorFromReal()
        {
            SubtractOperation op = SubtractOperation.Instance;
            Vector            v  = new Vector(new object[] { 1, 2, 3 });

            var result = op.Apply(1.5, v);

            Assert.IsNotNull(result);
            Assert.IsInstanceOfType(result, typeof(Vector));

            var vector = (Vector)result;

            Assert.AreEqual(3, vector.Length);
            Assert.AreEqual(0.5, vector[0]);
            Assert.AreEqual(-0.5, vector[1]);
            Assert.AreEqual(-1.5, vector[2]);
        }
        public void SubtractOperation_TwoMatrices_MatricesSubtracted()
        {
            var matrix1 = new Matrix(new int[2, 2] {
                { 1, 2 }, { 3, 4 }
            });
            var matrix2 = new Matrix(new int[2, 2] {
                { 1, 2 }, { 3, 4 }
            });
            var expectedMatrix = new Matrix(new int[2, 2] {
                { 0, 0 }, { 0, 0 }
            });

            var inputArray    = new Matrix[] { matrix1, matrix2 };
            var expectedArray = new Matrix[] { expectedMatrix };

            var opratrion = new SubtractOperation();

            var output = opratrion.Apply(inputArray);

            Assert.Equal(expectedArray, output, new MatrixComparer());
        }
Exemple #6
0
 protected VisitResult VisitSubtract(SubtractOperation operation)
 {
     return(VisitBinary(Expression.Subtract, operation));
 }
Exemple #7
0
        public void Subtract()
        {
            var result = new SubtractOperation().Perform(10, 4);

            Assert.AreEqual(6, result);
        }
Exemple #8
0
        public Factorial()
        {
            var ifBlockScope = Scope.CreateAndBuild(new List <Scope.IsStatic> {
            });
            var elseBlock    = Scope.CreateAndBuild(new List <Scope.IsStatic> {
            });

            var inputKey = new NameKey("input");
            var input    = MemberDefinition.CreateAndBuild(inputKey, new NumberType(), false);

            var facKey = new NameKey("fac");
            var fac    = MemberDefinition.CreateAndBuild(facKey, MethodType.CreateAndBuild(new NumberType(), new NumberType()), false);


            var methodScope = Scope.CreateAndBuild(new List <Scope.IsStatic> {
                new Scope.IsStatic(input, false)
            });


            Module =
                ModuleDefinition.CreateAndBuild(
                    Scope.CreateAndBuild(
                        new List <Scope.IsStatic> {
                new Scope.IsStatic(MemberDefinition.CreateAndBuild(facKey, MethodType.CreateAndBuild(new NumberType(), new NumberType()), false), false)
            }),
                    new ICodeElement[] {
                AssignOperation.CreateAndBuild(
                    MethodDefinition.CreateAndBuild(
                        new NumberType(),
                        new NumberType(),
                        input,
                        methodScope,
                        new ICodeElement[] {
                    ElseOperation.CreateAndBuild(
                        IfOperation.CreateAndBuild(
                            LessThanOperation.CreateAndBuild(
                                MemberReference.CreateAndBuild(input),
                                ConstantNumber.CreateAndBuild(2)),
                            BlockDefinition.CreateAndBuild(
                                ifBlockScope,
                                new ICodeElement[] {
                        ReturnOperation.CreateAndBuild(
                            ConstantNumber.CreateAndBuild(1))
                    },
                                new ICodeElement[0])),
                        BlockDefinition.CreateAndBuild(
                            elseBlock,
                            new ICodeElement[] {
                        ReturnOperation.CreateAndBuild(
                            MultiplyOperation.CreateAndBuild(
                                NextCallOperation.CreateAndBuild(
                                    SubtractOperation.CreateAndBuild(
                                        MemberReference.CreateAndBuild(input),
                                        ConstantNumber.CreateAndBuild(1)),
                                    MemberReference.CreateAndBuild(fac)),
                                MemberReference.CreateAndBuild(input)))
                    },
                            new ICodeElement[0]))
                },
                        new ICodeElement[0],
                        false),
                    MemberReference.CreateAndBuild(fac)
                    )
            },
                    new NameKey("factorial")
                    );
        }
Exemple #9
0
        public override HlslTreeNode Reduce()
        {
            var addend1   = Addend1.Reduce();
            var addend2   = Addend2.Reduce();
            var constant1 = addend1 as ConstantNode;
            var constant2 = addend2 as ConstantNode;

            if (constant1 != null)
            {
                float value1 = constant1.Value;
                if (value1 == 0)
                {
                    Replace(addend2);
                    return(addend2);
                }
                if (constant2 != null)
                {
                    return(new ConstantNode(value1 + constant2.Value));
                }
            }

            if (constant2 != null)
            {
                float value2 = constant2.Value;
                if (value2 == 0)
                {
                    return(addend1);
                }
                if (value2 < 0)
                {
                    var sub = new SubtractOperation(addend1, new ConstantNode(-value2));
                    Replace(sub);
                    return(sub);
                }
            }

            if (addend1 == addend2)
            {
                var mul = new MultiplyOperation(new ConstantNode(2), addend1);
                Replace(mul);
                return(mul);
            }

            if (addend1 is NegateOperation negate1 && addend2 is NegateOperation == false)
            {
                var sub = new SubtractOperation(addend2, negate1.Value);
                Replace(sub);
                return(sub);
            }

            if (addend1 is NegateOperation == false && addend2 is NegateOperation negate2)
            {
                var sub = new SubtractOperation(addend1, negate2.Value);
                Replace(sub);
                return(sub);
            }

            Inputs[0] = addend1;
            Inputs[1] = addend2;
            return(this);
        }
Exemple #10
0
        public Factorial()
        {
            var ifBlockScope = Scope.CreateAndBuild(new List <IsStatic> {
            });
            var elseBlock    = Scope.CreateAndBuild(new List <IsStatic> {
            });

            var inputKey = new NameKey("input");
            var input    = MemberDefinition.CreateAndBuild(inputKey, new NumberType(), Access.ReadWrite);

            var facKey = new NameKey("fac");
            var fac    = MemberDefinition.CreateAndBuild(facKey, MethodType.CreateAndBuild(new NumberType(), new NumberType()), Access.ReadWrite);

            var methodScope = Scope.CreateAndBuild(new List <IsStatic> {
                new IsStatic(input, false)
            });

            RootScope =
                Model.Instantiated.RootScope.CreateAndBuild(
                    Scope.CreateAndBuild(
                        new List <IsStatic> {
                new IsStatic(MemberDefinition.CreateAndBuild(facKey, MethodType.CreateAndBuild(
                                                                 new NumberType(),
                                                                 new NumberType()), Access.ReadWrite), false)
            }),
                    new [] {
                AssignOperation.CreateAndBuild(
                    MethodDefinition.CreateAndBuild(
                        new NumberType(),
                        input,
                        methodScope,
                        new ICodeElement[] {
                    ElseOperation.CreateAndBuild(
                        IfOperation.CreateAndBuild(
                            LessThanOperation.CreateAndBuild(
                                MemberReference.CreateAndBuild(input),
                                ConstantNumber.CreateAndBuild(2)),
                            BlockDefinition.CreateAndBuild(
                                ifBlockScope,
                                new ICodeElement[] {
                        ReturnOperation.CreateAndBuild(
                            ConstantNumber.CreateAndBuild(1))
                    },
                                Array.Empty <ICodeElement>())),
                        BlockDefinition.CreateAndBuild(
                            elseBlock,
                            new ICodeElement[] {
                        ReturnOperation.CreateAndBuild(
                            MultiplyOperation.CreateAndBuild(
                                NextCallOperation.CreateAndBuild(
                                    SubtractOperation.CreateAndBuild(
                                        MemberReference.CreateAndBuild(input),
                                        ConstantNumber.CreateAndBuild(1)),
                                    MemberReference.CreateAndBuild(fac)),
                                MemberReference.CreateAndBuild(input)))
                    },
                            Array.Empty <ICodeElement>()))
                },
                        Array.Empty <ICodeElement>()),
                    MemberReference.CreateAndBuild(fac)
                    )
            },
                    EntryPointDefinition.CreateAndBuild(new EmptyType(), MemberDefinition.CreateAndBuild(new NameKey("input"), new NumberType(), Access.ReadWrite), Scope.CreateAndBuild(Array.Empty <IsStatic>()), Array.Empty <ICodeElement>(), Array.Empty <ICodeElement>())
                    );
        }