示例#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 = null;

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

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

            var gcd = exp_gcd(v, x);

            if (gcd != Symbolic.ZERO && gcd != Symbolic.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
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static Algebraic integrate(Algebraic expr, Variable v)throws JasymcaException
    public static Algebraic integrate(Algebraic expr, Variable v)
    {
        Algebraic e = (new ExpandUser()).f_exakt(expr);

        try
        {
            e = e.integrate(v);
            e = (new TrigInverseExpand()).f_exakt(e);
            e = remove_constant(e, v);
            return(e);
        }
        catch (JasymcaException)
        {
        }
        debug("Second Attempt: " + expr);
        expr = (new ExpandUser()).f_exakt(expr);
        debug("Expand User Functions: " + expr);
        expr = (new TrigExpand()).f_exakt(expr);
        e    = expr;
        try
        {
            expr = (new NormExp()).f_exakt(expr);
            debug("Norm Functions: " + expr);
            expr = expr.integrate(v);
            debug("Integrated: " + expr);
            expr = remove_constant(expr, v);
            expr = (new TrigInverseExpand()).f_exakt(expr);
            return(expr);
        }
        catch (JasymcaException)
        {
        }
        debug("Third Attempt: " + expr);
        expr = e;
        SubstExp se = new SubstExp(v, expr);

        expr = se.f_exakt(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()).f_exakt(expr);
        expr = remove_constant(expr, v);
        return(expr);
    }
示例#3
0
    public static Algebraic[] reduce_exp(Algebraic[] p)
    {
        ArrayList   v    = new ArrayList();
        ArrayList   vars = new ArrayList();
        GetExpVars2 g    = new GetExpVars2(v);

        for (int i = 0; i < p.Length; i++)
        {
            g.f_exakt(p[i]);
        }
        for (int i = 0; i < v.Count; i++)
        {
            Algebraic a = (Algebraic)v[i];
            Variable  x = null;
            if (a is Polynomial)
            {
                x = ((Polynomial)a).v;
            }
            else
            {
                continue;
            }
            if (vars.Contains(x))
            {
                continue;
            }
            else
            {
                vars.Add(x);
            }
            Zahl gcd = exp_gcd(v, x);
            if (!gcd.Equals(Zahl.ZERO) && !gcd.Equals(Zahl.ONE))
            {
                SubstExp sb = new SubstExp(gcd, x);
                for (int k = 0; k < p.Length; k++)
                {
                    p[k] = sb.f_exakt(p[k]);
                }
            }
        }
        return(p);
    }