예제 #1
0
        public static Algebraic[] reduce_exp(Algebraic[] p)
        {
            var v    = new ArrayList();
            var vars = new ArrayList();

            var g = new GetExpVars2(v);

            foreach (var t in p)
            {
                g.SymEval(t);
            }

            foreach (var t in v)
            {
                var a = ( Algebraic )t;

                Variable x;

                if (a is Polynomial)
                {
                    x = (( Polynomial )a).Var;
                }
                else
                {
                    continue;
                }

                if (vars.Contains(x))
                {
                    continue;
                }

                vars.Add(x);

                var gcd = exp_gcd(v, x);

                if (gcd != Symbol.ZERO && gcd != Symbol.ONE)
                {
                    var sb = new SubstExp(gcd, x);

                    for (int k = 0; k < p.Length; k++)
                    {
                        p[k] = sb.SymEval(p[k]);
                    }
                }
            }

            return(p);
        }
예제 #2
0
        public static Algebraic Integrate(Algebraic expr, Variable v)
        {
            var e = new ExpandUser().SymEval(expr);

            try
            {
                e = e.Integrate(v);

                e = new TrigInverseExpand().SymEval(e);

                e = remove_constant(e, v);

                return(e);
            }
            catch (SymbolicException)
            {
            }

            Debug("Second Attempt: " + expr);

            expr = new ExpandUser().SymEval(expr);

            Debug("Expand User Functions: " + expr);

            expr = new TrigExpand().SymEval(expr);

            e = expr;

            try
            {
                expr = new NormExp().SymEval(expr);

                Debug("Norm Functions: " + expr);

                expr = expr.Integrate(v);

                Debug("Integrated: " + expr);

                expr = remove_constant(expr, v);

                expr = new TrigInverseExpand().SymEval(expr);

                return(expr);
            }
            catch (SymbolicException)
            {
            }

            Debug("Third Attempt: " + expr);

            expr = e;

            var se = new SubstExp(v, expr);

            expr = se.SymEval(expr);
            expr = se.rational(expr);

            Debug("Rationalized: " + expr);

            expr = expr.Integrate(se.t);

            Debug("Integrated: " + expr);

            expr = se.rat_reverse(expr);

            Debug("Reverse subst.: " + expr);

            expr = remove_constant(expr, v);

            expr = new TrigInverseExpand().SymEval(expr);

            expr = remove_constant(expr, v);

            return(expr);
        }