public SyntaxBlock Simplify()
        {
            A = A.Simplify();
            B = B.Simplify();

            var a = A as NumericConstant;
            var b = B as NumericConstant;

            if (a == null && b == null) //Neither A nor B are numeric constants, return this quotient in its existing state.
            {
                return(this);
            }

            if (a != null && b != null) //Both A and B are numeric constants, return new numeric constant that is the quotient of both.
            {
                return(new NumericConstant(a.value / b.value));
            }

            if (a?.value == 0)
            {
                return(new NumericConstant(0));
            }

            if (b?.value == 1)
            {
                return(A);
            }
            else if (b?.value == 0)
            {
                throw new DivideByZeroException("Can't devide by zero!");
            }
            return(this); //No simplification possible, return this quotient in its existing state.
        }
        public override bool ParallelEquals(SyntaxBlock ToCompare, int Depth)
        {
            if (Depth == 0)
            {
                return(Equals(ToCompare));
            }

            var casted = ToCompare as AbstractOrderstrictOperator;

            if (casted == null)
            {
                return(false);
            }
            if (ToCompare.GetType() != GetType())
            {
                return(false);
            }
            bool a = false;
            bool b = false;

            Parallel.Invoke(
                () => { a = A.Equals(casted.A); },
                () => { b = B.Equals(casted.B); }
                );
            return(a && b);
        }
        public override bool Equals(SyntaxBlock ToCompare)
        {
            var casted = ToCompare as AbstractOrderirrelevantOperator;

            if (casted == null)
            {
                return(false);
            }
            if (ToCompare.GetType() != GetType())
            {
                return(false);
            }

            if (A.Equals(casted.A))
            {
                if (B.Equals(casted.B))
                {
                    return(true);
                }
            }
            if (B.Equals(casted.A))
            {
                if (A.Equals(casted.B))
                {
                    return(true);
                }
            }
            return(false);
        }
示例#4
0
        public SyntaxBlock Simplify()
        {
            A = A.Simplify();
            B = B.Simplify();


            var a = A as NumericConstant;
            var b = B as NumericConstant;

            if (a == null && b == null) //Neither A nor B are numeric constants, return this sum in its existing state.
            {
                return(this);
            }

            if (a != null && b != null) //Both A and B are numeric constants, return new numeric constant that is the sum of both.
            {
                return(new NumericConstant(a.value + b.value));
            }

            if (a?.value == 0)  //if a is zero, return B;
            {
                return(B);
            }

            if (b?.value == 0)  //if b is zero, return A;
            {
                return(A);
            }

            return(this); //No simplification possible, return this sum in its existing state.
        }
示例#5
0
        public bool Equals(SyntaxBlock ToCompare)
        {
            var casted = ToCompare as NumericConstant;

            if (casted?.value == value)
            {
                return(true);
            }
            return(false);
        }
        public bool Equals(SyntaxBlock ToCompare)
        {
            Abstract_variable casted = ToCompare as Abstract_variable;

            if (casted?.Argument == Argument)
            {
                return(true);
            }
            return(false);
        }
 public SyntaxBlock ParallelSimplify(int Depth)
 {
     if (Depth == 0)
     {
         return(Simplify());
     }
     Parallel.Invoke(
         () => { A = A.ParallelSimplify(Depth - 1); },
         () => { B = B.ParallelSimplify(Depth - 1); }
         );
     return(SimplifySelf());
 }
        /// <summary>
        /// Calculates the derivative of a simple formula with only one variable.
        /// </summary>
        /// <param name="Formula">The formula for which to calculate the derivative for.</param>
        /// <returns>The derives formula.</returns>
        /// <exception cref="DerivativeException">Throws a DerivativeException when the formula contains more than one variable.</exception>
        public static SyntaxBlock CalculateDerivative(SyntaxBlock Formula)
        {
            var listOfPartials = CalculatePartialDerivatives(Formula);

            if (listOfPartials.Count > 1)
            {
                throw new DerivativeException("Formula has more than one variable");
            }
            if (listOfPartials.Count < 1)
            {
                throw new DerivativeException("Formula has no derivatives");
            }
            return(listOfPartials[0].Item2);
        }
        public override bool Equals(SyntaxBlock ToCompare)
        {
            var casted = ToCompare as AbstractOrderstrictOperator;

            if (casted == null)
            {
                return(false);
            }
            if (ToCompare.GetType() != GetType())
            {
                return(false);
            }

            return(A.Equals(casted.A) && B.Equals(casted.B));
        }
        public SyntaxBlock ParallelDerivative(VariableArgumentValue ArgumentToDerive, int Depth)
        {
            if (Depth == 0)
            {
                return(Derivative(ArgumentToDerive));
            }
            SyntaxBlock adir = null;
            SyntaxBlock bdir = null;

            Parallel.Invoke(
                () => { adir = A.ParallelDerivative(ArgumentToDerive, Depth - 1); },
                () => { bdir = B.ParallelDerivative(ArgumentToDerive, Depth - 1); }
                );
            return(DerivativeFormulate(adir, bdir));
        }
        public override bool ParallelEquals(SyntaxBlock ToCompare, int Depth)
        {
            if (Depth == 0)
            {
                return(Equals(ToCompare));
            }

            var casted = ToCompare as AbstractOrderirrelevantOperator;

            if (casted == null)
            {
                return(false);
            }
            if (ToCompare.GetType() != GetType())
            {
                return(false);
            }

            bool aisa, aisb;

            aisa = false;
            aisb = false;

            Parallel.Invoke(
                () => {
                if (A.Equals(casted.A))
                {
                    if (B.Equals(casted.B))
                    {
                        aisa = true;
                    }
                }
            },
                () => {
                if (B.Equals(casted.A))
                {
                    if (A.Equals(casted.B))
                    {
                        aisb = true;
                    }
                }
            }
                );
            return(aisa || aisb);
        }
示例#12
0
 public override SyntaxBlock DerivativeFormulate(SyntaxBlock Adir, SyntaxBlock Bdir)
 {
     //(A'*B + -1(B' * A))/ (B * B) => (A'*B - B' * A)/ B ^ 2
     return(new Quotient(new Sum(new Product(Adir, B),
                                 new Product(new NumericConstant(-1), new Product(Bdir, A))), new Product(B, B)));
 }
示例#13
0
 /// <summary>
 /// Creates a sum syntax block which adds argument A and B together.
 /// </summary>
 /// <param name="A">The left side of the sum.</param>
 /// <param name="B">The right side of the sum.</param>
 public Sum(SyntaxBlock A, SyntaxBlock B)
 {
     this.A = A;
     this.B = B;
 }
示例#14
0
 public Quotient(SyntaxBlock A, SyntaxBlock B)
 {
     this.A = A;
     this.B = B;
 }
 public AbstractOrderstrictOperator(SyntaxBlock A, SyntaxBlock B) : base(A, B)
 {
 }
 public AbstractOrderirrelevantOperator(SyntaxBlock A, SyntaxBlock B) : base(A, B)
 {
 }
示例#17
0
 public Quotient(SyntaxBlock A, SyntaxBlock B) : base(A, B)
 {
 }
示例#18
0
 /// <summary>
 /// Creates a product syntax block, which multiplies argument A and B together.
 /// </summary>
 /// <param name="A">The left side of the product.</param>
 /// <param name="B">The right side of the product.</param>
 public Product(SyntaxBlock A, SyntaxBlock B) : base(A, B)
 {
 }
示例#19
0
 public bool ParallelEquals(SyntaxBlock ToCompare, int Depth)
 {
     return(Equals(ToCompare));
 }
 public AbstractOperator(SyntaxBlock A, SyntaxBlock B)
 {
     this.A = A;
     this.B = B;
 }
        /// <summary>
        /// Calculates all the partial derivatives of a given formula.
        /// </summary>
        /// <param name="Formula">The formula for which to calculate all partial derivatives.</param>
        /// <returns>A list of tuples, containing the ArgumentValue for which it was calculated (item1) and the formula itself(item2).</returns>
        public static List <Tuple <ArgumentValue, SyntaxBlock> > CalculatePartialDerivatives(SyntaxBlock Formula)
        {
            var AllVariableVariables = Formula.GetAllVariables(true);
            var distinctVariables    = AllVariableVariables.Distinct();
            List <Tuple <ArgumentValue, SyntaxBlock> > PartialDerivatives = new List <Tuple <ArgumentValue, SyntaxBlock> >();

            foreach (ArgumentValue i in distinctVariables)
            {
                PartialDerivatives.Add(new Tuple <ArgumentValue, SyntaxBlock>((ArgumentValue)i, Formula.Derivative((ArgumentValue)i).Simplify()));
            }
            return(PartialDerivatives);
        }
示例#22
0
 /// <summary>
 /// Creates a product syntax block, which multiplies argument A and B together.
 /// </summary>
 /// <param name="A">The left side of the product.</param>
 /// <param name="B">The right side of the product.</param>
 public Product(SyntaxBlock A, SyntaxBlock B)
 {
     this.A = A;
     this.B = B;
 }
 public SyntaxBlock Simplify()
 {
     A = A.Simplify();
     B = B.Simplify();
     return(SimplifySelf());
 }
 public abstract SyntaxBlock DerivativeFormulate(SyntaxBlock Adir, SyntaxBlock Bdir);
示例#25
0
 /// <summary>
 /// Creates a sum syntax block which adds argument A and B together.
 /// </summary>
 /// <param name="A">The left side of the sum.</param>
 /// <param name="B">The right side of the sum.</param>
 public Sum(SyntaxBlock A, SyntaxBlock B) : base(A, B)
 {
 }
 public abstract bool ParallelEquals(SyntaxBlock ToCompare, int Depth);
示例#27
0
 public override SyntaxBlock DerivativeFormulate(SyntaxBlock Adir, SyntaxBlock Bdir)
 {
     return(new Sum(new Product(Adir, B), new Product(A, Bdir)));
 }
 public abstract bool Equals(SyntaxBlock ToCompare);