jscl.math.Expression Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jscl Show documentation
java symbolic computing library and mathematical editor
There is a newer version: 2.4.17
package jscl.math;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import jscl.math.function.Frac;
import jscl.math.function.Inv;
import jscl.math.polynomial.Polynomial;
import jscl.math.polynomial.UnivariatePolynomial;
import jscl.text.ExpressionParser;
import jscl.text.ParseException;
import jscl.text.Parser;
import jscl.util.ArrayUtils;

public class Expression extends Generic {
    Literal literal[];
    JSCLInteger coef[];
    int size;

    Expression() {}

    Expression(int size) {
        init(size);
    }

    public int size() {
        return size;
    }

    public Literal literal(int n) {
        return literal[n];
    }

    public JSCLInteger coef(int n) {
        return coef[n];
    }

    void init(int size) {
        literal=new Literal[size];
        coef=new JSCLInteger[size];
        this.size=size;
    }

    void resize(int size) {
        int length=literal.length;
        if(size0?literal[--i1]:null;
        Literal l2=i2>0?expression.literal[--i2]:null;
        while(l1!=null || l2!=null) {
            int c=l1==null?1:(l2==null?-1:-l1.compareTo(l2));
            if(c<0) {
                JSCLInteger en=coef[i1];
                --i;
                ex.literal[i]=l1;
                ex.coef[i]=en;
                l1=i1>0?literal[--i1]:null;
            } else if(c>0) {
                JSCLInteger en=expression.coef[i2];
                --i;
                ex.literal[i]=l2;
                ex.coef[i]=en;
                l2=i2>0?expression.literal[--i2]:null;
            } else {
                JSCLInteger en=coef[i1].add(expression.coef[i2]);
                if(en.signum()!=0) {
                    --i;
                    ex.literal[i]=l1;
                    ex.coef[i]=en;
                }
                l1=i1>0?literal[--i1]:null;
                l2=i2>0?expression.literal[--i2]:null;
            }
        }
        ex.resize(ex.size-i);
        return ex;
    }

    public Generic add(Generic generic) {
        if(generic instanceof Expression) {
            return add((Expression)generic);
        } else if(generic instanceof JSCLInteger || generic instanceof Rational) {
            return add(valueof(generic));
        } else {
            return generic.valueof(this).add(generic);
        }
    }

    public Expression subtract(Expression expression) {
        return multiplyAndAdd(Literal.valueOf(),JSCLInteger.valueOf(-1),expression);
    }

    public Generic subtract(Generic generic) {
        if(generic instanceof Expression) {
            return subtract((Expression)generic);
        } else if(generic instanceof JSCLInteger || generic instanceof Rational) {
            return subtract(valueof(generic));
        } else {
            return generic.valueof(this).subtract(generic);
        }
    }

    Expression multiplyAndAdd(Literal lit, JSCLInteger integer, Expression expression) {
        if(integer.signum()==0) return this;
        Expression ex=newinstance(size+expression.size);
        int i=ex.size;
        int i1=size;
        int i2=expression.size;
        Literal l1=i1>0?literal[--i1]:null;
        Literal l2=i2>0?expression.literal[--i2].multiply(lit):null;
        while(l1!=null || l2!=null) {
            int c=l1==null?1:(l2==null?-1:-l1.compareTo(l2));
            if(c<0) {
                JSCLInteger en=coef[i1];
                --i;
                ex.literal[i]=l1;
                ex.coef[i]=en;
                l1=i1>0?literal[--i1]:null;
            } else if(c>0) {
                JSCLInteger en=expression.coef[i2].multiply(integer);
                --i;
                ex.literal[i]=l2;
                ex.coef[i]=en;
                l2=i2>0?expression.literal[--i2].multiply(lit):null;
            } else {
                JSCLInteger en=coef[i1].add(expression.coef[i2].multiply(integer));
                if(en.signum()!=0) {
                    --i;
                    ex.literal[i]=l1;
                    ex.coef[i]=en;
                }
                l1=i1>0?literal[--i1]:null;
                l2=i2>0?expression.literal[--i2].multiply(lit):null;
            }
        }
        ex.resize(ex.size-i);
        return ex;
    }

    public Expression multiply(Expression expression) {
        Expression ex=newinstance(0);
        for(int i=0;i=0;i--) en=en.gcd(coef[i]);
        return en;
    }

    public Literal literalScm() {
        Literal l=Literal.valueOf();
        for(int i=0;i1) {
                    Generic s=JSCLInteger.valueOf(0);
                    for(int i=0;i0) return 1;
            else {
                c=coef[i1].compareTo(expression.coef[i2]);
                if(c<0) return -1;
                else if(c>0) return 1;
                l1=i1==0?null:literal[--i1];
                l2=i2==0?null:expression.literal[--i2];
            }
        }
        return 0;
    }

    public int compareTo(Generic generic) {
        if(generic instanceof Expression) {
            return compareTo((Expression)generic);
        } else if(generic instanceof JSCLInteger || generic instanceof Rational) {
            return compareTo(valueof(generic));
        } else {
            return generic.valueof(this).compareTo(generic);
        }
    }

    public static Expression valueOf(Variable variable) {
        return valueOf(Literal.valueOf(variable));
    }

    public static Expression valueOf(Literal literal) {
        return valueOf(literal,JSCLInteger.valueOf(1));
    }

    public static Expression valueOf(JSCLInteger integer) {
        return valueOf(Literal.valueOf(),integer);
    }

    public static Expression valueOf(Literal literal, JSCLInteger integer) {
        Expression ex=new Expression();
        ex.init(literal,integer);
        return ex;
    }

    void init(Literal lit, JSCLInteger integer) {
        if(integer.signum()!=0) {
            init(1);
            literal[0]=lit;
            coef[0]=integer;
        } else init(0);
    }

    public static Expression valueOf(Rational rational) {
        Expression ex=new Expression();
        ex.init(rational);
        return ex;
    }

    public static Expression valueOf(String str) throws ParseException {
        int pos[]=new int[1];
        Generic a;
        try {
            a=(Generic)ExpressionParser.parser.parse(str,pos);
        } catch (ParseException e) {
            throw e;
        }
        Parser.skipWhitespaces(str,pos);
        if(pos[0]0 && i>0) buffer.append("+");
            if(l.degree()==0) buffer.append(en);
            else {
                if(en.abs().compareTo(JSCLInteger.valueOf(1))==0) {
                    if(en.signum()<0) buffer.append("-");
                } else buffer.append(en).append("*");
                buffer.append(l);
            }
        }
        return buffer.toString();
    }

    public String toMathML() {
	String s = "" + "0" + "";
	int n = 0;
	for(int i=0;i" + c.toMathML() + l.toMathML() + "";
	    s = n == 0?en.signum() < 0?"" + t + "":t:en.signum() < 0?"" + s + t + "":"" + s + t + "";
	    n++;
	}
	return s;
    }

    protected Expression newinstance(int n) {
        return new Expression(n);
    }
}