public void DiffInjectTest()
        {
            var deriv = new Derivative(new Variable("x"), new Variable("x"));
            resolver.Resolve(deriv);

            Assert.NotNull(deriv.Differentiator);
            Assert.Equal(this.differentiator, deriv.Differentiator);
        }
示例#2
0
文件: DerivTest.cs 项目: sys27/xFunc
        public void ExecutePointTest()
        {
            var differentiator = new Mock<IDifferentiator>();
            differentiator.Setup(d => d.Analyze(It.IsAny<Derivative>()))
                          .Returns<Derivative>(exp => exp.Expression);

            var deriv = new Derivative(new Variable("x"), new Variable("x"), new Number(2));
            deriv.Differentiator = differentiator.Object;

            Assert.Equal(2.0, deriv.Execute());
        }
示例#3
0
        public void Deriv()
        {
            var simp = new Derivative(new Add(new Number(2), new Number(3)));
            var expected = new Derivative(new Number(5));

            SimpleTest(simp, expected);
        }
示例#4
0
        public void DoubleDiffTest()
        {
            var exp = new Derivative(new Derivative(new Sin(new Variable("x")), new Variable("x")), new Variable("x"));
            var deriv = Differentiate(exp);

            Assert.Equal("-(sin(x) * 1) * 1", deriv.ToString());
        }
示例#5
0
        public void DerivTest()
        {
            var exp = new Derivative(new Number(2));
            var deriv = Differentiate(exp);

            Assert.Equal("0", deriv.ToString());
        }
示例#6
0
        public void SolveExpTest()
        {
            var lexer = new Mock<ILexer>();
            var parser = new Mock<IParser>();
            var simplifier = new Mock<ISimplifier>();
            var differentiator = new Mock<IDifferentiator>();

            var strExp = "deriv(x)";
            var exp = new Derivative(new Variable("x"), new Variable("x"));
            var diff = new Number(1);

            var tokens = new List<IToken>
            {
                new FunctionToken(Functions.Derivative, 1),
                new SymbolToken(Symbols.OpenBracket),
                new VariableToken("x"),
                new SymbolToken(Symbols.CloseBracket)
            };
            lexer.Setup(l => l.Tokenize(strExp)).Returns(() => tokens);
            parser.Setup(p => p.Parse(tokens)).Returns(() => exp);

            simplifier.Setup(s => s.Analyze(It.IsAny<Number>())).Returns<Number>(e => e);
            simplifier.Setup(s => s.Analyze(It.IsAny<Derivative>())).Returns<Derivative>(e => e);

            differentiator.Setup(d => d.Analyze(It.IsAny<Derivative>())).Returns(() => diff);
            differentiator.SetupProperty(d => d.Variable);
            differentiator.SetupProperty(d => d.Parameters);

            exp.Differentiator = differentiator.Object;
            exp.Simplifier = simplifier.Object;
            var processor = new Processor(lexer.Object, parser.Object, simplifier.Object, differentiator.Object);
            var result = processor.Solve<ExpressionResult>(strExp);

            lexer.Verify(l => l.Tokenize(It.IsAny<string>()), Times.Once());
            parser.Verify(p => p.Parse(It.IsAny<IEnumerable<IToken>>()), Times.Once());

            Assert.Equal(new Number(1), result.Result);
        }
示例#7
0
文件: DerivTest.cs 项目: sys27/xFunc
        public void ToStringVarTest()
        {
            var deriv = new Derivative(new Sin(new Variable("x")), new Variable("x"));

            Assert.Equal("deriv(sin(x), x)", deriv.ToString());
        }
示例#8
0
文件: DerivTest.cs 项目: sys27/xFunc
        public void ToStringPointTest()
        {
            var deriv = new Derivative(new Sin(new Variable("x")), new Variable("x"), new Number(1));

            Assert.Equal("deriv(sin(x), x, 1)", deriv.ToString());
        }
示例#9
0
        /// <summary>
        /// Creates an expression object from <see cref="FunctionToken"/>.
        /// </summary>
        /// <param name="token">The function token.</param>
        /// <returns>An expression.</returns>
        protected virtual IExpression CreateFunction(FunctionToken token)
        {
            IExpression exp;

            switch (token.Function)
            {
                case Functions.Add:
                    exp = new Add(); break;
                case Functions.Sub:
                    exp = new Sub(); break;
                case Functions.Mul:
                    exp = new Mul(); break;
                case Functions.Div:
                    exp = new Div(); break;
                case Functions.Pow:
                    exp = new Pow(); break;
                case Functions.Absolute:
                    exp = new Abs(); break;
                case Functions.Sine:
                    exp = new Sin(); break;
                case Functions.Cosine:
                    exp = new Cos(); break;
                case Functions.Tangent:
                    exp = new Tan(); break;
                case Functions.Cotangent:
                    exp = new Cot(); break;
                case Functions.Secant:
                    exp = new Sec(); break;
                case Functions.Cosecant:
                    exp = new Csc(); break;
                case Functions.Arcsine:
                    exp = new Arcsin(); break;
                case Functions.Arccosine:
                    exp = new Arccos(); break;
                case Functions.Arctangent:
                    exp = new Arctan(); break;
                case Functions.Arccotangent:
                    exp = new Arccot(); break;
                case Functions.Arcsecant:
                    exp = new Arcsec(); break;
                case Functions.Arccosecant:
                    exp = new Arccsc(); break;
                case Functions.Sqrt:
                    exp = new Sqrt(); break;
                case Functions.Root:
                    exp = new Root(); break;
                case Functions.Ln:
                    exp = new Ln(); break;
                case Functions.Lg:
                    exp = new Lg(); break;
                case Functions.Lb:
                    exp = new Lb(); break;
                case Functions.Log:
                    exp = new Log(); break;
                case Functions.Sineh:
                    exp = new Sinh(); break;
                case Functions.Cosineh:
                    exp = new Cosh(); break;
                case Functions.Tangenth:
                    exp = new Tanh(); break;
                case Functions.Cotangenth:
                    exp = new Coth(); break;
                case Functions.Secanth:
                    exp = new Sech(); break;
                case Functions.Cosecanth:
                    exp = new Csch(); break;
                case Functions.Arsineh:
                    exp = new Arsinh(); break;
                case Functions.Arcosineh:
                    exp = new Arcosh(); break;
                case Functions.Artangenth:
                    exp = new Artanh(); break;
                case Functions.Arcotangenth:
                    exp = new Arcoth(); break;
                case Functions.Arsecanth:
                    exp = new Arsech(); break;
                case Functions.Arcosecanth:
                    exp = new Arcsch(); break;
                case Functions.Exp:
                    exp = new Exp(); break;
                case Functions.GCD:
                    exp = new GCD(); break;
                case Functions.LCM:
                    exp = new LCM(); break;
                case Functions.Factorial:
                    exp = new Fact(); break;
                case Functions.Sum:
                    exp = new Sum(); break;
                case Functions.Product:
                    exp = new Product(); break;
                case Functions.Round:
                    exp = new Round(); break;
                case Functions.Floor:
                    exp = new Floor(); break;
                case Functions.Ceil:
                    exp = new Ceil(); break;
                case Functions.Derivative:
                    exp = new Derivative(); break;
                case Functions.Simplify:
                    exp = new Simplify(); break;
                case Functions.Del:
                    exp = new Del(); break;
                case Functions.Define:
                    exp = new Define(); break;
                case Functions.Vector:
                    exp = new Vector(); break;
                case Functions.Matrix:
                    exp = new Matrix(); break;
                case Functions.Transpose:
                    exp = new Transpose(); break;
                case Functions.Determinant:
                    exp = new Determinant(); break;
                case Functions.Inverse:
                    exp = new Inverse(); break;
                case Functions.If:
                    exp = new If(); break;
                case Functions.For:
                    exp = new For(); break;
                case Functions.While:
                    exp = new While(); break;
                case Functions.Undefine:
                    exp = new Undefine(); break;
                case Functions.Im:
                    exp = new Im(); break;
                case Functions.Re:
                    exp = new Re(); break;
                case Functions.Phase:
                    exp = new Phase(); break;
                case Functions.Conjugate:
                    exp = new Conjugate(); break;
                case Functions.Reciprocal:
                    exp = new Reciprocal(); break;
                case Functions.Min:
                    exp = new Min(); break;
                case Functions.Max:
                    exp = new Max(); break;
                case Functions.Avg:
                    exp = new Avg(); break;
                case Functions.Count:
                    exp = new Count(); break;
                case Functions.Var:
                    exp = new Var(); break;
                case Functions.Varp:
                    exp = new Varp(); break;
                case Functions.Stdev:
                    exp = new Stdev(); break;
                case Functions.Stdevp:
                    exp = new Stdevp(); break;
                default:
                    exp = null; break;
            }

            var diff = exp as DifferentParametersExpression;
            if (diff != null)
                diff.ParametersCount = token.CountOfParams;

            return exp;
        }