Example #1
0
        static void Main(string[] args)
        {
            // Create some constants.
            Expression A = 2;
            Constant B = Constant.New(3);

            // Create some variables.
            Expression x = "x";
            Variable y = Variable.New("y");

            // Create a basic expressions.
            Expression f = A*x + B*y + 4;

            // This expression uses the implicit conversion from string to
            // Expression, which parses the string.
            Expression g = "5*x + C*y + 8";

            // Create a system of equations from the above expressions.
            var system = new List<Equal>()
            {
                Equal.New(f, 0),
                Equal.New(g, 0),
            };

            // We can now solve the system of equations for x and y. Since the
            // equations have a variable 'C', the solutions will not be
            // constants.
            List<Arrow> solutions = system.Solve(x, y);
            Console.WriteLine("The solutions are:");
            foreach (Arrow i in solutions)
                Console.WriteLine(i.ToString());

            // A fundamental building block of ComputerAlgebra is the 'Arrow'
            // expression. Arrow expressions define the value of one expression
            // to be the value given by another expression. For example, 'x->2'
            // defines the expression 'x' to have the value '2'.

            // The 'Solve' function used above returns a list of Arrow
            // expressions defining the solutions of the system.

            // Arrow expressions are used by the 'Evaluate' function to
            // substitute values for expressions into other expressions. To
            // demonstrate the usage of Evaluate, let's validate the solution
            // by using Evaluate to substitute the solutions into the original
            // system of equations, and then substitute a value for C.
            Expression f_xy = f.Evaluate(solutions).Evaluate(Arrow.New("C", 2));
            Expression g_xy = g.Evaluate(solutions).Evaluate(Arrow.New("C", 2));
            if ((f_xy == 0) && (g_xy == 0))
                Console.WriteLine("Success!");
            else
                Console.WriteLine("Failure! f = {0}, g = {1}", f_xy, g_xy);

            // Suppose we need to evaluate the solutions efficiently many times.
            // We can compile the solutions to delegates where 'C' is a
            // parameter to the delegate, allowing it to be specified later.
            var x_C = x.Evaluate(solutions).Compile<Func<double, double>>("C");
            var y_C = y.Evaluate(solutions).Compile<Func<double, double>>("C");

            for (int i = 0; i < 20; ++i)
            {
                double C = i / 2.0;
                Console.WriteLine("C = {0}: (x, y) = ({1}, {2})", C, x_C(C), y_C(C));
            }
        }
Example #2
0
        // Expand N(x)/D(x) using partial fractions.
        private static Expression ExpandPartialFractions(Expression N, Expression D, Expression x)
        {
            List<Expression> terms = new List<Expression>();
            List<Variable> unknowns = new List<Variable>();
            List<Expression> basis = new List<Expression>();
            foreach (Expression i in Product.TermsOf(D))
            {
                // Get the multiplicity of this basis term.
                Expression e = i;
                int n = Power.IntegralExponentOf(e);
                if (n != 1)
                    e = ((Power)i).Left;

                // Convert to a polynomial.
                Polynomial Pi = Polynomial.New(e, x);

                // Add new terms for each multiplicity n.
                for (int j = 1; j <= n; ++j)
                {
                    // Expression for the unknown numerator of this term.
                    Expression unknown = 0;
                    for (int k = 0; k < Pi.Degree; ++k)
                    {
                        Variable Ai = Variable.New("_A" + unknowns.Count.ToString());
                        unknown += Ai * (x ^ k);
                        unknowns.Add(Ai);
                    }

                    terms.Add(Product.New(unknown, Power.New(e, -j)));
                }
                basis.Add(i);
            }

            // Equate the original expression with the decomposed expressions.
            D = Sum.New(terms.Select(j => (Expression)(D * j))).Expand();
            Polynomial l = Polynomial.New(N, x);
            Polynomial r = Polynomial.New(D, x);

            // Equate terms of equal degree and solve for the unknowns.
            int degree = Math.Max(l.Degree, r.Degree);
            List<Equal> eqs = new List<Equal>(degree + 1);
            for (int i = 0; i <= degree; ++i)
                eqs.Add(Equal.New(l[i], r[i]));
            List<Arrow> A = eqs.Solve(unknowns);

            // Substitute the now knowns.
            return Sum.New(terms.Select(i => i.Evaluate(A)));
        }