diff --git a/src/misc/lib/jscl.jar b/src/misc/lib/jscl.jar
new file mode 100644
index 00000000..7da29a66
Binary files /dev/null and b/src/misc/lib/jscl.jar differ
diff --git a/src/misc/src/jscl/editorengine/EditorEngine.java b/src/misc/src/jscl/editorengine/EditorEngine.java
new file mode 100644
index 00000000..619115ae
--- /dev/null
+++ b/src/misc/src/jscl/editorengine/EditorEngine.java
@@ -0,0 +1,58 @@
+package jscl.editorengine;
+
+import jscl.editor.Engine;
+import jscl.editor.EngineException;
+import bsh.Interpreter;
+import bsh.EvalError;
+
+public class EditorEngine extends Engine {
+	Interpreter interp=new Interpreter();
+
+	public EditorEngine() throws EngineException {
+		try {
+			interp.eval("importCommands(\"/jscl/editorengine/commands\");\n"
+			           +"mml(x) { return tomathml(x); }\n");
+		} catch (EvalError e) {
+			throw new EngineException(e);
+		}
+	}
+
+	public String eval(String str) throws EngineException {
+		int n=str.length()-1;
+		if(n<0 || "\n".equals(str.substring(n))) {
+			exec(str);
+			return str;
+		} else return eval0(str);
+	}
+
+	public void exec(String str) throws EngineException {
+		try {
+			interp.eval(str);
+		} catch (EvalError e) {
+			throw new EngineException(e);
+		}
+	}
+
+	String eval0(String str) throws EngineException {
+		try {
+			return interp.eval(commands(str)).toString();
+		} catch (EvalError e) {
+			throw new EngineException(e);
+		}
+	}
+
+	String commands(String str) {
+		return commands(str,false);
+	}
+
+	String commands(String str, boolean found) {
+		for(int i=0;i<cmds.length;i++) {
+			int n=str.length()-cmds[i].length()-1;
+			if(n>=0 && (" "+cmds[i].toLowerCase()).equals(str.substring(n))) return commands(str.substring(0,n),true)+"."+cmds[i]+"()";
+		}
+		str=str.replaceAll("\n","");
+		return found?"jscl.math.Expression.valueOf(\""+str+"\")":str;
+	}
+
+	static final String cmds[]=new String[] {"expand","factorize","elementary","simplify","numeric","toMathML","toJava"};
+}
diff --git a/src/misc/src/jscl/editorengine/EditorEngineFactory.java b/src/misc/src/jscl/editorengine/EditorEngineFactory.java
new file mode 100644
index 00000000..61fc96d6
--- /dev/null
+++ b/src/misc/src/jscl/editorengine/EditorEngineFactory.java
@@ -0,0 +1,11 @@
+package jscl.editorengine;
+
+import jscl.editor.Engine;
+import jscl.editor.EngineFactory;
+import jscl.editor.EngineException;
+
+public class EditorEngineFactory extends EngineFactory {
+	public Engine getEngine() throws EngineException {
+		return new EditorEngine();
+	}
+}
diff --git a/src/misc/src/jscl/editorengine/commands/elementary.bsh b/src/misc/src/jscl/editorengine/commands/elementary.bsh
new file mode 100644
index 00000000..f3c6cab7
--- /dev/null
+++ b/src/misc/src/jscl/editorengine/commands/elementary.bsh
@@ -0,0 +1,5 @@
+import jscl.math.Expression;
+
+String elementary(String expr) {
+	return Expression.valueOf(expr).elementary().toString();
+}
diff --git a/src/misc/src/jscl/editorengine/commands/expand.bsh b/src/misc/src/jscl/editorengine/commands/expand.bsh
new file mode 100644
index 00000000..0b7af2d2
--- /dev/null
+++ b/src/misc/src/jscl/editorengine/commands/expand.bsh
@@ -0,0 +1,5 @@
+import jscl.math.Expression;
+
+String expand(String expr) {
+	return Expression.valueOf(expr).expand().toString();
+}
diff --git a/src/misc/src/jscl/editorengine/commands/factorize.bsh b/src/misc/src/jscl/editorengine/commands/factorize.bsh
new file mode 100644
index 00000000..b21abe8e
--- /dev/null
+++ b/src/misc/src/jscl/editorengine/commands/factorize.bsh
@@ -0,0 +1,5 @@
+import jscl.math.Expression;
+
+String factorize(String expr) {
+	return Expression.valueOf(expr).factorize().toString();
+}
diff --git a/src/misc/src/jscl/editorengine/commands/numeric.bsh b/src/misc/src/jscl/editorengine/commands/numeric.bsh
new file mode 100644
index 00000000..d1d61910
--- /dev/null
+++ b/src/misc/src/jscl/editorengine/commands/numeric.bsh
@@ -0,0 +1,5 @@
+import jscl.math.Expression;
+
+String numeric(String expr) {
+	return Expression.valueOf(expr).numeric().toString();
+}
diff --git a/src/misc/src/jscl/editorengine/commands/simplify.bsh b/src/misc/src/jscl/editorengine/commands/simplify.bsh
new file mode 100644
index 00000000..c8a049fc
--- /dev/null
+++ b/src/misc/src/jscl/editorengine/commands/simplify.bsh
@@ -0,0 +1,5 @@
+import jscl.math.Expression;
+
+String simplify(String expr) {
+	return Expression.valueOf(expr).simplify().toString();
+}
diff --git a/src/misc/src/jscl/editorengine/commands/tojava.bsh b/src/misc/src/jscl/editorengine/commands/tojava.bsh
new file mode 100644
index 00000000..40e794e9
--- /dev/null
+++ b/src/misc/src/jscl/editorengine/commands/tojava.bsh
@@ -0,0 +1,5 @@
+import jscl.math.Expression;
+
+String tojava(String expr) {
+	return Expression.valueOf(expr).toJava();
+}
diff --git a/src/misc/src/jscl/editorengine/commands/tomathml.bsh b/src/misc/src/jscl/editorengine/commands/tomathml.bsh
new file mode 100644
index 00000000..81afd4f3
--- /dev/null
+++ b/src/misc/src/jscl/editorengine/commands/tomathml.bsh
@@ -0,0 +1,5 @@
+import jscl.math.Expression;
+
+String tomathml(String expr) {
+	return Expression.valueOf(expr).toMathML();
+}
diff --git a/src/misc/src/jscl/math/Antiderivative.java b/src/misc/src/jscl/math/Antiderivative.java
new file mode 100644
index 00000000..0b4f1a8a
--- /dev/null
+++ b/src/misc/src/jscl/math/Antiderivative.java
@@ -0,0 +1,228 @@
+package jscl.math;
+
+import jscl.math.function.Frac;
+import jscl.math.function.Inv;
+import jscl.math.function.Log;
+import jscl.math.function.Pow;
+import jscl.math.function.Root;
+import jscl.math.polynomial.Monomial;
+import jscl.math.polynomial.Polynomial;
+import jscl.math.polynomial.UnivariatePolynomial;
+
+public class Antiderivative {
+    UnivariatePolynomial factory;
+    PolynomialWithSyzygy syzygy;
+    Generic result;
+
+    Antiderivative(Variable variable) {
+        factory=(UnivariatePolynomial)Polynomial.factory(variable);
+        syzygy=(PolynomialWithSyzygy)PolynomialWithSyzygy.factory(variable);
+    }
+
+    public static Generic compute(Frac frac, Variable variable) {
+        Antiderivative s=new Antiderivative(variable);
+        s.compute(frac);
+        return s.getValue();
+    }
+
+    public static Generic compute(Root root, Variable variable) throws NotIntegrableException {
+        int d=root.degree();
+        Generic a[]=root.parameters();
+        boolean b=d>0;
+        b=b && a[0].negate().isIdentity(variable);
+        for(int i=1;i<d;i++) b=b && a[i].signum()==0;
+        b=b && a[d].compareTo(JSCLInteger.valueOf(1))==0;
+        if(b) {
+            return new Pow(
+                a[0].negate(),
+                new Inv(JSCLInteger.valueOf(d)).evaluate()
+            ).antiderivative(0);
+        } else throw new NotIntegrableException();
+    }
+
+    void compute(Frac frac) {
+        Debug.println("antiderivative");
+        Debug.increment();
+        Generic g[]=frac.parameters();
+        Generic r[]=reduce(g[0],g[1]);
+        r=divideAndRemainder(r[0],r[1]);
+        Generic s=new Inv(r[2]).evaluate();
+        Generic p=r[0].multiply(s);
+        Generic a=r[1].multiply(s);
+        result=p.antiderivative(factory.variable()).add(hermite(a,g[1]));
+        Debug.decrement();
+    }
+
+    Generic[] reduce(Generic n, Generic d) {
+        Debug.println("reduce("+n+", "+d+")");
+        Polynomial pn=factory.valueof(n);
+        Polynomial pd=factory.valueof(d);
+        Polynomial gcd=pn.gcd(pd);
+        return new Generic[] {
+            pn.divide(gcd).genericValue(),
+            pd.divide(gcd).genericValue()
+        };
+    }
+
+    Generic[] divideAndRemainder(Generic n, Generic d) {
+        Debug.println("divideAndRemainder("+n+", "+d+")");
+        Polynomial pn=syzygy.valueof(n,0);
+        Polynomial pd=syzygy.valueof(d,1);
+        PolynomialWithSyzygy pr=(PolynomialWithSyzygy)pn.remainderUpToCoefficient(pd);
+        return new Generic[] {
+            pr.syzygy[1].genericValue().negate(),
+            pr.genericValue(),
+            pr.syzygy[0].genericValue()
+        };
+    }
+
+    Generic[] bezout(Generic a, Generic b) {
+        Debug.println("bezout("+a+", "+b+")");
+        Polynomial pa=syzygy.valueof(a,0);
+        Polynomial pb=syzygy.valueof(b,1);
+        PolynomialWithSyzygy gcd=(PolynomialWithSyzygy)pa.gcd(pb);
+        return new Generic[] {
+            gcd.syzygy[0].genericValue(),
+            gcd.syzygy[1].genericValue(),
+            gcd.genericValue()
+        };
+    }
+
+    Generic hermite(Generic a, Generic d) {
+        Debug.println("hermite("+a+", "+d+")");
+        UnivariatePolynomial sd[]=((UnivariatePolynomial)factory.valueof(d)).squarefreeDecomposition();
+        int m=sd.length-1;
+        if(m<2) return trager(a,d);
+        else {
+            Generic u=sd[0].genericValue();
+            for(int i=1;i<m;i++) {
+                u=u.multiply(sd[i].genericValue().pow(i));
+            }
+            Generic v=sd[m].genericValue();
+            Generic vprime=sd[m].derivative().genericValue();
+            Generic uvprime=u.multiply(vprime);
+            Generic r[]=bezout(uvprime,v);
+            Generic b=r[0].multiply(a);
+            Generic c=r[1].multiply(a);
+            Generic s=r[2];
+            r=divideAndRemainder(b,v);
+            b=r[1];
+            c=c.multiply(r[2]).add(r[0].multiply(uvprime));
+            s=new Inv(s.multiply(r[2]).multiply(JSCLInteger.valueOf(1-m))).evaluate();
+            b=b.multiply(s);
+            c=c.multiply(s);
+            Generic bprime=((UnivariatePolynomial)factory.valueof(b)).derivative().genericValue();
+            return new Frac(b,v.pow(m-1)).evaluate().add(hermite(JSCLInteger.valueOf(1-m).multiply(c).subtract(u.multiply(bprime)),u.multiply(v.pow(m-1))));
+        }
+    }
+
+    Generic trager(Generic a, Generic d) {
+        Debug.println("trager("+a+", "+d+")");
+        Variable t=new TechnicalVariable("t");
+        UnivariatePolynomial pd=(UnivariatePolynomial)factory.valueof(d);
+        UnivariatePolynomial pa=(UnivariatePolynomial)factory.valueof(a).subtract(pd.derivative().multiply(t.expressionValue()));
+        UnivariatePolynomial rs[]=pd.remainderSequence(pa);
+        Polynomial fact=UnivariatePolynomial.factory(t);
+        for(int i=0;i<rs.length;i++) if(rs[i]!=null) rs[i]=(UnivariatePolynomial)fact.valueof((i>0?rs[i].normalize():rs[i]).genericValue());
+        UnivariatePolynomial q[]=rs[0].squarefreeDecomposition();
+        int m=q.length-1;
+        Generic s=JSCLInteger.valueOf(0);
+        for(int i=1;i<=m;i++) {
+            for(int j=0;j<q[i].degree();j++) {
+                Generic a2=new Root(q[i],j).evaluate();
+                s=s.add(a2.multiply(new Log(i==pd.degree()?d:rs[i].substitute(a2)).evaluate()));
+            }
+        }
+        return s;
+    }
+
+    Generic getValue() {
+        return result;
+    }
+}
+
+class PolynomialWithSyzygy extends UnivariatePolynomial {
+    Polynomial syzygy[]=new Polynomial[2];
+
+    PolynomialWithSyzygy(Variable variable) {
+        super(variable);
+    }
+
+    public Polynomial subtract(Polynomial polynomial) {
+        PolynomialWithSyzygy p2=(PolynomialWithSyzygy)polynomial;
+        PolynomialWithSyzygy p=(PolynomialWithSyzygy)super.subtract(p2);
+        for(int i=0;i<syzygy.length;i++) p.syzygy[i]=syzygy[i].subtract(p2.syzygy[i]);
+        return p;
+    }
+
+    public Polynomial multiply(Generic generic) {
+        PolynomialWithSyzygy p=(PolynomialWithSyzygy)super.multiply(generic);
+        for(int i=0;i<syzygy.length;i++) p.syzygy[i]=syzygy[i].multiply(generic);
+        return p;
+    }
+
+    public Polynomial multiply(Monomial monomial, Generic generic) {
+        PolynomialWithSyzygy p=(PolynomialWithSyzygy)super.multiply(monomial,generic);
+        for(int i=0;i<syzygy.length;i++) p.syzygy[i]=syzygy[i].multiply(monomial).multiply(generic);
+        return p;
+    }
+
+    public Polynomial divide(Generic generic) throws ArithmeticException {
+        PolynomialWithSyzygy p=(PolynomialWithSyzygy)super.divide(generic);
+        for(int i=0;i<syzygy.length;i++) p.syzygy[i]=syzygy[i].divide(generic);
+        return p;
+    }
+
+    public Polynomial remainderUpToCoefficient(Polynomial polynomial) throws ArithmeticException {
+        PolynomialWithSyzygy p=this;
+        PolynomialWithSyzygy q=(PolynomialWithSyzygy)polynomial;
+        if(p.signum()==0) return p;
+        int d=p.degree();
+        int d2=q.degree();
+        for(int i=d-d2;i>=0;i--) {
+            Generic c1=p.get(i+d2);
+            Generic c2=q.get(d2);
+            Generic c=c1.gcd(c2);
+            c1=c1.divide(c);
+            c2=c2.divide(c);
+            p=(PolynomialWithSyzygy)p.multiply(c2).subtract(q.multiply(monomial(Literal.valueOf(variable,i)),c1)).normalize();
+        }
+        return p;
+    }
+
+    public Polynomial gcd(Polynomial polynomial) {
+        Polynomial p=this;
+        Polynomial q=polynomial;
+        while(q.signum()!=0) {
+            Polynomial r=p.remainderUpToCoefficient(q);
+            p=q;
+            q=r;
+        }
+        return p;
+    }
+
+    public Generic gcd() {
+        Generic a=super.gcd();
+        for(int i=0;i<syzygy.length;i++) a=a.gcd(syzygy[i].gcd());
+        return a.signum()==signum()?a:a.negate();
+    }
+
+    public PolynomialWithSyzygy valueof(Generic generic, int n) {
+        PolynomialWithSyzygy p=(PolynomialWithSyzygy)newinstance();
+        p.init(generic,n);
+        return p;
+    }
+
+    public static Polynomial factory(Variable variable) {
+        return new PolynomialWithSyzygy(variable);
+    }
+
+    void init(Generic generic, int n) {
+        init(generic);
+        for(int i=0;i<syzygy.length;i++) syzygy[i]=Polynomial.factory(variable).valueof(JSCLInteger.valueOf(i==n?1:0));
+    }
+
+    protected UnivariatePolynomial newinstance() {
+        return new PolynomialWithSyzygy(variable);
+    }
+}
diff --git a/src/misc/src/jscl/math/Arithmetic.java b/src/misc/src/jscl/math/Arithmetic.java
new file mode 100644
index 00000000..a25550aa
--- /dev/null
+++ b/src/misc/src/jscl/math/Arithmetic.java
@@ -0,0 +1,8 @@
+package jscl.math;
+
+public interface Arithmetic {
+        abstract Arithmetic add(Arithmetic arithmetic);
+        abstract Arithmetic subtract(Arithmetic arithmetic);
+        abstract Arithmetic multiply(Arithmetic arithmetic);
+        abstract Arithmetic divide(Arithmetic arithmetic) throws ArithmeticException;
+}
diff --git a/src/misc/src/jscl/math/Debug.java b/src/misc/src/jscl/math/Debug.java
new file mode 100644
index 00000000..7361f9b1
--- /dev/null
+++ b/src/misc/src/jscl/math/Debug.java
@@ -0,0 +1,38 @@
+package jscl.math;
+
+import java.io.PrintStream;
+
+public class Debug {
+    static PrintStream out;
+    static int indentation;
+
+    private Debug() {}
+
+    public static void println(Object x) {
+        if(out==null);
+        else {
+            for(int i=0;i<indentation;i++) out.print(' ');
+            out.println(x);
+        }
+    }
+
+    public static void setOutputStream(PrintStream out) {
+        Debug.out=out;
+    }
+
+    public static PrintStream getOutputStream() {
+        return out;
+    }
+
+    public static void increment() {
+        indentation++;
+    }
+
+    public static void decrement() {
+        indentation--;
+    }
+
+    public static void reset() {
+        indentation=0;
+    }
+}
diff --git a/src/misc/src/jscl/math/DoubleVariable.java b/src/misc/src/jscl/math/DoubleVariable.java
new file mode 100644
index 00000000..179bd137
--- /dev/null
+++ b/src/misc/src/jscl/math/DoubleVariable.java
@@ -0,0 +1,44 @@
+package jscl.math;
+
+public class DoubleVariable extends GenericVariable {
+    public DoubleVariable(Generic generic) {
+        super(generic);
+    }
+
+    public JSCLInteger symbolic() {
+        return ((NumericWrapper)content).integerValue();
+    }
+
+    public Generic antiderivative(Variable variable) throws NotIntegrableException {
+        return expressionValue().multiply(variable.expressionValue());
+    }
+
+    public Generic derivative(Variable variable) {
+        return JSCLInteger.valueOf(0);
+    }
+
+    public Generic substitute(Variable variable, Generic generic) {
+        if(isIdentity(variable)) return generic;
+        else return expressionValue();
+    }
+
+    public Generic expand() {
+        return expressionValue();
+    }
+
+    public Generic factorize() {
+        return expressionValue();
+    }
+
+    public Generic elementary() {
+        return expressionValue();
+    }
+
+    public Generic simplify() {
+        return expressionValue();
+    }
+
+    protected Variable newinstance() {
+        return new DoubleVariable(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/Expression.java b/src/misc/src/jscl/math/Expression.java
new file mode 100644
index 00000000..1493eca1
--- /dev/null
+++ b/src/misc/src/jscl/math/Expression.java
@@ -0,0 +1,709 @@
+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.mathml.MathML;
+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(size<length) {
+            Literal literal[]=new Literal[size];
+            JSCLInteger coef[]=new JSCLInteger[size];
+            System.arraycopy(this.literal,length-size,literal,0,size);
+            System.arraycopy(this.coef,length-size,coef,0,size);
+            this.literal=literal;
+            this.coef=coef;
+            this.size=size;
+        }
+    }
+
+    public Expression add(Expression expression) {
+        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]: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<size;i++) ex=ex.multiplyAndAdd(literal[i],coef[i],expression);
+        return ex;
+    }
+
+    public Generic multiply(Generic generic) {
+        if(generic instanceof Expression) {
+            return multiply((Expression)generic);
+        } else if(generic instanceof JSCLInteger) {
+            return multiply(valueof(generic));
+        } else if(generic instanceof Rational) {
+            return multiply(valueof(generic));
+        } else {
+            return generic.multiply(this);
+        }
+    }
+
+    public Generic divide(Generic generic) throws ArithmeticException {
+        Generic a[]=divideAndRemainder(generic);
+        if(a[1].signum()==0) return a[0];
+        else throw new NotDivisibleException();
+    }
+
+    public Generic[] divideAndRemainder(Generic generic) throws ArithmeticException {
+        if(generic instanceof Expression) {
+            Expression ex=(Expression)generic;
+            Literal l1=literalScm();
+            Literal l2=ex.literalScm();
+            Literal l=(Literal)l1.gcd(l2);
+            Variable va[]=l.variables();
+            if(va.length==0) {
+                if(signum()==0 && ex.signum()!=0) return new Generic[] {this,JSCLInteger.valueOf(0)};
+                else try {
+                    return divideAndRemainder(ex.integerValue());
+                } catch (NotIntegerException e) {
+                    return new Generic[] {JSCLInteger.valueOf(0),this};
+                }
+            } else {
+                Polynomial fact=Polynomial.factory(va[0]);
+                Polynomial p[]=fact.valueof(this).divideAndRemainder(fact.valueof(ex));
+                return new Generic[] {p[0].genericValue(),p[1].genericValue()};
+            }
+        } else if(generic instanceof JSCLInteger) {
+            try {
+                Expression ex=newinstance(size);
+                for(int i=0;i<size;i++) {
+                    ex.literal[i]=literal[i];
+                    ex.coef[i]=coef[i].divide((JSCLInteger)generic);
+                }
+                return new Generic[] {ex,JSCLInteger.valueOf(0)};
+            } catch (NotDivisibleException e) {
+                return new Generic[] {JSCLInteger.valueOf(0),this};
+            }
+        } else if(generic instanceof Rational) {
+            return divideAndRemainder(valueof(generic));
+        } else {
+            return generic.valueof(this).divideAndRemainder(generic);
+        }
+    }
+
+    public Generic gcd(Generic generic) {
+        if(generic instanceof Expression) {
+            Expression ex=(Expression)generic;
+            Literal l1=literalScm();
+            Literal l2=ex.literalScm();
+            Literal l=(Literal)l1.gcd(l2);
+            Variable va[]=l.variables();
+            if(va.length==0) {
+                if(signum()==0) return ex;
+                else return gcd(ex.gcd());
+            } else {
+                Polynomial fact=Polynomial.factory(va[0]);
+                return fact.valueof(this).gcd(fact.valueof(ex)).genericValue();
+            }
+        } else if(generic instanceof JSCLInteger) {
+            if(generic.signum()==0) return this;
+            else return gcd().gcd(generic);
+        } else if(generic instanceof Rational) {
+            return gcd(valueof(generic));
+        } else {
+            return generic.valueof(this).gcd(generic);
+        }
+    }
+
+    public Generic gcd() {
+        JSCLInteger en=JSCLInteger.valueOf(0);
+        for(int i=size-1;i>=0;i--) en=en.gcd(coef[i]);
+        return en;
+    }
+
+    public Literal literalScm() {
+        Literal l=Literal.valueOf();
+        for(int i=0;i<size;i++) l=l.scm(literal[i]);
+        return l;
+    }
+
+    public Generic negate() {
+        return multiply(JSCLInteger.valueOf(-1));
+    }
+
+    public int signum() {
+        return size==0?0:coef[0].signum();
+    }
+
+    public int degree() {
+        return 0;
+    }
+
+    public Generic antiderivative(Variable variable) throws NotIntegrableException {
+        if(isPolynomial(variable)) {
+            return ((UnivariatePolynomial)Polynomial.factory(variable).valueof(this)).antiderivative().genericValue();
+        } else {
+            try {
+                Variable v=variableValue();
+                try {
+                    return v.antiderivative(variable);
+                } catch (NotIntegrableException e) {
+                    if(v instanceof Frac) {
+                        Generic g[]=((Frac)v).parameters();
+                        if(g[1].isConstant(variable)) {
+                            return new Inv(g[1]).evaluate().multiply(g[0].antiderivative(variable));
+                        }
+                    }
+                }
+            } catch (NotVariableException e) {
+                Generic a[]=sumValue();
+                if(a.length>1) {
+                    Generic s=JSCLInteger.valueOf(0);
+                    for(int i=0;i<a.length;i++) {
+                        s=s.add(a[i].antiderivative(variable));
+                    }
+                    return s;
+                } else {
+                    Generic p[]=a[0].productValue();
+                    Generic s=JSCLInteger.valueOf(1);
+                    Generic t=JSCLInteger.valueOf(1);
+                    for(int i=0;i<p.length;i++) {
+                        if(p[i].isConstant(variable)) s=s.multiply(p[i]);
+                        else t=t.multiply(p[i]);
+                    }
+                    if(s.compareTo(JSCLInteger.valueOf(1))==0);
+                    else return s.multiply(t.antiderivative(variable));
+                }
+            }
+        }
+        throw new NotIntegrableException();
+    }
+
+    public Generic derivative(Variable variable) {
+        Generic s=JSCLInteger.valueOf(0);
+        Literal l=literalScm();
+        int n=l.size;
+        for(int i=0;i<n;i++) {
+            Variable v=l.variable[i];
+            Generic a=((UnivariatePolynomial)Polynomial.factory(v).valueof(this)).derivative(variable).genericValue();
+            s=s.add(a);
+        }
+        return s;
+    }
+
+    public Generic substitute(Variable variable, Generic generic) {
+        Map m=literalScm().content();
+        Iterator it=m.entrySet().iterator();
+        while(it.hasNext()) {
+            Map.Entry e=(Map.Entry)it.next();
+            Variable v=(Variable)e.getKey();
+            e.setValue(v.substitute(variable,generic));
+        }
+        return substitute(m);
+    }
+
+    Generic substitute(Map map) {
+        Generic s=JSCLInteger.valueOf(0);
+        for(int i=0;i<size;i++) {
+            Literal l=literal[i];
+            Generic a=coef[i];
+            int m=l.size;
+            for(int j=0;j<m;j++) {
+                Variable v=l.variable[j];
+                int c=l.power[j];
+                Generic b=(Generic)map.get(v);
+                b=b.pow(c);
+                if(Matrix.product(a,b)) throw new ArithmeticException();
+                a=a.multiply(b);
+            }
+            s=s.add(a);
+        }
+        return s;
+    }
+
+    public Generic expand() {
+        Map m=literalScm().content();
+        Iterator it=m.entrySet().iterator();
+        while(it.hasNext()) {
+            Map.Entry e=(Map.Entry)it.next();
+            Variable v=(Variable)e.getKey();
+            e.setValue(v.expand());
+        }
+        return substitute(m);
+    }
+
+    public Generic factorize() {
+        Map m=literalScm().content();
+        Iterator it=m.entrySet().iterator();
+        while(it.hasNext()) {
+            Map.Entry e=(Map.Entry)it.next();
+            Variable v=(Variable)e.getKey();
+            e.setValue(v.factorize());
+        }
+        Generic a=substitute(m);
+        return Factorization.compute(a);
+    }
+
+    public Generic elementary() {
+        Map m=literalScm().content();
+        Iterator it=m.entrySet().iterator();
+        while(it.hasNext()) {
+            Map.Entry e=(Map.Entry)it.next();
+            Variable v=(Variable)e.getKey();
+            e.setValue(v.elementary());
+        }
+        return substitute(m);
+    }
+
+    public Generic simplify() {
+        return Simplification.compute(this);
+    }
+
+    public Generic numeric() {
+        try {
+            return integerValue().numeric();
+        } catch (NotIntegerException ex) {
+            Map m=literalScm().content();
+            Iterator it=m.entrySet().iterator();
+            while(it.hasNext()) {
+                Map.Entry e=(Map.Entry)it.next();
+                Variable v=(Variable)e.getKey();
+                e.setValue(v.numeric());
+            }
+            return substitute(m);
+        }
+    }
+
+    public Generic valueof(Generic generic) {
+        Expression ex=newinstance(0);
+        ex.init(generic);
+        return ex;
+    }
+
+    public Generic[] sumValue() {
+        Generic a[]=new Generic[size];
+        for(int i=0;i<a.length;i++) a[i]=valueOf(literal[i],coef[i]);
+        return a;
+    }
+
+    public Generic[] productValue() throws NotProductException {
+        if(size==0) return new Generic[] {JSCLInteger.valueOf(0)};
+        else if(size==1) {
+            Literal l=literal[0];
+            JSCLInteger en=coef[0];
+            Generic p[]=l.productValue();
+            if(en.compareTo(JSCLInteger.valueOf(1))==0) return p;
+            else {
+                Generic a[]=new Generic[p.length+1];
+                for(int i=0;i<p.length;i++) a[i+1]=p[i];
+                a[0]=en;
+                return a;
+            }
+        } else throw new NotProductException();
+    }
+
+    public Power powerValue() throws NotPowerException {
+        if(size==0) return new Power(JSCLInteger.valueOf(0),1);
+        else if(size==1) {
+            Literal l=literal[0];
+            JSCLInteger en=coef[0];
+            if(en.compareTo(JSCLInteger.valueOf(1))==0) return l.powerValue();
+            else if(l.degree()==0) return en.powerValue();
+            else throw new NotPowerException();
+        } else throw new NotPowerException();
+    }
+
+    public Expression expressionValue() throws NotExpressionException {
+        return this;
+    }
+
+    public JSCLInteger integerValue() throws NotIntegerException {
+        if(size==0) return JSCLInteger.valueOf(0);
+        else if(size==1) {
+            Literal l=literal[0];
+            JSCLInteger en=coef[0];
+            if(l.degree()==0) return en;
+            else throw new NotIntegerException();
+        } else throw new NotIntegerException();
+    }
+
+    public Variable variableValue() throws NotVariableException {
+        if(size==0) throw new NotVariableException();
+        else if(size==1) {
+            Literal l=literal[0];
+            JSCLInteger en=coef[0];
+            if(en.compareTo(JSCLInteger.valueOf(1))==0) return l.variableValue();
+            else throw new NotVariableException();
+        } else throw new NotVariableException();
+    }
+
+    public Variable[] variables() {
+        return literalScm().variables();
+    }
+
+    public static Variable[] variables(Generic generic[]) {
+        List l=new ArrayList();
+        for(int i=0;i<generic.length;i++) {
+            Variable va[]=generic[i].variables();
+            for(int j=0;j<va.length;j++) {
+                Variable v=va[j];
+                if(l.contains(v));
+                else l.add(v);
+            }
+        }
+        return (Variable[])ArrayUtils.toArray(l,new Variable[l.size()]);
+    }
+
+    public boolean isPolynomial(Variable variable) {
+        boolean s=true;
+        Literal l=literalScm();
+        int n=l.size;
+        for(int i=0;i<n;i++) {
+            Variable v=l.variable[i];
+            s=s && (v.isConstant(variable) || v.isIdentity(variable));
+        }
+        return s;
+    }
+
+    public boolean isConstant(Variable variable) {
+        boolean s=true;
+        Literal l=literalScm();
+        int n=l.size;
+        for(int i=0;i<n;i++) {
+            Variable v=l.variable[i];
+            s=s && v.isConstant(variable);
+        }
+        return s;
+    }
+
+    public JSCLVector grad(Variable variable[]) {
+        Generic v[]=new Generic[variable.length];
+        for(int i=0;i<variable.length;i++) v[i]=derivative(variable[i]);
+        return new JSCLVector(v);
+    }
+
+    public Generic laplacian(Variable variable[]) {
+        return grad(variable).divergence(variable);
+    }
+
+    public Generic dalembertian(Variable variable[]) {
+        Generic a=derivative(variable[0]).derivative(variable[0]);
+        for(int i=1;i<4;i++) a=a.subtract(derivative(variable[i]).derivative(variable[i]));
+        return a;
+    }
+
+    public int compareTo(Expression expression) {
+        int i1=size;
+        int i2=expression.size;
+        Literal l1=i1==0?null:literal[--i1];
+        Literal l2=i2==0?null:expression.literal[--i2];
+        while(l1!=null || l2!=null) {
+            int c=l1==null?-1:(l2==null?1:l1.compareTo(l2));
+            if(c<0) return -1;
+            else if(c>0) 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]<str.length()) {
+            throw new ParseException();
+        }
+        Expression ex=new Expression();
+        ex.init(a);
+        return ex;
+    }
+
+    void init(Expression expression) {
+        init(expression.size);
+        System.arraycopy(expression.literal,0,literal,0,size);
+        System.arraycopy(expression.coef,0,coef,0,size);
+    }
+
+    void init(JSCLInteger integer) {
+        init(Literal.valueOf(),integer);
+    }
+
+    void init(Rational rational) {
+        try {
+            init(Literal.valueOf(),rational.integerValue());
+        } catch (NotIntegerException e) {
+            init(Literal.valueOf(rational.variableValue()),JSCLInteger.valueOf(1));
+        }
+    }
+
+    void init(Generic generic) {
+        if(generic instanceof Expression) {
+            init((Expression)generic);
+        } else if(generic instanceof JSCLInteger) {
+            init((JSCLInteger)generic);
+        } else if(generic instanceof Rational) {
+            init((Rational)generic);
+        } else throw new ArithmeticException();
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        if(signum()==0) buffer.append("0");
+        for(int i=0;i<size;i++) {
+            Literal l=literal[i];
+            JSCLInteger en=coef[i];
+            if(en.signum()>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 toJava() {
+        StringBuffer buffer=new StringBuffer();
+        if(signum()==0) buffer.append("JSCLDouble.valueOf(0)");
+        for(int i=0;i<size;i++) {
+            Literal l=literal[i];
+            JSCLInteger en=coef[i];
+            if(i>0) {
+                if(en.signum()<0) {
+                    buffer.append(".subtract(");
+                    en=(JSCLInteger)en.negate();
+                } else buffer.append(".add(");
+            }
+            if(l.degree()==0) buffer.append(en.toJava());
+            else {
+                if(en.abs().compareTo(JSCLInteger.valueOf(1))==0) {
+                    if(en.signum()>0) buffer.append(l.toJava());
+                    else if(en.signum()<0) buffer.append(l.toJava()).append(".negate()");
+                } else buffer.append(en.toJava()).append(".multiply(").append(l.toJava()).append(")");
+            }
+            if(i>0) buffer.append(")");
+        }
+        return buffer.toString();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        MathML e1=element.element("mrow");
+        if(signum()==0) {
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text("0"));
+            e1.appendChild(e2);
+        }
+        for(int i=0;i<size;i++) {
+            Literal l=literal[i];
+            JSCLInteger en=coef[i];
+            if(en.signum()>0 && i>0) {
+                MathML e2=element.element("mo");
+                e2.appendChild(element.text("+"));
+                e1.appendChild(e2);
+            }
+            if(l.degree()==0) separateSign(e1,en);
+            else {
+                if(en.abs().compareTo(JSCLInteger.valueOf(1))==0) {
+                    if(en.signum()<0) {
+                        MathML e2=element.element("mo");
+                        e2.appendChild(element.text("-"));
+                        e1.appendChild(e2);
+                    }
+                } else separateSign(e1,en);
+                l.toMathML(e1,null);
+            }
+        }
+        element.appendChild(e1);
+    }
+
+    public static void separateSign(MathML element, Generic generic) {
+        if(generic.signum()<0) {
+            MathML e1=element.element("mo");
+            e1.appendChild(element.text("-"));
+            element.appendChild(e1);
+            generic.negate().toMathML(element,null);
+        } else generic.toMathML(element,null);
+    }
+
+    protected Expression newinstance(int n) {
+        return new Expression(n);
+    }
+}
diff --git a/src/misc/src/jscl/math/ExpressionVariable.java b/src/misc/src/jscl/math/ExpressionVariable.java
new file mode 100644
index 00000000..745a9a0c
--- /dev/null
+++ b/src/misc/src/jscl/math/ExpressionVariable.java
@@ -0,0 +1,57 @@
+package jscl.math;
+
+import jscl.mathml.MathML;
+
+public class ExpressionVariable extends GenericVariable {
+        public ExpressionVariable(Generic generic) {
+                super(generic);
+        }
+
+        public Generic substitute(Variable variable, Generic generic) {
+                if(isIdentity(variable)) return generic;
+                else return content.substitute(variable,generic);
+        }
+
+        public Generic elementary() {
+                return content.elementary();
+        }
+
+        public Generic simplify() {
+                return content.simplify();
+        }
+
+        public String toString() {
+                StringBuffer buffer=new StringBuffer();
+                buffer.append("(").append(content).append(")");
+                return buffer.toString();
+        }
+
+        public String toJava() {
+                StringBuffer buffer=new StringBuffer();
+                buffer.append("(").append(content.toJava()).append(")");
+                return buffer.toString();
+        }
+
+    public void toMathML(MathML element, Object data) {
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) bodyToMathML(element);
+        else {
+            MathML e1=element.element("msup");
+            bodyToMathML(e1);
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+
+    void bodyToMathML(MathML element) {
+        MathML e1=element.element("mfenced");
+        content.toMathML(e1,null);
+        element.appendChild(e1);
+    }
+
+        protected Variable newinstance() {
+                return new ExpressionVariable(null);
+        }
+}
diff --git a/src/misc/src/jscl/math/Factorization.java b/src/misc/src/jscl/math/Factorization.java
new file mode 100644
index 00000000..5c72ea42
--- /dev/null
+++ b/src/misc/src/jscl/math/Factorization.java
@@ -0,0 +1,290 @@
+package jscl.math;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import jscl.math.polynomial.Basis;
+import jscl.math.polynomial.Monomial;
+import jscl.math.polynomial.Ordering;
+import jscl.math.polynomial.Polynomial;
+import jscl.util.ArrayComparator;
+import jscl.util.ArrayUtils;
+
+public class Factorization {
+    Polynomial factory;
+    Generic result;
+
+    Factorization(Polynomial factory) {
+        this.factory=factory;
+    }
+
+    public static Generic compute(Generic generic) {
+        try {
+            return GenericVariable.content(factorize(generic.integerValue()));
+        } catch (NotIntegerException e) {
+            Factorization f=new Factorization(Polynomial.factory(generic.variables(),Monomial.iteratorOrdering,-1));
+            f.computeValue(generic);
+            return f.getValue();
+        }
+    }
+
+    static Generic factorize(JSCLInteger integer) {
+        Generic n[]=integer.gcdAndNormalize();
+        Generic s=n[1];
+        Generic a=JSCLInteger.valueOf(1);
+        Generic p=JSCLInteger.valueOf(2);
+        while(s.compareTo(JSCLInteger.valueOf(1))>0) {
+            Generic q[]=s.divideAndRemainder(p);
+            if(q[0].compareTo(p)<0) {
+                p=s;
+                q=s.divideAndRemainder(p);
+            }
+            if(q[1].signum()==0) {
+                a=a.multiply(expression(p,true));
+                s=q[0];
+            } else p=p.add(JSCLInteger.valueOf(1));
+        }
+        return a.multiply(n[0]);
+    }
+
+    void computeValue(Generic generic) {
+        Debug.println("factorization");
+        Polynomial n[]=factory.valueof(generic).gcdAndNormalize();
+        Monomial m=n[1].monomialGcd();
+        Polynomial s=n[1].divide(m);
+        Generic a=JSCLInteger.valueOf(1);
+        Divisor d[]=new Divisor[2];
+        Monomial p[]=new Monomial[2];
+        Monomial q[]=new Monomial[2];
+        d[1]=new Divisor(s.head().monomial());
+        loop: while(d[1].hasNext()) {
+            p[1]=(Monomial)d[1].next();
+            q[1]=d[1].complementary();
+            d[0]=new Divisor(s.tail().monomial());
+            while(d[0].hasNext()) {
+                p[0]=(Monomial)d[0].next();
+                q[0]=d[0].complementary();
+                if(p[1].compareTo(p[0])<=0) continue loop;
+                Debug.println(toString(p)+" * "+toString(q)+" = "+s);
+                if(ArrayComparator.comparator.compare(q,p)<0) {
+                    a=a.multiply(expression(s.genericValue()));
+                    break loop;
+                } else {
+                    Debug.increment();
+                    Polynomial r[]=remainder(s,polynomial(s,p),terminator(s));
+                    Debug.decrement();
+                    if(r[0].signum()==0) {
+                        a=a.multiply(expression(r[1].genericValue()));
+                        s=r[2];
+                        d[1].divide();
+                        d[0].divide();
+                        continue loop;
+                    }
+                }
+            }
+        }
+        result=a.multiply(n[0].multiply(m).genericValue());
+    }
+
+    static Polynomial[] remainder(Polynomial s, Polynomial p, Generic t[]) {
+        Polynomial zero=s.valueof(JSCLInteger.valueOf(0));
+        Generic a[]=Basis.augment(t,s.remainderUpToCoefficient(p).elements());
+        Variable unk[]=Basis.augmentUnknown(new Variable[] {},p.elements());
+        {
+            Variable u=unk[unk.length-1];
+            System.arraycopy(unk,0,unk,1,unk.length-1);
+            unk[0]=u;
+        }
+        Generic be[][]=Linearization.compute(Basis.compute(a,unk,Monomial.lexicographic,0,Basis.DEGREE).elements(),unk);
+        for(int i=0;i<be.length;i++) {
+            Polynomial r=substitute(p,be[i],unk);
+            try {
+                return new Polynomial[] {zero,r,s.divide(r)};
+            } catch(NotDivisibleException e) {}
+        } 
+        return new Polynomial[] {s,zero,zero};
+    }
+
+    static Polynomial substitute(Polynomial p, Generic a[], Variable unk[]) {
+        Generic s[]=new Generic[] {p.genericValue()};
+        return p.valueof(Basis.compute(Basis.augment(a,s),Basis.augmentUnknown(unk,s)).elements()[0]);
+    }
+
+    private static final String ter="t";
+
+    static Polynomial polynomial(Polynomial s, Monomial monomial[]) {
+        Polynomial p=s.valueof(JSCLInteger.valueOf(0));
+        Iterator it=monomial[1].iterator(monomial[0]);
+        for(int i=0;it.hasNext();i++) {
+            Monomial m=(Monomial)it.next();
+            Variable t=it.hasNext()?new TechnicalVariable(ter,new int[] {i}):new TechnicalVariable(ter);
+            p=p.add(p.valueof(m).multiply(t.expressionValue()));
+        }
+        return p;
+    }
+
+    static Generic[] terminator(Polynomial polynomial) {
+        Generic t[]=new Generic[2];
+        t[1]=terminator(polynomial.head().coef().abs(),new TechnicalVariable(ter),false);
+        t[0]=terminator(polynomial.tail().coef(),new TechnicalVariable(ter,new int[] {0}),true);
+        return t;
+    }
+
+    static Generic terminator(Generic generic, Variable var, boolean tail) {
+        Generic x=var.expressionValue();
+        Generic a=JSCLInteger.valueOf(1);
+        Iterator it=IntegerDivisor.create(generic.integerValue());
+        while(it.hasNext()) {
+            Generic s=(Generic)it.next();
+            a=a.multiply(x.subtract(s));
+            if(!tail) a=a.multiply(x.add(s));
+        }
+        return a;
+    }
+
+    static Generic expression(Generic generic) {
+        return expression(generic,false);
+    }
+
+    static Generic expression(Generic generic, boolean integer) {
+        if(generic.compareTo(JSCLInteger.valueOf(1))==0) return generic;
+        else return GenericVariable.valueOf(generic,integer).expressionValue();
+    }
+
+    static String toString(Monomial monomial[]) {
+        return "{"+monomial[0]+", "+monomial[1]+"}";
+    }
+
+    Generic getValue() {
+        return GenericVariable.content(result,true);
+    }
+}
+
+class Linearization {
+    Variable unknown[];
+    List result=new ArrayList();
+    
+    Linearization(Variable unknown[]) {
+        this.unknown=unknown;
+    }
+
+    static Generic[][] compute(Generic generic[], Variable unknown[]) {
+        Linearization l=new Linearization(unknown);
+        Debug.println("linearization");
+        Debug.increment();
+        l.process(generic);
+        Debug.decrement();
+        return l.getValue();
+    }
+
+    void process(Generic generic[]) {
+        boolean flag=true;
+        for(int i=0;i<generic.length;i++) {
+            Generic s=generic[i];
+            Variable va[]=s.variables();
+            if(va.length==1) {
+                Variable t=va[0];
+                Polynomial p=Polynomial.factory(t).valueof(s);
+                if(p.degree()>1) {
+                    flag=false;
+                    Polynomial r[]=linearize(p,t);
+                    for(int j=0;j<r.length;j++) {
+                        process(Basis.compute(Basis.augment(new Generic[] {r[j].genericValue()},generic),unknown).elements());
+                    }
+                }
+            } else flag=false;
+        }
+        if(flag) result.add(generic);
+    }
+
+    static Polynomial[] linearize(Polynomial polynomial, Variable variable) {
+        List l=new ArrayList();
+        Generic x=variable.expressionValue();
+        Polynomial s=polynomial;
+        try {
+            Polynomial r=s.valueof(x);
+            s=s.divide(r);
+            l.add(r);
+            while(true) s=s.divide(r);
+        } catch (NotDivisibleException e) {}
+        IntegerDivisor d[]=new IntegerDivisor[2];
+        Generic p[]=new Generic[2];
+        Generic q[]=new Generic[2];
+        d[1]=IntegerDivisor.create(JSCLInteger.valueOf(1));
+        loop: while(d[1].hasNext()) {
+            p[1]=(Generic)d[1].next();
+            q[1]=d[1].integer(d[1].complementary());
+            d[0]=IntegerDivisor.create(s.tail().coef().integerValue());
+            while(d[0].hasNext()) {
+                p[0]=(Generic)d[0].next();
+                q[0]=d[0].integer(d[0].complementary());
+                if(ArrayComparator.comparator.compare(q,p)<0) break loop;
+                for(int i=0;i<2;i++) {
+                    Polynomial r=s.valueof(i==0?p[1].multiply(x).subtract(p[0]):p[1].multiply(x).add(p[0]));
+                    for(boolean flag=true;true;flag=false) {
+                        try { s=s.divide(r); } catch (NotDivisibleException e) { break; }
+                        d[1].divide();
+                        d[0].divide();
+                        if(flag) l.add(r);
+                    }
+                }
+            }
+        }
+        return (Polynomial[])ArrayUtils.toArray(l,new Polynomial[l.size()]);
+    }
+
+    Generic[][] getValue() {
+        return (Generic[][])ArrayUtils.toArray(result,new Generic[result.size()][]);
+    }
+}
+
+class Divisor implements Iterator {
+    Monomial monomial;
+    Monomial current;
+    Iterator iterator;
+
+    Divisor(Monomial monomial) {
+        this.monomial=monomial;
+        iterator=monomial.divisor();
+    }
+
+    Monomial complementary() {
+        return monomial.divide(current);
+    }
+
+    void divide() {
+        monomial=complementary();
+        iterator=monomial.divisor(current);
+    }
+
+    public boolean hasNext() {
+        return iterator.hasNext();
+    }
+
+    public Object next() {
+        return current=(Monomial)iterator.next();
+    }
+
+    public void remove() {
+        throw new UnsupportedOperationException();
+    }
+}
+
+class IntegerDivisor extends Divisor {
+    IntegerDivisor(Generic generic, Variable unknown[], Ordering ordering) {
+        super(Polynomial.factory(unknown,ordering).valueof(generic).head().monomial());
+    }
+
+    public Object next() {
+        return integer((Monomial)super.next());
+    }
+
+    Generic integer(Monomial monomial) {
+        return Expression.valueOf(Literal.valueOf(monomial)).expand();
+    }
+
+    static IntegerDivisor create(JSCLInteger integer) {
+        Generic a=Factorization.factorize(integer);
+        return new IntegerDivisor(a,a.variables(),Monomial.iteratorOrdering);
+    }
+}
diff --git a/src/misc/src/jscl/math/Field.java b/src/misc/src/jscl/math/Field.java
new file mode 100644
index 00000000..40e79055
--- /dev/null
+++ b/src/misc/src/jscl/math/Field.java
@@ -0,0 +1,3 @@
+package jscl.math;
+
+public interface Field {}
diff --git a/src/misc/src/jscl/math/Generic.java b/src/misc/src/jscl/math/Generic.java
new file mode 100644
index 00000000..1e20965c
--- /dev/null
+++ b/src/misc/src/jscl/math/Generic.java
@@ -0,0 +1,138 @@
+package jscl.math;
+
+import jscl.mathml.MathML;
+
+public abstract class Generic implements Arithmetic, Comparable {
+    public abstract Generic add(Generic generic);
+
+    public Generic subtract(Generic generic) {
+        return add(generic.negate());
+    }
+
+    public abstract Generic multiply(Generic generic);
+
+    public boolean multiple(Generic generic) throws ArithmeticException {
+        return remainder(generic).signum()==0;
+    }
+
+    public abstract Generic divide(Generic generic) throws ArithmeticException;
+
+    public Arithmetic add(Arithmetic arithmetic) {
+        return add((Generic)arithmetic);
+    }
+
+    public Arithmetic subtract(Arithmetic arithmetic) {
+        return subtract((Generic)arithmetic);
+    }
+
+    public Arithmetic multiply(Arithmetic arithmetic) {
+        return multiply((Generic)arithmetic);
+    }
+
+    public Arithmetic divide(Arithmetic arithmetic) throws ArithmeticException {
+        return divide((Generic)arithmetic);
+    }
+
+    public Generic[] divideAndRemainder(Generic generic) throws ArithmeticException {
+        try {
+            return new Generic[] {divide(generic),JSCLInteger.valueOf(0)};
+        } catch (NotDivisibleException e) {
+            return new Generic[] {JSCLInteger.valueOf(0),this};
+        }
+    }
+
+    public Generic remainder(Generic generic) throws ArithmeticException {
+        return divideAndRemainder(generic)[1];
+    }
+
+    public Generic inverse() {
+        return JSCLInteger.valueOf(1).divide(this);
+    }
+
+    public abstract Generic gcd(Generic generic);
+
+    public Generic scm(Generic generic) {
+        return divide(gcd(generic)).multiply(generic);
+    }
+
+    public abstract Generic gcd();
+
+    public Generic[] gcdAndNormalize() {
+        Generic gcd=gcd();
+        if(gcd.signum()==0) return new Generic[] {gcd,this};
+        if(gcd.signum()!=signum()) gcd=gcd.negate();
+        return new Generic[] {gcd,divide(gcd)};
+    }
+
+    public Generic normalize() {
+        return gcdAndNormalize()[1];
+    }
+
+    public Generic pow(int exponent) {
+        Generic a=JSCLInteger.valueOf(1);
+        for(int i=0;i<exponent;i++) a=a.multiply(this);
+        return a;
+    }
+
+    public Generic abs() {
+        return signum()<0?negate():this;
+    }
+
+    public abstract Generic negate();
+    public abstract int signum();
+    public abstract int degree();
+
+//    public abstract Generic mod(Generic generic);
+//    public abstract Generic modPow(Generic exponent, Generic generic);
+//    public abstract Generic modInverse(Generic generic);
+//    public abstract boolean isProbablePrime(int certainty);
+    public abstract Generic antiderivative(Variable variable) throws NotIntegrableException;
+    public abstract Generic derivative(Variable variable);
+    public abstract Generic substitute(Variable variable, Generic generic);
+    public abstract Generic expand();
+    public abstract Generic factorize();
+    public abstract Generic elementary();
+    public abstract Generic simplify();
+    public abstract Generic numeric();
+    public abstract Generic valueof(Generic generic);
+    public abstract Generic[] sumValue();
+    public abstract Generic[] productValue() throws NotProductException;
+    public abstract Power powerValue() throws NotPowerException;
+    public abstract Expression expressionValue() throws NotExpressionException;
+    public abstract JSCLInteger integerValue() throws NotIntegerException;
+    public abstract Variable variableValue() throws NotVariableException;
+    public abstract Variable[] variables();
+    public abstract boolean isPolynomial(Variable variable);
+    public abstract boolean isConstant(Variable variable);
+
+    public boolean isIdentity(Variable variable) {
+        try {
+            return variableValue().isIdentity(variable);
+        } catch (NotVariableException e) {
+            return false;
+        }
+    }
+
+    public abstract int compareTo(Generic generic);
+
+    public int compareTo(Object o) {
+        return compareTo((Generic)o);
+    }
+
+    public boolean equals(Object obj) {
+        if(obj instanceof Generic) {
+            return compareTo((Generic)obj)==0;
+        } else return false;
+    }
+
+    public abstract String toJava();
+
+    public String toMathML() {
+        MathML document=new MathML("math","-//W3C//DTD MathML 2.0//EN","http://www.w3.org/TR/MathML2/dtd/mathml2.dtd");
+        MathML e=document.element("math");
+        toMathML(e,null);
+        return e.toString();
+    }
+
+    public abstract void toMathML(MathML element, Object data);
+}
diff --git a/src/misc/src/jscl/math/GenericVariable.java b/src/misc/src/jscl/math/GenericVariable.java
new file mode 100644
index 00000000..7df35cd7
--- /dev/null
+++ b/src/misc/src/jscl/math/GenericVariable.java
@@ -0,0 +1,105 @@
+package jscl.math;
+
+import jscl.mathml.MathML;
+
+public abstract class GenericVariable extends Variable {
+    Generic content;
+
+    GenericVariable(Generic generic) {
+        super("");
+        content=generic;
+    }
+
+    public static Generic content(Generic generic) {
+        return content(generic,false);
+    }
+
+    public static Generic content(Generic generic, boolean expression) {
+        try {
+            Variable v=generic.variableValue();
+            if(expression) {
+                if(v instanceof ExpressionVariable) generic=((ExpressionVariable)v).content;
+            } else {
+                if(v instanceof GenericVariable) generic=((GenericVariable)v).content;
+            }
+        } catch (NotVariableException e) {}
+        return generic;
+    }
+
+    public Generic antiderivative(Variable variable) throws NotIntegrableException {
+        return content.antiderivative(variable);
+    }
+
+    public Generic derivative(Variable variable) {
+        return content.derivative(variable);
+    }
+
+    public Generic substitute(Variable variable, Generic generic) {
+        GenericVariable v=(GenericVariable)newinstance();
+        v.content=content.substitute(variable,generic);
+        if(v.isIdentity(variable)) return generic;
+        else return v.expressionValue();
+    }
+
+    public Generic expand() {
+        return content.expand();
+    }
+
+    public Generic factorize() {
+        GenericVariable v=(GenericVariable)newinstance();
+        v.content=content.factorize();
+        return v.expressionValue();
+    }
+
+    public Generic elementary() {
+        GenericVariable v=(GenericVariable)newinstance();
+        v.content=content.elementary();
+        return v.expressionValue();
+    }
+
+    public Generic simplify() {
+        GenericVariable v=(GenericVariable)newinstance();
+        v.content=content.simplify();
+        return v.expressionValue();
+    }
+
+    public Generic numeric() {
+        return content.numeric();
+    }
+
+    public boolean isConstant(Variable variable) {
+        return content.isConstant(variable);
+    }
+
+    public int compareTo(Variable variable) {
+        if(this==variable) return 0;
+        int c=comparator.compare(this,variable);
+        if(c<0) return -1;
+        else if(c>0) return 1;
+        else {
+            GenericVariable v=(GenericVariable)variable;
+            return content.compareTo(v.content);
+        }
+    }
+
+    public static GenericVariable valueOf(Generic generic) {
+        return valueOf(generic,false);
+    }
+
+    public static GenericVariable valueOf(Generic generic, boolean integer) {
+        if(integer) return new IntegerVariable(generic);
+        else return new ExpressionVariable(generic);
+    }
+
+    public String toString() {
+        return content.toString();
+    }
+
+    public String toJava() {
+        return content.toJava();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        content.toMathML(element,data);
+    }
+}
diff --git a/src/misc/src/jscl/math/IntegerVariable.java b/src/misc/src/jscl/math/IntegerVariable.java
new file mode 100644
index 00000000..d562d02a
--- /dev/null
+++ b/src/misc/src/jscl/math/IntegerVariable.java
@@ -0,0 +1,57 @@
+package jscl.math;
+
+import jscl.mathml.MathML;
+
+class IntegerVariable extends GenericVariable {
+    IntegerVariable(Generic generic) {
+        super(generic);
+    }
+
+    public Generic substitute(Variable variable, Generic generic) {
+        if(isIdentity(variable)) return generic;
+        else return content.substitute(variable,generic);
+    }
+
+    public Generic elementary() {
+        return content.elementary();
+    }
+
+    public Generic simplify() {
+        return content.simplify();
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append("(").append(content).append(")");
+        return buffer.toString();
+    }
+
+    public String toJava() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append("(").append(content.toJava()).append(")");
+        return buffer.toString();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) bodyToMathML(element);
+        else {
+            MathML e1=element.element("msup");
+            bodyToMathML(e1);
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+
+    void bodyToMathML(MathML element) {
+        MathML e1=element.element("mfenced");
+        content.toMathML(e1,null);
+        element.appendChild(e1);
+    }
+
+    protected Variable newinstance() {
+        return new IntegerVariable(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/JSCLBoolean.java b/src/misc/src/jscl/math/JSCLBoolean.java
new file mode 100644
index 00000000..79fc2adc
--- /dev/null
+++ b/src/misc/src/jscl/math/JSCLBoolean.java
@@ -0,0 +1,16 @@
+package jscl.math;
+
+public class JSCLBoolean extends ModularInteger {
+    public static final JSCLBoolean factory=new JSCLBoolean(0);
+
+    public JSCLBoolean(long content) {
+        super(content,2);
+    }
+
+    protected ModularInteger newinstance(long content) {
+        return content%2==0?zero:one;
+    }
+
+    private static final JSCLBoolean zero=factory;
+    private static final JSCLBoolean one=new JSCLBoolean(1);
+}
diff --git a/src/misc/src/jscl/math/JSCLInteger.java b/src/misc/src/jscl/math/JSCLInteger.java
new file mode 100644
index 00000000..e65f4187
--- /dev/null
+++ b/src/misc/src/jscl/math/JSCLInteger.java
@@ -0,0 +1,330 @@
+package jscl.math;
+
+import java.math.BigInteger;
+import jscl.mathml.MathML;
+
+public final class JSCLInteger extends Generic {
+    public static final JSCLInteger factory=new JSCLInteger(BigInteger.valueOf(0));
+    final BigInteger content;
+
+    public JSCLInteger(BigInteger content) {
+        this.content=content;
+    }
+
+    public BigInteger content() {
+        return content;
+    }
+
+    public JSCLInteger add(JSCLInteger integer) {
+        return new JSCLInteger(content.add(integer.content));
+    }
+
+    public Generic add(Generic generic) {
+        if(generic instanceof JSCLInteger) {
+            return add((JSCLInteger)generic);
+        } else {
+            return generic.valueof(this).add(generic);
+        }
+    }
+
+    public JSCLInteger subtract(JSCLInteger integer) {
+        return new JSCLInteger(content.subtract(integer.content));
+    }
+
+    public Generic subtract(Generic generic) {
+        if(generic instanceof JSCLInteger) {
+            return subtract((JSCLInteger)generic);
+        } else {
+            return generic.valueof(this).subtract(generic);
+        }
+    }
+
+    public JSCLInteger multiply(JSCLInteger integer) {
+        return new JSCLInteger(content.multiply(integer.content));
+    }
+
+    public Generic multiply(Generic generic) {
+        if(generic instanceof JSCLInteger) {
+            return multiply((JSCLInteger)generic);
+        } else {
+            return generic.multiply(this);
+        }
+    }
+
+    public JSCLInteger divide(JSCLInteger integer) throws ArithmeticException {
+        JSCLInteger e[]=divideAndRemainder(integer);
+        if(e[1].signum()==0) return e[0];
+        else throw new NotDivisibleException();
+    }
+
+    public Generic divide(Generic generic) throws ArithmeticException {
+        if(generic instanceof JSCLInteger) {
+            return divide((JSCLInteger)generic);
+        } else {
+            return generic.valueof(this).divide(generic);
+        }
+    }
+
+    public JSCLInteger[] divideAndRemainder(JSCLInteger integer) throws ArithmeticException {
+        BigInteger b[]=content.divideAndRemainder(integer.content);
+        return new JSCLInteger[] {new JSCLInteger(b[0]),new JSCLInteger(b[1])};
+    }
+
+    public Generic[] divideAndRemainder(Generic generic) throws ArithmeticException {
+        if(generic instanceof JSCLInteger) {
+            return divideAndRemainder((JSCLInteger)generic);
+        } else {
+            return generic.valueof(this).divideAndRemainder(generic);
+        }
+    }
+
+    public JSCLInteger remainder(JSCLInteger integer) throws ArithmeticException {
+        return new JSCLInteger(content.remainder(integer.content));
+    }
+
+    public Generic remainder(Generic generic) throws ArithmeticException {
+        if(generic instanceof JSCLInteger) {
+            return remainder((JSCLInteger)generic);
+        } else {
+            return generic.valueof(this).remainder(generic);
+        }
+    }
+
+    public JSCLInteger gcd(JSCLInteger integer) {
+        return new JSCLInteger(content.gcd(integer.content));
+    }
+
+    public Generic gcd(Generic generic) {
+        if(generic instanceof JSCLInteger) {
+            return gcd((JSCLInteger)generic);
+        } else {
+            return generic.valueof(this).gcd(generic);
+        }
+    }
+
+    public Generic gcd() {
+        return new JSCLInteger(BigInteger.valueOf(signum()));
+    }
+
+    public Generic pow(int exponent) {
+        return new JSCLInteger(content.pow(exponent));
+    }
+
+    public Generic negate() {
+        return new JSCLInteger(content.negate());
+    }
+
+    public int signum() {
+        return content.signum();
+    }
+
+    public int degree() {
+        return 0;
+    }
+
+    public JSCLInteger mod(JSCLInteger integer) {
+        return new JSCLInteger(content.mod(integer.content));
+    }
+
+    public JSCLInteger modPow(JSCLInteger exponent, JSCLInteger integer) {
+        return new JSCLInteger(content.modPow(exponent.content,integer.content));
+    }
+
+    public JSCLInteger modInverse(JSCLInteger integer) {
+        return new JSCLInteger(content.modInverse(integer.content));
+    }
+
+    public JSCLInteger phi() {
+        if(signum()==0) return this;
+        Generic a=factorize();
+        Generic p[]=a.productValue();
+        Generic s=JSCLInteger.valueOf(1);
+        for(int i=0;i<p.length;i++) {
+            Power o=p[i].powerValue();
+            Generic q=o.value(true);
+            int c=o.exponent();
+            s=s.multiply(q.subtract(JSCLInteger.valueOf(1)).multiply(q.pow(c-1)));
+        }
+        return s.integerValue();
+    }
+
+    public JSCLInteger[] primitiveRoots() {
+        JSCLInteger phi=phi();
+        Generic a=phi.factorize();
+        Generic p[]=a.productValue();
+        JSCLInteger d[]=new JSCLInteger[p.length];
+        for(int i=0;i<p.length;i++) {
+            d[i]=phi.divide(p[i].powerValue().value(true).integerValue());
+        }
+        int k=0;
+        JSCLInteger n=this;
+        JSCLInteger m=JSCLInteger.valueOf(1);
+        JSCLInteger r[]=new JSCLInteger[phi.phi().intValue()];
+        while(m.compareTo(n)<0) {
+            boolean b=m.gcd(n).compareTo(JSCLInteger.valueOf(1))==0;
+            for(int i=0;i<d.length;i++) {
+                b=b && m.modPow(d[i],n).compareTo(JSCLInteger.valueOf(1))>0;
+            }
+            if(b) r[k++]=m;
+            m=m.add(JSCLInteger.valueOf(1));
+        }
+        return k>0?r:new JSCLInteger[0];
+    }
+
+    public JSCLInteger sqrt() {
+        return nthrt(2);
+    }
+
+    public JSCLInteger nthrt(int n) {
+//      return JSCLInteger.valueOf((int)Math.pow((double)intValue(),1./n));
+        if(signum()==0) return JSCLInteger.valueOf(0);
+        else if(signum()<0) {
+            if(n%2==0) throw new ArithmeticException();
+            else return (JSCLInteger)((JSCLInteger)negate()).nthrt(n).negate();
+        } else {
+            Generic x0;
+            Generic x=this;
+            do {
+                x0=x;
+                x=divideAndRemainder(x.pow(n-1))[0].add(x.multiply(JSCLInteger.valueOf(n-1))).divideAndRemainder(JSCLInteger.valueOf(n))[0];
+            } while(x.compareTo(x0)<0);
+            return x0.integerValue();
+        }
+    }
+
+    public Generic antiderivative(Variable variable) throws NotIntegrableException {
+        return multiply(variable.expressionValue());
+    }
+
+    public Generic derivative(Variable variable) {
+        return JSCLInteger.valueOf(0);
+    }
+
+    public Generic substitute(Variable variable, Generic generic) {
+        return this;
+    }
+
+    public Generic expand() {
+        return this;
+    }
+
+    public Generic factorize() {
+        return Factorization.compute(this);
+    }
+
+    public Generic elementary() {
+        return this;
+    }
+
+    public Generic simplify() {
+        return this;
+    }
+
+    public Generic numeric() {
+        return new NumericWrapper(this);
+    }
+
+    public Generic valueof(Generic generic) {
+        return new JSCLInteger(((JSCLInteger)generic).content);
+    }
+
+    public Generic[] sumValue() {
+        if(content.signum()==0) return new Generic[0];
+        else return new Generic[] {this};
+    }
+
+    public Generic[] productValue() throws NotProductException {
+        if(content.compareTo(BigInteger.valueOf(1))==0) return new Generic[0];
+        else return new Generic[] {this};
+    }
+
+    public Power powerValue() throws NotPowerException {
+        if(content.signum()<0) throw new NotPowerException();
+        else return new Power(this,1);
+    }
+
+    public Expression expressionValue() throws NotExpressionException {
+        return Expression.valueOf(this);
+    }
+
+    public JSCLInteger integerValue() throws NotIntegerException {
+        return this;
+    }
+
+    public Variable variableValue() throws NotVariableException {
+        throw new NotVariableException();
+    }
+
+    public Variable[] variables() {
+        return new Variable[0];
+    }
+
+    public boolean isPolynomial(Variable variable) {
+        return true;
+    }
+
+    public boolean isConstant(Variable variable) {
+        return true;
+    }
+
+    public int intValue() {
+        return content.intValue();
+    }
+
+    public int compareTo(JSCLInteger integer) {
+        return content.compareTo(integer.content);
+    }
+
+    public int compareTo(Generic generic) {
+        if(generic instanceof JSCLInteger) {
+            return compareTo((JSCLInteger)generic);
+        } else {
+            return generic.valueof(this).compareTo(generic);
+        }
+    }
+
+    private static final JSCLInteger ZERO=new JSCLInteger(BigInteger.valueOf(0));
+    private static final JSCLInteger ONE=new JSCLInteger(BigInteger.valueOf(1));
+
+    public static JSCLInteger valueOf(long val) {
+        switch((int)val) {
+        case 0:
+            return ZERO;
+        case 1:
+            return ONE;
+        default:
+            return new JSCLInteger(BigInteger.valueOf(val));
+        }
+    }
+
+    public static JSCLInteger valueOf(String str) {
+        return new JSCLInteger(new BigInteger(str));
+    }
+
+    public String toString() {
+        return content.toString();
+    }
+
+    public String toJava() {
+        return "JSCLDouble.valueOf("+content+")";
+    }
+
+    public void toMathML(MathML element, Object data) {
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) bodyToMathML(element);
+        else {
+            MathML e1=element.element("msup");
+            bodyToMathML(e1);
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+
+    void bodyToMathML(MathML element) {
+        MathML e1=element.element("mn");
+        e1.appendChild(element.text(String.valueOf(content)));
+        element.appendChild(e1);
+    }
+}
diff --git a/src/misc/src/jscl/math/JSCLVector.java b/src/misc/src/jscl/math/JSCLVector.java
new file mode 100644
index 00000000..6a1622b6
--- /dev/null
+++ b/src/misc/src/jscl/math/JSCLVector.java
@@ -0,0 +1,476 @@
+package jscl.math;
+
+import jscl.math.function.Conjugate;
+import jscl.math.function.Frac;
+import jscl.mathml.MathML;
+import jscl.util.ArrayComparator;
+
+public class JSCLVector extends Generic {
+    protected final Generic element[];
+    protected final int n;
+
+    public JSCLVector(Generic element[]) {
+        this.element=element;
+        n=element.length;
+    }
+
+    public Generic[] elements() {
+        return element;
+    }
+
+    public JSCLVector add(JSCLVector vector) {
+        JSCLVector v=(JSCLVector)newinstance();
+        for(int i=0;i<n;i++) v.element[i]=element[i].add(vector.element[i]);
+        return v;
+    }
+
+    public Generic add(Generic generic) {
+        if(generic instanceof JSCLVector) {
+            return add((JSCLVector)generic);
+        } else {
+            return add(valueof(generic));
+        }
+    }
+
+    public JSCLVector subtract(JSCLVector vector) {
+        JSCLVector v=(JSCLVector)newinstance();
+        for(int i=0;i<n;i++) v.element[i]=element[i].subtract(vector.element[i]);
+        return v;
+    }
+
+    public Generic subtract(Generic generic) {
+        if(generic instanceof JSCLVector) {
+            return subtract((JSCLVector)generic);
+        } else {
+            return subtract(valueof(generic));
+        }
+    }
+
+    public Generic multiply(Generic generic) {
+        if(generic instanceof JSCLVector) {
+            return scalarProduct((JSCLVector)generic);
+        } else if(generic instanceof Matrix) {
+            return ((Matrix)generic).transpose().multiply(this);
+        } else {
+            JSCLVector v=(JSCLVector)newinstance();
+            for(int i=0;i<n;i++) v.element[i]=element[i].multiply(generic);
+            return v;
+        }
+    }
+
+    public Generic divide(Generic generic) throws ArithmeticException {
+        if(generic instanceof JSCLVector) {
+            throw new ArithmeticException();
+        } else if(generic instanceof Matrix) {
+            return multiply(((Matrix)generic).inverse());
+        } else {
+            JSCLVector v=(JSCLVector)newinstance();
+            for(int i=0;i<n;i++) {
+                try {
+                    v.element[i]=element[i].divide(generic);
+                } catch (NotDivisibleException e) {
+                    v.element[i]=new Frac(element[i],generic).evaluate();
+                }
+            }
+            return v;
+        }
+    }
+
+    public Generic gcd(Generic generic) {
+        return null;
+    }
+
+    public Generic gcd() {
+        return null;
+    }
+
+    public Generic negate() {
+        JSCLVector v=(JSCLVector)newinstance();
+        for(int i=0;i<n;i++) v.element[i]=element[i].negate();
+        return v;
+    }
+
+    public int signum() {
+        for(int i=0;i<n;i++) {
+            int c=element[i].signum();
+            if(c<0) return -1;
+            else if(c>0) return 1;
+        }
+        return 0;
+    }
+
+    public int degree() {
+        return 0;
+    }
+
+    public Generic antiderivative(Variable variable) throws NotIntegrableException {
+        JSCLVector v=(JSCLVector)newinstance();
+        for(int i=0;i<n;i++) v.element[i]=element[i].antiderivative(variable);
+        return v;
+    }
+
+    public Generic derivative(Variable variable) {
+        JSCLVector v=(JSCLVector)newinstance();
+        for(int i=0;i<n;i++) v.element[i]=element[i].derivative(variable);
+        return v;
+    }
+
+    public Generic substitute(Variable variable, Generic generic) {
+        JSCLVector v=(JSCLVector)newinstance();
+        for(int i=0;i<n;i++) v.element[i]=element[i].substitute(variable,generic);
+        return v;
+    }
+
+    public Generic expand() {
+        JSCLVector v=(JSCLVector)newinstance();
+        for(int i=0;i<n;i++) v.element[i]=element[i].expand();
+        return v;
+    }
+
+    public Generic factorize() {
+        JSCLVector v=(JSCLVector)newinstance();
+        for(int i=0;i<n;i++) v.element[i]=element[i].factorize();
+        return v;
+    }
+
+    public Generic elementary() {
+        JSCLVector v=(JSCLVector)newinstance();
+        for(int i=0;i<n;i++) v.element[i]=element[i].elementary();
+        return v;
+    }
+
+    public Generic simplify() {
+        JSCLVector v=(JSCLVector)newinstance();
+        for(int i=0;i<n;i++) v.element[i]=element[i].simplify();
+        return v;
+    }
+
+    public Generic numeric() {
+        return new NumericWrapper(this);
+    }
+
+    public Generic valueof(Generic generic) {
+        if(generic instanceof JSCLVector ||  generic instanceof Matrix) {
+            throw new ArithmeticException();
+        } else {
+            JSCLVector v=(JSCLVector)unity(n).multiply(generic);
+            return newinstance(v.element);
+        }
+    }
+
+    public Generic[] sumValue() {
+        return new Generic[] {this};
+    }
+
+    public Generic[] productValue() throws NotProductException {
+        return new Generic[] {this};
+    }
+
+    public Power powerValue() throws NotPowerException {
+        return new Power(this,1);
+    }
+
+    public Expression expressionValue() throws NotExpressionException {
+        throw new NotExpressionException();
+    }
+
+    public JSCLInteger integerValue() throws NotIntegerException {
+        throw new NotIntegerException();
+    }
+
+    public Variable variableValue() throws NotVariableException {
+        throw new NotVariableException();
+    }
+
+    public Variable[] variables() {
+        return null;
+    }
+
+    public boolean isPolynomial(Variable variable) {
+        return false;
+    }
+
+    public boolean isConstant(Variable variable) {
+        return false;
+    }
+
+    public Generic magnitude2() {
+        return scalarProduct(this);
+    }
+
+    public Generic scalarProduct(JSCLVector vector) {
+        Generic a=JSCLInteger.valueOf(0);
+        for(int i=0;i<n;i++) {
+            a=a.add(element[i].multiply(vector.element[i]));
+        }
+        return a;
+    }
+
+    public JSCLVector vectorProduct(JSCLVector vector) {
+        JSCLVector v=(JSCLVector)newinstance();
+        Generic m[][]={
+            {JSCLInteger.valueOf(0),element[2].negate(),element[1]},
+            {element[2],JSCLInteger.valueOf(0),element[0].negate()},
+            {element[1].negate(),element[0],JSCLInteger.valueOf(0)}
+        };
+        JSCLVector v2=(JSCLVector)new Matrix(m).multiply(vector);
+        for(int i=0;i<n;i++) v.element[i]=i<v2.n?v2.element[i]:JSCLInteger.valueOf(0);
+        return v;
+    }
+
+    public JSCLVector complexProduct(JSCLVector vector) {
+        return product(new Clifford(0,1).operator(),vector);
+    }
+
+    public JSCLVector quaternionProduct(JSCLVector vector) {
+        return product(new Clifford(0,2).operator(),vector);
+    }
+
+    public JSCLVector geometricProduct(JSCLVector vector, int algebra[]) {
+        return product(new Clifford(algebra==null?new int[] {Clifford.log2e(n),0}:algebra).operator(),vector);
+    }
+
+    JSCLVector product(int product[][], JSCLVector vector) {
+        JSCLVector v=(JSCLVector)newinstance();
+        for(int i=0;i<n;i++) v.element[i]=JSCLInteger.valueOf(0);
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<n;j++) {
+                Generic a=element[i].multiply(vector.element[j]);
+                int k=Math.abs(product[i][j])-1;
+                v.element[k]=v.element[k].add(product[i][j]<0?a.negate():a);
+            }
+        }
+        return v;
+    }
+
+    public Generic divergence(Variable variable[]) {
+        Generic a=JSCLInteger.valueOf(0);
+        for(int i=0;i<n;i++) a=a.add(element[i].derivative(variable[i]));
+        return a;
+    }
+
+    public JSCLVector curl(Variable variable[]) {
+        JSCLVector v=(JSCLVector)newinstance();
+        v.element[0]=element[2].derivative(variable[1]).subtract(element[1].derivative(variable[2]));
+        v.element[1]=element[0].derivative(variable[2]).subtract(element[2].derivative(variable[0]));
+        v.element[2]=element[1].derivative(variable[0]).subtract(element[0].derivative(variable[1]));
+        for(int i=3;i<n;i++) v.element[i]=element[i];
+        return v;
+    }
+
+    public Matrix jacobian(Variable variable[]) {
+        Matrix m=new Matrix(new Generic[n][variable.length]);
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<variable.length;j++) {
+                m.element[i][j]=element[i].derivative(variable[j]);
+            }
+        }
+        return m;
+    }
+
+    public Generic del(Variable variable[], int algebra[]) {
+        return differential(new Clifford(algebra==null?new int[] {Clifford.log2e(n),0}:algebra).operator(),variable);
+    }
+
+    JSCLVector differential(int product[][], Variable variable[]) {
+        JSCLVector v=(JSCLVector)newinstance();
+        for(int i=0;i<n;i++) v.element[i]=JSCLInteger.valueOf(0);
+        int l=Clifford.log2e(n);
+        for(int i=1;i<=l;i++) {
+            for(int j=0;j<n;j++) {
+                Generic a=element[j].derivative(variable[i-1]);
+                int k=Math.abs(product[i][j])-1;
+                v.element[k]=v.element[k].add(product[i][j]<0?a.negate():a);
+            }
+        }
+        return v;
+    }
+
+    public Generic conjugate() {
+        JSCLVector v=(JSCLVector)newinstance();
+        for(int i=0;i<n;i++) {
+            v.element[i]=new Conjugate(element[i]).evaluate();
+        }
+        return v;
+    }
+
+    public int compareTo(JSCLVector vector) {
+        return ArrayComparator.comparator.compare(element,vector.element);
+    }
+
+    public int compareTo(Generic generic) {
+        if(generic instanceof JSCLVector) {
+            return compareTo((JSCLVector)generic);
+        } else {
+            return compareTo(valueof(generic));
+        }
+    }
+
+    public static JSCLVector unity(int dimension) {
+        JSCLVector v=new JSCLVector(new Generic[dimension]);
+        for(int i=0;i<v.n;i++) {
+            if(i==0) v.element[i]=JSCLInteger.valueOf(1);
+            else v.element[i]=JSCLInteger.valueOf(0);
+        }
+        return v;
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append("{");
+        for(int i=0;i<n;i++) {
+            buffer.append(element[i]).append(i<n-1?", ":"");
+        }
+        buffer.append("}");
+        return buffer.toString();
+    }
+
+    public String toJava() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append("new NumericVector(new Numeric[] {");
+        for(int i=0;i<n;i++) {
+            buffer.append(element[i].toJava()).append(i<n-1?", ":"");
+        }
+        buffer.append("})");
+        return buffer.toString();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) bodyToMathML(element);
+        else {
+            MathML e1=element.element("msup");
+            bodyToMathML(e1);
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+
+    protected void bodyToMathML(MathML e0) {
+        MathML e1=e0.element("mfenced");
+        MathML e2=e0.element("mtable");
+        for(int i=0;i<n;i++) {
+            MathML e3=e0.element("mtr");
+            MathML e4=e0.element("mtd");
+            element[i].toMathML(e4,null);
+            e3.appendChild(e4);
+            e2.appendChild(e3);
+        }
+        e1.appendChild(e2);
+        e0.appendChild(e1);
+    }
+
+    protected Generic newinstance() {
+        return newinstance(new Generic[n]);
+    }
+
+    protected Generic newinstance(Generic element[]) {
+        return new JSCLVector(element);
+    }
+}
+
+class Clifford {
+    int p,n;
+    int operator[][];
+
+    Clifford(int algebra[]) {
+        this(algebra[0],algebra[1]);
+    }
+
+    Clifford(int p, int q) {
+        this.p=p;
+        n=p+q;
+        int m=1<<n;
+        operator=new int[m][m];
+        for(int i=0;i<m;i++) {
+            for(int j=0;j<m;j++) {
+                int a=combination(i,n);
+                int b=combination(j,n);
+                int c=a^b;
+                int l=location(c,n);
+                boolean s=sign(a,b);
+                int k=l+1;
+                operator[i][j]=s?-k:k;
+            }
+        }
+    }
+
+    boolean sign(int a, int b) {
+        boolean s=false;
+        for(int i=0;i<n;i++) {
+            if((b&(1<<i))>0) {
+                for(int j=i;j<n;j++) {
+                    if((a&(1<<j))>0 && (j>i || i>=p)) s=!s;
+                }
+            }
+        }
+        return s;
+    }
+
+    static int combination(int l, int n) {
+        if(n<=2) return l;
+        int b[]=new int[1];
+        int l1=decimation(l,n,b);
+        int c=combination(l1,n-1);
+        return (c<<1)+b[0];
+    }
+
+    static int location(int c, int n) {
+        if(n<=2) return c;
+        int c1=c>>1;
+        int b=c&1;
+        int l1=location(c1,n-1);
+        return dilatation(l1,n,new int[] {b});
+    }
+
+    static int decimation(int l, int n, int b[]) {
+        int p=grade(l,n-1,1);
+        int p1=(p+1)>>1;
+        b[0]=p&1;
+        return l-sum(p1,n-1);
+    }
+
+    static int dilatation(int l, int n, int b[]) {
+        int p1=grade(l,n-1);
+        return l+sum(p1+b[0],n-1);
+    }
+
+    static int grade(int l, int n) {
+        return grade(l,n,0);
+    }
+
+    static int grade(int l, int n, int d) {
+        int s=0, p=0;
+        while(true) {
+            s+=binomial(n,p>>d);
+            if(s<=l) p++;
+            else break;
+        }
+        return p;
+    }
+
+    static int sum(int p, int n) {
+        int q=0, s=0;
+        while(q<p) s+=binomial(n,q++);
+        return s;
+    }
+
+    static int binomial(int n, int p) {
+        int a=1, b=1;
+        for(int i=n-p+1;i<=n;i++) a*=i;
+        for(int i=2;i<=p;i++) b*=i;
+        return a/b;
+    }
+
+    static int log2e(int n) {
+        int i;
+        for(i=0;n>1;n>>=1) i++;
+        return i;
+    }
+
+    int[][] operator() {
+        return operator;
+    }
+}
diff --git a/src/misc/src/jscl/math/Literal.java b/src/misc/src/jscl/math/Literal.java
new file mode 100644
index 00000000..d4c4c8d2
--- /dev/null
+++ b/src/misc/src/jscl/math/Literal.java
@@ -0,0 +1,368 @@
+package jscl.math;
+
+import java.util.Iterator;
+import java.util.Map;
+import java.util.TreeMap;
+import jscl.math.function.Frac;
+import jscl.math.function.Pow;
+import jscl.math.polynomial.Monomial;
+import jscl.mathml.MathML;
+
+public class Literal implements Comparable {
+    Variable variable[];
+    int power[];
+    int degree;
+    int size;
+
+    Literal() {}
+
+    Literal(int size) {
+        init(size);
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public Variable variable(int n) {
+        return variable[n];
+    }
+
+    public int power(int n) {
+        return power[n];
+    }
+
+    void init(int size) {
+        variable=new Variable[size];
+        power=new int[size];
+        this.size=size;
+    }
+
+    void resize(int size) {
+        if(size<variable.length) {
+            Variable variable[]=new Variable[size];
+            int power[]=new int[size];
+            System.arraycopy(this.variable,0,variable,0,size);
+            System.arraycopy(this.power,0,power,0,size);
+            this.variable=variable;
+            this.power=power;
+            this.size=size;
+        }
+    }
+
+    public Literal multiply(Literal literal) {
+        Literal l=newinstance(size+literal.size);
+        int i=0;
+        int i1=0;
+        int i2=0;
+        Variable v1=i1<size?variable[i1]:null;
+        Variable v2=i2<literal.size?literal.variable[i2]:null;
+        while(v1!=null || v2!=null) {
+            int c=v1==null?1:(v2==null?-1:v1.compareTo(v2));
+            if(c<0) {
+                int s=power[i1];
+                l.variable[i]=v1;
+                l.power[i]=s;
+                l.degree+=s;
+                i++;
+                i1++;
+                v1=i1<size?variable[i1]:null;
+            } else if(c>0) {
+                int s=literal.power[i2];
+                l.variable[i]=v2;
+                l.power[i]=s;
+                l.degree+=s;
+                i++;
+                i2++;
+                v2=i2<literal.size?literal.variable[i2]:null;
+            } else {
+                int s=power[i1]+literal.power[i2];
+                l.variable[i]=v1;
+                l.power[i]=s;
+                l.degree+=s;
+                i++;
+                i1++;
+                i2++;
+                v1=i1<size?variable[i1]:null;
+                v2=i2<literal.size?literal.variable[i2]:null;
+            }
+        }
+        l.resize(i);
+        return l;
+    }
+
+    public Literal divide(Literal literal) throws ArithmeticException {
+        Literal l=newinstance(size+literal.size);
+        int i=0;
+        int i1=0;
+        int i2=0;
+        Variable v1=i1<size?variable[i1]:null;
+        Variable v2=i2<literal.size?literal.variable[i2]:null;
+        while(v1!=null || v2!=null) {
+            int c=v1==null?1:(v2==null?-1:v1.compareTo(v2));
+            if(c<0) {
+                int s=power[i1];
+                l.variable[i]=v1;
+                l.power[i]=s;
+                l.degree+=s;
+                i++;
+                i1++;
+                v1=i1<size?variable[i1]:null;
+            } else if(c>0) {
+                throw new NotDivisibleException();
+            } else {
+                int s=power[i1]-literal.power[i2];
+                if(s<0) throw new NotDivisibleException();
+                else if(s==0);
+                else {
+                    l.variable[i]=v1;
+                    l.power[i]=s;
+                    l.degree+=s;
+                    i++;
+                }
+                i1++;
+                i2++;
+                v1=i1<size?variable[i1]:null;
+                v2=i2<literal.size?literal.variable[i2]:null;
+            }
+        }
+        l.resize(i);
+        return l;
+    }
+
+    public Literal gcd(Literal literal) {
+        Literal l=newinstance(Math.min(size,literal.size));
+        int i=0;
+        int i1=0;
+        int i2=0;
+        Variable v1=i1<size?variable[i1]:null;
+        Variable v2=i2<literal.size?literal.variable[i2]:null;
+        while(v1!=null || v2!=null) {
+            int c=v1==null?1:(v2==null?-1:v1.compareTo(v2));
+            if(c<0) {
+                i1++;
+                v1=i1<size?variable[i1]:null;
+            } else if(c>0) {
+                i2++;
+                v2=i2<literal.size?literal.variable[i2]:null;
+            } else {
+                int s=Math.min(power[i1],literal.power[i2]);
+                l.variable[i]=v1;
+                l.power[i]=s;
+                l.degree+=s;
+                i++;
+                i1++;
+                i2++;
+                v1=i1<size?variable[i1]:null;
+                v2=i2<literal.size?literal.variable[i2]:null;
+            }
+        }
+        l.resize(i);
+        return l;
+    }
+
+    public Literal scm(Literal literal) {
+        Literal l=newinstance(size+literal.size);
+        int i=0;
+        int i1=0;
+        int i2=0;
+        Variable v1=i1<size?variable[i1]:null;
+        Variable v2=i2<literal.size?literal.variable[i2]:null;
+        while(v1!=null || v2!=null) {
+            int c=v1==null?1:(v2==null?-1:v1.compareTo(v2));
+            if(c<0) {
+                int s=power[i1];
+                l.variable[i]=v1;
+                l.power[i]=s;
+                l.degree+=s;
+                i++;
+                i1++;
+                v1=i1<size?variable[i1]:null;
+            } else if(c>0) {
+                int s=literal.power[i2];
+                l.variable[i]=v2;
+                l.power[i]=s;
+                l.degree+=s;
+                i++;
+                i2++;
+                v2=i2<literal.size?literal.variable[i2]:null;
+            } else {
+                int s=Math.max(power[i1],literal.power[i2]);
+                l.variable[i]=v1;
+                l.power[i]=s;
+                l.degree+=s;
+                i++;
+                i1++;
+                i2++;
+                v1=i1<size?variable[i1]:null;
+                v2=i2<literal.size?literal.variable[i2]:null;
+            }
+        }
+        l.resize(i);
+        return l;
+    }
+
+    public Generic[] productValue() throws NotProductException {
+        Generic a[]=new Generic[size];
+        for(int i=0;i<a.length;i++) a[i]=variable[i].expressionValue().pow(power[i]);
+        return a;
+    }
+
+    public Power powerValue() throws NotPowerException {
+        if(size==0) return new Power(JSCLInteger.valueOf(1),1);
+        else if(size==1) {
+            Variable v=variable[0];
+            int c=power[0];
+            return new Power(v.expressionValue(),c);
+        } else throw new NotPowerException();
+    }
+
+    public Variable variableValue() throws NotVariableException {
+        if(size==0) throw new NotVariableException();
+        else if(size==1) {
+            Variable v=variable[0];
+            int c=power[0];
+            if(c==1) return v;
+            else throw new NotVariableException();
+        } else throw new NotVariableException();
+    }
+
+    public Variable[] variables() {
+        Variable va[]=new Variable[size];
+        System.arraycopy(variable,0,va,0,size);
+        return va;
+    }
+
+    public int degree() {
+        return degree;
+    }
+
+    public int compareTo(Literal literal) {
+        int i1=size;
+        int i2=literal.size;
+        Variable v1=i1==0?null:variable[--i1];
+        Variable v2=i2==0?null:literal.variable[--i2];
+        while(v1!=null || v2!=null) {
+            int c=v1==null?-1:(v2==null?1:v1.compareTo(v2));
+            if(c<0) return -1;
+            else if(c>0) return 1;
+            else {
+                int c1=power[i1];
+                int c2=literal.power[i2];
+                if(c1<c2) return -1;
+                else if(c1>c2) return 1;
+                v1=i1==0?null:variable[--i1];
+                v2=i2==0?null:literal.variable[--i2];
+            }
+        }
+        return 0;
+    }
+
+    public int compareTo(Object o) {
+        return compareTo((Literal)o);
+    }
+
+    public static Literal valueOf() {
+        return new Literal(0);
+    }
+
+    public static Literal valueOf(Variable variable) {
+        return valueOf(variable,1);
+    }
+
+    public static Literal valueOf(Variable variable, int power) {
+        Literal l=new Literal();
+        l.init(variable,power);
+        return l;
+    }
+
+    void init(Variable var, int pow) {
+        if(pow!=0) {
+            init(1);
+            variable[0]=var;
+            power[0]=pow;
+            degree=pow;
+        } else init(0);
+    }
+
+    public static Literal valueOf(Monomial monomial) {
+        Literal l=new Literal();
+        l.init(monomial);
+        return l;
+    }
+
+    void init(Monomial monomial) {
+        Map map=new TreeMap();
+        Variable unk[]=monomial.unknown();
+        for(int i=0;i<unk.length;i++) {
+            int c=monomial.element(i);
+            if(c>0) map.put(unk[i],new Integer(c));
+        }
+        init(map.size());
+        Iterator it=map.entrySet().iterator();
+        for(int i=0;it.hasNext();i++) {
+            Map.Entry e=(Map.Entry)it.next();
+            Variable v=(Variable)e.getKey();
+            int c=((Integer)e.getValue()).intValue();
+            variable[i]=v;
+            power[i]=c;
+            degree+=c;
+        }
+    }
+
+    Map content() {
+        Map map=new TreeMap();
+        for(int i=0;i<size;i++) map.put(variable[i],new Integer(power[i]));
+        return map;
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        if(degree==0) buffer.append("1");
+        for(int i=0;i<size;i++) {
+            if(i>0) buffer.append("*");
+            Variable v=variable[i];
+            int c=power[i];
+            if(c==1) buffer.append(v);
+            else {
+                if(v instanceof Frac || v instanceof Pow) {
+                    buffer.append("(").append(v).append(")");
+                } else buffer.append(v);
+                buffer.append("^").append(c);
+            }
+        }
+        return buffer.toString();
+    }
+
+    public String toJava() {
+        StringBuffer buffer=new StringBuffer();
+        if(degree==0) buffer.append("JSCLDouble.valueOf(1)");
+        for(int i=0;i<size;i++) {
+            if(i>0) buffer.append(".multiply(");
+            Variable v=variable[i];
+            int c=power[i];
+            buffer.append(v.toJava());
+            if(c==1);
+            else buffer.append(".pow(").append(c).append(")");
+            if(i>0) buffer.append(")");
+        }
+        return buffer.toString();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        if(degree==0) {
+            MathML e1=element.element("mn");
+            e1.appendChild(element.text("1"));
+            element.appendChild(e1);
+        }
+        for(int i=0;i<size;i++) {
+            Variable v=variable[i];
+            int c=power[i];
+            v.toMathML(element,new Integer(c));
+        }
+    }
+
+    protected Literal newinstance(int n) {
+        return new Literal(n);
+    }
+}
diff --git a/src/misc/src/jscl/math/Matrix.java b/src/misc/src/jscl/math/Matrix.java
new file mode 100644
index 00000000..89c1c755
--- /dev/null
+++ b/src/misc/src/jscl/math/Matrix.java
@@ -0,0 +1,497 @@
+package jscl.math;
+
+import jscl.math.function.Conjugate;
+import jscl.math.function.Frac;
+import jscl.math.function.trigonometric.Cos;
+import jscl.math.function.trigonometric.Sin;
+import jscl.mathml.MathML;
+import jscl.util.ArrayComparator;
+
+public class Matrix extends Generic {
+    protected final Generic element[][];
+    protected final int n,p;
+
+    public Matrix(Generic element[][]) {
+        this.element=element;
+        n=element.length;
+        p=element.length>0?element[0].length:0;
+    }
+
+    public Generic[][] elements() {
+        return element;
+    }
+
+    public Matrix add(Matrix matrix) {
+        Matrix m=(Matrix)newinstance();
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<p;j++) {
+                m.element[i][j]=element[i][j].add(matrix.element[i][j]);
+            }
+        }
+        return m;
+    }
+
+    public Generic add(Generic generic) {
+        if(generic instanceof Matrix) {
+            return add((Matrix)generic);
+        } else {
+            return add(valueof(generic));
+        }
+    }
+
+    public Matrix subtract(Matrix matrix) {
+        Matrix m=(Matrix)newinstance();
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<p;j++) {
+                m.element[i][j]=element[i][j].subtract(matrix.element[i][j]);
+            }
+        }
+        return m;
+    }
+
+    public Generic subtract(Generic generic) {
+        if(generic instanceof Matrix) {
+            return subtract((Matrix)generic);
+        } else {
+            return subtract(valueof(generic));
+        }
+    }
+
+    public static boolean product(Generic a, Generic b) {
+        return (a instanceof Matrix && b instanceof Matrix) || (a instanceof Matrix && b instanceof JSCLVector) || (a instanceof JSCLVector && b instanceof Matrix);
+    }
+
+    public Matrix multiply(Matrix matrix) {
+        if(p!=matrix.n) throw new ArithmeticException();
+        Matrix m=(Matrix)newinstance(new Generic[n][matrix.p]);
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<matrix.p;j++) {
+                m.element[i][j]=JSCLInteger.valueOf(0);
+                for(int k=0;k<p;k++) {
+                    m.element[i][j]=m.element[i][j].add(element[i][k].multiply(matrix.element[k][j]));
+                }
+            }
+        }
+        return m;
+    }
+
+    public Generic multiply(Generic generic) {
+        if(generic instanceof Matrix) {
+            return multiply((Matrix)generic);
+        } else if(generic instanceof JSCLVector) {
+            JSCLVector v=(JSCLVector)((JSCLVector)generic).newinstance(new Generic[n]);
+            JSCLVector v2=(JSCLVector)generic;
+            if(p!=v2.n) throw new ArithmeticException();
+            for(int i=0;i<n;i++) {
+                v.element[i]=JSCLInteger.valueOf(0);
+                for(int k=0;k<p;k++) {
+                    v.element[i]=v.element[i].add(element[i][k].multiply(v2.element[k]));
+                }
+            }
+            return v;
+        } else {
+            Matrix m=(Matrix)newinstance();
+            for(int i=0;i<n;i++) {
+                for(int j=0;j<p;j++) {
+                    m.element[i][j]=element[i][j].multiply(generic);
+                }
+            }
+            return m;
+        }
+    }
+
+    public Generic divide(Generic generic) throws ArithmeticException {
+        if(generic instanceof Matrix) {
+            return multiply(((Matrix)generic).inverse());
+        } else if(generic instanceof JSCLVector) {
+            throw new ArithmeticException();
+        } else {
+            Matrix m=(Matrix)newinstance();
+            for(int i=0;i<n;i++) {
+                for(int j=0;j<p;j++) {
+                    try {
+                        m.element[i][j]=element[i][j].divide(generic);
+                    } catch (NotDivisibleException e) {
+                        m.element[i][j]=new Frac(element[i][j],generic).evaluate();
+                    }
+                }
+            }
+            return m;
+        }
+    }
+
+    public Generic gcd(Generic generic) {
+        return null;
+    }
+
+    public Generic gcd() {
+        return null;
+    }
+
+    public Generic negate() {
+        Matrix m=(Matrix)newinstance();
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<p;j++) {
+                m.element[i][j]=element[i][j].negate();
+            }
+        }
+        return m;
+    }
+
+    public int signum() {
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<p;j++) {
+                int c=element[i][j].signum();
+                if(c<0) return -1;
+                else if(c>0) return 1;
+            }
+        }
+        return 0;
+    }
+
+    public int degree() {
+        return 0;
+    }
+
+    public Generic antiderivative(Variable variable) throws NotIntegrableException {
+        Matrix m=(Matrix)newinstance();
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<p;j++) {
+                m.element[i][j]=element[i][j].antiderivative(variable);
+            }
+        }
+        return m;
+    }
+
+    public Generic derivative(Variable variable) {
+        Matrix m=(Matrix)newinstance();
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<p;j++) {
+                m.element[i][j]=element[i][j].derivative(variable);
+            }
+        }
+        return m;
+    }
+
+    public Generic substitute(Variable variable, Generic generic) {
+        Matrix m=(Matrix)newinstance();
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<p;j++) {
+                m.element[i][j]=element[i][j].substitute(variable,generic);
+            }
+        }
+        return m;
+    }
+
+    public Generic expand() {
+        Matrix m=(Matrix)newinstance();
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<p;j++) {
+                m.element[i][j]=element[i][j].expand();
+            }
+        }
+        return m;
+    }
+
+    public Generic factorize() {
+        Matrix m=(Matrix)newinstance();
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<p;j++) {
+                m.element[i][j]=element[i][j].factorize();
+            }
+        }
+        return m;
+    }
+
+    public Generic elementary() {
+        Matrix m=(Matrix)newinstance();
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<p;j++) {
+                m.element[i][j]=element[i][j].elementary();
+            }
+        }
+        return m;
+    }
+
+    public Generic simplify() {
+        Matrix m=(Matrix)newinstance();
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<p;j++) {
+                m.element[i][j]=element[i][j].simplify();
+            }
+        }
+        return m;
+    }
+
+    public Generic numeric() {
+        return new NumericWrapper(this);
+    }
+
+    public Generic valueof(Generic generic) {
+        if(generic instanceof Matrix || generic instanceof JSCLVector) {
+            throw new ArithmeticException();
+        } else {
+            Matrix m=(Matrix)identity(n,p).multiply(generic);
+                        return newinstance(m.element);
+        }
+    }
+
+    public Generic[] sumValue() {
+        return new Generic[] {this};
+    }
+
+    public Generic[] productValue() throws NotProductException {
+        return new Generic[] {this};
+    }
+
+    public Power powerValue() throws NotPowerException {
+        return new Power(this,1);
+    }
+
+    public Expression expressionValue() throws NotExpressionException {
+        throw new NotExpressionException();
+    }
+
+    public JSCLInteger integerValue() throws NotIntegerException {
+        throw new NotIntegerException();
+    }
+
+    public Variable variableValue() throws NotVariableException {
+        throw new NotVariableException();
+    }
+
+    public Variable[] variables() {
+        return null;
+    }
+
+    public boolean isPolynomial(Variable variable) {
+        return false;
+    }
+
+    public boolean isConstant(Variable variable) {
+        return false;
+    }
+
+    public Generic[] vectors() {
+        JSCLVector v[]=new JSCLVector[n];
+        for(int i=0;i<n;i++) {
+            v[i]=new JSCLVector(new Generic[p]);
+            for(int j=0;j<p;j++) {
+                v[i].element[j]=element[i][j];
+            }
+        }
+        return v;
+    }
+
+    public Generic tensorProduct(Matrix matrix) {
+        Matrix m=(Matrix)newinstance(new Generic[n*matrix.n][p*matrix.p]);
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<p;j++) {
+                for(int k=0;k<matrix.n;k++) {
+                    for(int l=0;l<matrix.p;l++) {
+                        m.element[i*matrix.n+k][j*matrix.p+l]=element[i][j].multiply(matrix.element[k][l]);
+                    }
+                }
+            }
+        }
+        return m;
+    }
+
+    public Generic transpose() {
+        Matrix m=(Matrix)newinstance(new Generic[p][n]);
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<p;j++) {
+                m.element[j][i]=element[i][j];
+            }
+        }
+        return m;
+    }
+
+    public Generic trace() {
+        Generic s=JSCLInteger.valueOf(0);
+        for(int i=0;i<n;i++) {
+            s=s.add(element[i][i]);
+        }
+        return s;
+    }
+
+    public Generic inverse() {
+        Matrix m=(Matrix)newinstance();
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<n;j++) {
+                m.element[i][j]=inverseElement(i,j);
+            }
+        }
+        return m.transpose().divide(determinant());
+    }
+
+    Generic inverseElement(int k, int l) {
+        Matrix m=(Matrix)newinstance();
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<n;j++) {
+                m.element[i][j]=i==k?JSCLInteger.valueOf(j==l?1:0):element[i][j];
+            }
+        }
+        return m.determinant();
+    }
+
+    public Generic determinant() {
+        if(n>1) {
+            Generic a=JSCLInteger.valueOf(0);
+            for(int i=0;i<n;i++) {
+                if(element[i][0].signum()==0);
+                else {
+                    Matrix m=(Matrix)newinstance(new Generic[n-1][n-1]);
+                    for(int j=0;j<n-1;j++) {
+                        for(int k=0;k<n-1;k++) m.element[j][k]=element[j<i?j:j+1][k+1];
+                    }
+                    if(i%2==0) a=a.add(element[i][0].multiply(m.determinant()));
+                    else a=a.subtract(element[i][0].multiply(m.determinant()));
+                }
+            }
+            return a;
+        } else if(n>0) return element[0][0];
+        else return JSCLInteger.valueOf(0);
+    }
+
+    public Generic conjugate() {
+        Matrix m=(Matrix)newinstance();
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<p;j++) {
+                m.element[i][j]=new Conjugate(element[i][j]).evaluate();
+            }
+        }
+        return m;
+    }
+
+    public int compareTo(Matrix matrix) {
+        return ArrayComparator.comparator.compare(vectors(),matrix.vectors());
+    }
+
+    public int compareTo(Generic generic) {
+        if(generic instanceof Matrix) {
+            return compareTo((Matrix)generic);
+        } else {
+            return compareTo(valueof(generic));
+        }
+    }
+
+    public static Matrix identity(int dimension) {
+            return identity(dimension,dimension);
+    }
+
+    public static Matrix identity(int n, int p) {
+        Matrix m=new Matrix(new Generic[n][p]);
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<p;j++) {
+                if(i==j) {
+                    m.element[i][j]=JSCLInteger.valueOf(1);
+                } else {
+                    m.element[i][j]=JSCLInteger.valueOf(0);
+                }
+            }
+        }
+        return m;
+    }
+
+    public static Matrix frame(JSCLVector vector[]) {
+        Matrix m=new Matrix(new Generic[vector.length>0?vector[0].n:0][vector.length]);
+        for(int i=0;i<m.n;i++) {
+            for(int j=0;j<m.p;j++) {
+                m.element[i][j]=vector[j].element[i];
+            }
+        }
+        return m;
+    }
+
+    public static Matrix rotation(int dimension, int plane, Generic angle) {
+        return rotation(dimension,plane,2,angle);
+    }
+
+    public static Matrix rotation(int dimension, int axis1, int axis2, Generic angle) {
+        Matrix m=new Matrix(new Generic[dimension][dimension]);
+        for(int i=0;i<m.n;i++) {
+            for(int j=0;j<m.p;j++) {
+                if(i==axis1 && j==axis1) {
+                    m.element[i][j]=new Cos(angle).evaluate();
+                } else if(i==axis1 && j==axis2) {
+                    m.element[i][j]=new Sin(angle).evaluate().negate();
+                } else if(i==axis2 && j==axis1) {
+                    m.element[i][j]=new Sin(angle).evaluate();
+                } else if(i==axis2 && j==axis2) {
+                    m.element[i][j]=new Cos(angle).evaluate();
+                } else if(i==j) {
+                    m.element[i][j]=JSCLInteger.valueOf(1);
+                } else {
+                    m.element[i][j]=JSCLInteger.valueOf(0);
+                }
+            }
+        }
+        return m;
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append("{");
+        for(int i=0;i<n;i++) {
+            buffer.append("{");
+            for(int j=0;j<p;j++) {
+                buffer.append(element[i][j]).append(j<p-1?", ":"");
+            }
+            buffer.append("}").append(i<n-1?",\n":"");
+        }
+        buffer.append("}");
+        return buffer.toString();
+    }
+
+    public String toJava() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append("new NumericMatrix(new Numeric[][] {");
+        for(int i=0;i<n;i++) {
+            buffer.append("{");
+            for(int j=0;j<p;j++) {
+                buffer.append(element[i][j].toJava()).append(j<p-1?", ":"");
+            }
+            buffer.append("}").append(i<n-1?", ":"");
+        }
+        buffer.append("})");
+        return buffer.toString();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) bodyToMathML(element);
+        else {
+            MathML e1=element.element("msup");
+            bodyToMathML(e1);
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+
+    protected void bodyToMathML(MathML e0) {
+        MathML e1=e0.element("mfenced");
+        MathML e2=e0.element("mtable");
+        for(int i=0;i<n;i++) {
+            MathML e3=e0.element("mtr");
+            for(int j=0;j<p;j++) {
+                MathML e4=e0.element("mtd");
+                element[i][j].toMathML(e4,null);
+                e3.appendChild(e4);
+            }
+            e2.appendChild(e3);
+        }
+        e1.appendChild(e2);
+        e0.appendChild(e1);
+    }
+
+    protected Generic newinstance() {
+        return newinstance(new Generic[n][p]);
+    }
+
+    protected Generic newinstance(Generic element[][]) {
+        return new Matrix(element);
+    }
+}
diff --git a/src/misc/src/jscl/math/MatrixVariable.java b/src/misc/src/jscl/math/MatrixVariable.java
new file mode 100644
index 00000000..0171714b
--- /dev/null
+++ b/src/misc/src/jscl/math/MatrixVariable.java
@@ -0,0 +1,11 @@
+package jscl.math;
+
+public class MatrixVariable extends GenericVariable {
+        public MatrixVariable(Generic generic) {
+                super(generic);
+        }
+
+        protected Variable newinstance() {
+                return new MatrixVariable(null);
+        }
+}
diff --git a/src/misc/src/jscl/math/ModularInteger.java b/src/misc/src/jscl/math/ModularInteger.java
new file mode 100644
index 00000000..a9218acd
--- /dev/null
+++ b/src/misc/src/jscl/math/ModularInteger.java
@@ -0,0 +1,189 @@
+package jscl.math;
+
+import java.math.BigInteger;
+import jscl.mathml.MathML;
+
+public class ModularInteger extends Generic implements Field {
+    public static final ModularInteger booleanFactory=new ModularInteger(0,2);
+    final int modulo;
+    final int content;
+
+    public ModularInteger(long content, int modulo) {
+        this.modulo=modulo;
+        this.content=(int)(content%modulo);
+    }
+
+    public int content() {
+        return content;
+    }
+
+    public int modulo() {
+        return modulo;
+    }
+
+    public ModularInteger add(ModularInteger integer) {
+        return newinstance((long)content+integer.content);
+    }
+
+    public Generic add(Generic generic) {
+        return add((ModularInteger)generic);
+    }
+
+    public ModularInteger subtract(ModularInteger integer) {
+        return newinstance((long)content+(modulo-integer.content));
+    }
+
+    public Generic subtract(Generic generic) {
+        return subtract((ModularInteger)generic);
+    }
+
+    public ModularInteger multiply(ModularInteger integer) {
+        return newinstance((long)content*integer.content);
+    }
+
+    public Generic multiply(Generic generic) {
+        return multiply((ModularInteger)generic);
+    }
+
+    public Generic divide(Generic generic) throws ArithmeticException {
+        return multiply(generic.inverse());
+    }
+
+    public Generic inverse() {
+        return newinstance(BigInteger.valueOf(content).modInverse(BigInteger.valueOf(modulo)).intValue());
+    }
+
+    public Generic gcd(Generic generic) {
+        throw new UnsupportedOperationException();
+    }
+
+    public Generic gcd() {
+        throw new UnsupportedOperationException();
+    }
+
+    public Generic pow(int exponent) {
+        throw new UnsupportedOperationException();
+    }
+
+    public Generic negate() {
+        return newinstance(modulo-content);
+    }
+
+    public int signum() {
+        return content>0?1:0;
+    }
+
+    public int degree() {
+        return 0;
+    }
+
+    public Generic antiderivative(Variable variable) throws NotIntegrableException {
+        throw new UnsupportedOperationException();
+    }
+
+    public Generic derivative(Variable variable) {
+        throw new UnsupportedOperationException();
+    }
+
+    public Generic substitute(Variable variable, Generic generic) {
+        throw new UnsupportedOperationException();
+    }
+
+    public Generic expand() {
+        throw new UnsupportedOperationException();
+    }
+
+    public Generic factorize() {
+        throw new UnsupportedOperationException();
+    }
+
+    public Generic elementary() {
+        throw new UnsupportedOperationException();
+    }
+
+    public Generic simplify() {
+        throw new UnsupportedOperationException();
+    }
+
+    public Generic numeric() {
+        throw new UnsupportedOperationException();
+    }
+
+    public Generic valueof(Generic generic) {
+        if(generic instanceof ModularInteger) {
+            return newinstance(((ModularInteger)generic).content);
+        } else {
+            return newinstance(((JSCLInteger)generic).content().mod(BigInteger.valueOf(modulo)).intValue());
+        }
+    }
+
+    public Generic[] sumValue() {
+        throw new UnsupportedOperationException();
+    }
+
+    public Generic[] productValue() throws NotProductException {
+        throw new UnsupportedOperationException();
+    }
+
+    public Power powerValue() throws NotPowerException {
+        throw new UnsupportedOperationException();
+    }
+
+    public Expression expressionValue() throws NotExpressionException {
+        return Expression.valueOf(integerValue());
+    }
+
+    public JSCLInteger integerValue() throws NotIntegerException {
+        return JSCLInteger.valueOf(content);
+    }
+
+    public Variable variableValue() throws NotVariableException {
+        throw new UnsupportedOperationException();
+    }
+
+    public Variable[] variables() {
+        throw new UnsupportedOperationException();
+    }
+
+    public boolean isPolynomial(Variable variable) {
+        throw new UnsupportedOperationException();
+    }
+
+    public boolean isConstant(Variable variable) {
+        throw new UnsupportedOperationException();
+    }
+
+    public int compareTo(ModularInteger integer) {
+        return content<integer.content?-1:content>integer.content?1:0;
+    }
+
+    public int compareTo(Generic generic) {
+        if(generic instanceof ModularInteger) {
+            return compareTo((ModularInteger)generic);
+        } else if(generic instanceof JSCLInteger) {
+            return compareTo(valueof(generic));
+        } else {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    public static ModularInteger factory(int modulo) {
+        return new ModularInteger(0,modulo);
+    }
+
+    public String toString() {
+        return ""+content;
+    }
+
+    public String toJava() {
+        throw new UnsupportedOperationException();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        throw new UnsupportedOperationException();
+    }
+
+    protected ModularInteger newinstance(long content) {
+        return new ModularInteger(content,modulo);
+    }
+}
diff --git a/src/misc/src/jscl/math/NotDivisibleException.java b/src/misc/src/jscl/math/NotDivisibleException.java
new file mode 100644
index 00000000..29ac1bac
--- /dev/null
+++ b/src/misc/src/jscl/math/NotDivisibleException.java
@@ -0,0 +1,9 @@
+package jscl.math;
+
+public class NotDivisibleException extends ArithmeticException {
+        public NotDivisibleException() {}
+
+        public NotDivisibleException(String s) {
+                super(s);
+        }
+}
diff --git a/src/misc/src/jscl/math/NotExpressionException.java b/src/misc/src/jscl/math/NotExpressionException.java
new file mode 100644
index 00000000..b1daf564
--- /dev/null
+++ b/src/misc/src/jscl/math/NotExpressionException.java
@@ -0,0 +1,9 @@
+package jscl.math;
+
+public class NotExpressionException extends ArithmeticException {
+        public NotExpressionException() {}
+
+        public NotExpressionException(String s) {
+                super(s);
+        }
+}
diff --git a/src/misc/src/jscl/math/NotIntegerException.java b/src/misc/src/jscl/math/NotIntegerException.java
new file mode 100644
index 00000000..053c65d8
--- /dev/null
+++ b/src/misc/src/jscl/math/NotIntegerException.java
@@ -0,0 +1,9 @@
+package jscl.math;
+
+public class NotIntegerException extends ArithmeticException {
+        public NotIntegerException() {}
+
+        public NotIntegerException(String s) {
+                super(s);
+        }
+}
diff --git a/src/misc/src/jscl/math/NotIntegrableException.java b/src/misc/src/jscl/math/NotIntegrableException.java
new file mode 100644
index 00000000..41017f32
--- /dev/null
+++ b/src/misc/src/jscl/math/NotIntegrableException.java
@@ -0,0 +1,9 @@
+package jscl.math;
+
+public class NotIntegrableException extends ArithmeticException {
+        public NotIntegrableException() {}
+
+        public NotIntegrableException(String s) {
+                super(s);
+        }
+}
diff --git a/src/misc/src/jscl/math/NotPowerException.java b/src/misc/src/jscl/math/NotPowerException.java
new file mode 100644
index 00000000..eaa5ed69
--- /dev/null
+++ b/src/misc/src/jscl/math/NotPowerException.java
@@ -0,0 +1,9 @@
+package jscl.math;
+
+public class NotPowerException extends ArithmeticException {
+        public NotPowerException() {}
+
+        public NotPowerException(String s) {
+                super(s);
+        }
+}
diff --git a/src/misc/src/jscl/math/NotProductException.java b/src/misc/src/jscl/math/NotProductException.java
new file mode 100644
index 00000000..c0a35ed1
--- /dev/null
+++ b/src/misc/src/jscl/math/NotProductException.java
@@ -0,0 +1,9 @@
+package jscl.math;
+
+public class NotProductException extends ArithmeticException {
+        public NotProductException() {}
+
+        public NotProductException(String s) {
+                super(s);
+        }
+}
diff --git a/src/misc/src/jscl/math/NotVariableException.java b/src/misc/src/jscl/math/NotVariableException.java
new file mode 100644
index 00000000..46580201
--- /dev/null
+++ b/src/misc/src/jscl/math/NotVariableException.java
@@ -0,0 +1,9 @@
+package jscl.math;
+
+public class NotVariableException extends ArithmeticException {
+        public NotVariableException() {}
+
+        public NotVariableException(String s) {
+                super(s);
+        }
+}
diff --git a/src/misc/src/jscl/math/NumericWrapper.java b/src/misc/src/jscl/math/NumericWrapper.java
new file mode 100644
index 00000000..b3d852c3
--- /dev/null
+++ b/src/misc/src/jscl/math/NumericWrapper.java
@@ -0,0 +1,344 @@
+package jscl.math;
+
+import jscl.math.function.Constant;
+import jscl.math.numeric.JSCLDouble;
+import jscl.math.numeric.Numeric;
+import jscl.math.numeric.NumericMatrix;
+import jscl.math.numeric.NumericVector;
+import jscl.mathml.MathML;
+
+public final class NumericWrapper extends Generic {
+    final Numeric content;
+
+    public NumericWrapper(JSCLInteger integer) {
+        content=JSCLDouble.valueOf(integer.content().doubleValue());
+    }
+
+    public NumericWrapper(Rational rational) {
+        content=JSCLDouble.valueOf(rational.numerator().doubleValue()/rational.denominator().doubleValue());
+    }
+
+    public NumericWrapper(JSCLVector vector) {
+        Numeric v[]=new Numeric[vector.n];
+        for(int i=0;i<vector.n;i++) v[i]=((NumericWrapper)vector.element[i].numeric()).content();
+        content=new NumericVector(v);
+    }
+
+    public NumericWrapper(Matrix matrix) {
+        Numeric m[][]=new Numeric[matrix.n][matrix.p];
+        for(int i=0;i<matrix.n;i++) {
+            for(int j=0;j<matrix.p;j++) {
+                m[i][j]=((NumericWrapper)matrix.element[i][j].numeric()).content();
+            }
+        }
+        content=new NumericMatrix(m);
+    }
+
+    public NumericWrapper(Constant constant) {
+        if(constant.compareTo(new Constant("pi"))==0) content=JSCLDouble.valueOf(Math.PI);
+        else if(constant.compareTo(new Constant("infin"))==0) content=JSCLDouble.valueOf(Double.POSITIVE_INFINITY);
+        else throw new ArithmeticException();
+    }
+
+    public NumericWrapper(Numeric numeric) {
+        content=numeric;
+    }
+
+    public Numeric content() {
+        return content;
+    }
+
+    public NumericWrapper add(NumericWrapper wrapper) {
+        return new NumericWrapper(content.add(wrapper.content));
+    }
+
+    public Generic add(Generic generic) {
+        if(generic instanceof NumericWrapper) {
+            return add((NumericWrapper)generic);
+        } else {
+            return add(valueof(generic));
+        }
+    }
+
+    public NumericWrapper subtract(NumericWrapper wrapper) {
+        return new NumericWrapper(content.subtract(wrapper.content));
+    }
+
+    public Generic subtract(Generic generic) {
+        if(generic instanceof NumericWrapper) {
+            return subtract((NumericWrapper)generic);
+        } else {
+            return subtract(valueof(generic));
+        }
+    }
+
+    public NumericWrapper multiply(NumericWrapper wrapper) {
+        return new NumericWrapper(content.multiply(wrapper.content));
+    }
+
+    public Generic multiply(Generic generic) {
+        if(generic instanceof NumericWrapper) {
+            return multiply((NumericWrapper)generic);
+        } else {
+            return multiply(valueof(generic));
+        }
+    }
+
+    public NumericWrapper divide(NumericWrapper wrapper) throws ArithmeticException {
+        return new NumericWrapper(content.divide(wrapper.content));
+    }
+
+    public Generic divide(Generic generic) throws ArithmeticException {
+        if(generic instanceof NumericWrapper) {
+            return divide((NumericWrapper)generic);
+        } else {
+            return divide(valueof(generic));
+        }
+    }
+
+    public Generic gcd(Generic generic) {
+        return null;
+    }
+
+    public Generic gcd() {
+        return null;
+    }
+
+    public Generic abs() {
+        return new NumericWrapper(content.abs());
+    }
+
+    public Generic negate() {
+        return new NumericWrapper(content.negate());
+    }
+
+    public int signum() {
+        return content.signum();
+    }
+
+    public int degree() {
+        return 0;
+    }
+
+    public Generic antiderivative(Variable variable) throws NotIntegrableException {
+        return null;
+    }
+
+    public Generic derivative(Variable variable) {
+        return null;
+    }
+
+    public Generic substitute(Variable variable, Generic generic) {
+        return null;
+    }
+
+    public Generic expand() {
+        return null;
+    }
+
+    public Generic factorize() {
+        return null;
+    }
+
+    public Generic elementary() {
+        return null;
+    }
+
+    public Generic simplify() {
+        return null;
+    }
+
+    public Generic numeric() {
+        return this;
+    }
+
+    public NumericWrapper valueof(NumericWrapper wrapper) {
+        return new NumericWrapper(content.valueof(wrapper.content));
+    }
+
+    public Generic valueof(Generic generic) {
+        if(generic instanceof NumericWrapper) {
+            return valueof((NumericWrapper)generic);
+        } else if(generic instanceof JSCLInteger) {
+            return new NumericWrapper((JSCLInteger)generic);
+        } else throw new ArithmeticException();
+    }
+
+    public Generic[] sumValue() {
+        return null;
+    }
+
+    public Generic[] productValue() throws NotProductException {
+        return null;
+    }
+
+    public Power powerValue() throws NotPowerException {
+        return null;
+    }
+
+    public Expression expressionValue() throws NotExpressionException {
+        throw new NotExpressionException();
+    }
+
+    public JSCLInteger integerValue() throws NotIntegerException {
+        if(content instanceof JSCLDouble) return JSCLInteger.valueOf((int)((JSCLDouble)content).doubleValue());
+        else throw new NotIntegerException();
+    }
+
+    public Variable variableValue() throws NotVariableException {
+        throw new NotVariableException();
+    }
+
+    public Variable[] variables() {
+        return new Variable[0];
+    }
+
+    public boolean isPolynomial(Variable variable) {
+        return true;
+    }
+
+    public boolean isConstant(Variable variable) {
+        return true;
+    }
+
+    public Generic sgn() {
+        return new NumericWrapper(content.sgn());
+    }
+
+    public Generic log() {
+        return new NumericWrapper(content.log());
+    }
+
+    public Generic exp() {
+        return new NumericWrapper(content.exp());
+    }
+
+    public Generic pow(Generic generic) {
+        return new NumericWrapper(content.pow(((NumericWrapper)generic).content));
+    }
+
+    public Generic sqrt() {
+        return new NumericWrapper(content.sqrt());
+    }
+
+    public Generic nthrt(int n) {
+        return new NumericWrapper(content.nthrt(n));
+    }
+
+    public static Generic root(int subscript, Generic parameter[]) {
+        Numeric param[]=new Numeric[parameter.length];
+        for(int i=0;i<param.length;i++) param[i]=((NumericWrapper)parameter[i]).content;
+        return new NumericWrapper(Numeric.root(subscript,param));
+    }
+
+    public Generic conjugate() {
+        return new NumericWrapper(content.conjugate());
+    }
+
+    public Generic acos() {
+        return new NumericWrapper(content.acos());
+    }
+
+    public Generic asin() {
+        return new NumericWrapper(content.asin());
+    }
+
+    public Generic atan() {
+        return new NumericWrapper(content.atan());
+    }
+
+    public Generic acot() {
+        return new NumericWrapper(content.acot());
+    }
+
+    public Generic cos() {
+        return new NumericWrapper(content.cos());
+    }
+
+    public Generic sin() {
+        return new NumericWrapper(content.sin());
+    }
+
+    public Generic tan() {
+        return new NumericWrapper(content.tan());
+    }
+
+    public Generic cot() {
+        return new NumericWrapper(content.cot());
+    }
+
+    public Generic acosh() {
+        return new NumericWrapper(content.acosh());
+    }
+
+    public Generic asinh() {
+        return new NumericWrapper(content.asinh());
+    }
+
+    public Generic atanh() {
+        return new NumericWrapper(content.atanh());
+    }
+
+    public Generic acoth() {
+        return new NumericWrapper(content.acoth());
+    }
+
+    public Generic cosh() {
+        return new NumericWrapper(content.cosh());
+    }
+
+    public Generic sinh() {
+        return new NumericWrapper(content.sinh());
+    }
+
+    public Generic tanh() {
+        return new NumericWrapper(content.tanh());
+    }
+
+    public Generic coth() {
+        return new NumericWrapper(content.coth());
+    }
+
+    public int compareTo(NumericWrapper wrapper) {
+        return content.compareTo(wrapper.content);
+    }
+
+    public int compareTo(Generic generic) {
+        if(generic instanceof NumericWrapper) {
+            return compareTo((NumericWrapper)generic);
+        } else {
+            return compareTo(valueof(generic));
+        }
+    }
+
+    public String toString() {
+        return content.toString();
+    }
+
+    public String toJava() {
+        return "JSCLDouble.valueOf("+new Double(((JSCLDouble)content).doubleValue())+")";
+    }
+
+    public void toMathML(MathML element, Object data) {
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) bodyToMathML(element);
+        else {
+            MathML e1=element.element("msup");
+            bodyToMathML(e1);
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+
+    void bodyToMathML(MathML element) {
+        MathML e1=element.element("mn");
+        e1.appendChild(element.text(String.valueOf(new Double(((JSCLDouble)content).doubleValue()))));
+        element.appendChild(e1);
+    }
+
+    protected Generic newinstance() {
+        return null;
+    }
+}
diff --git a/src/misc/src/jscl/math/Power.java b/src/misc/src/jscl/math/Power.java
new file mode 100644
index 00000000..83737032
--- /dev/null
+++ b/src/misc/src/jscl/math/Power.java
@@ -0,0 +1,27 @@
+package jscl.math;
+
+public class Power {
+    final Generic value;
+    final int exponent;
+
+    public Power(Generic value, int exponent) {
+        this.value=value;
+        this.exponent=exponent;
+    }
+    
+    public Generic value() {
+        return value(false);
+    }
+    
+    public Generic value(boolean content) {
+        return content?GenericVariable.content(value):value;
+    }
+
+    public int exponent() {
+        return exponent;
+    }
+
+    public String toString() {
+        return "("+value+", "+exponent+")";
+    }
+}
diff --git a/src/misc/src/jscl/math/Rational.java b/src/misc/src/jscl/math/Rational.java
new file mode 100644
index 00000000..5edc4222
--- /dev/null
+++ b/src/misc/src/jscl/math/Rational.java
@@ -0,0 +1,281 @@
+package jscl.math;
+
+import java.math.BigInteger;
+import jscl.math.function.Frac;
+import jscl.math.function.Inv;
+import jscl.mathml.MathML;
+
+public final class Rational extends Generic implements Field {
+    public static final Rational factory=new Rational(BigInteger.valueOf(0),BigInteger.valueOf(1));
+    final BigInteger numerator;
+    final BigInteger denominator;
+
+    public Rational(BigInteger numerator, BigInteger denominator) {
+        this.numerator=numerator;
+        this.denominator=denominator;
+    }
+
+    public BigInteger numerator() {
+        return numerator;
+    }
+
+    public BigInteger denominator() {
+        return denominator;
+    }
+
+    public Rational add(Rational rational) {
+        BigInteger gcd=denominator.gcd(rational.denominator);
+        BigInteger c=denominator.divide(gcd);
+        BigInteger c2=rational.denominator.divide(gcd);
+        return new Rational(numerator.multiply(c2).add(rational.numerator.multiply(c)),denominator.multiply(c2)).reduce();
+    }
+
+    Rational reduce() {
+        BigInteger gcd=numerator.gcd(denominator);
+        if(gcd.signum()!=denominator.signum()) gcd=gcd.negate();
+        return gcd.signum()==0?this:new Rational(numerator.divide(gcd),denominator.divide(gcd));
+    }
+
+    public Generic add(Generic generic) {
+        if(generic instanceof Rational) {
+            return add((Rational)generic);
+        } else if(generic instanceof JSCLInteger) {
+            return add(valueof(generic));
+        } else {
+            return generic.valueof(this).add(generic);
+        }
+    }
+
+    public Rational multiply(Rational rational) {
+        BigInteger gcd=numerator.gcd(rational.denominator);
+        BigInteger gcd2=denominator.gcd(rational.numerator);
+        return new Rational(numerator.divide(gcd).multiply(rational.numerator.divide(gcd2)),denominator.divide(gcd2).multiply(rational.denominator.divide(gcd)));
+    }
+
+    public Generic multiply(Generic generic) {
+        if(generic instanceof Rational) {
+            return multiply((Rational)generic);
+        } else if(generic instanceof JSCLInteger) {
+            return multiply(valueof(generic));
+        } else {
+            return generic.multiply(this);
+        }
+    }
+
+    public Generic divide(Generic generic) throws ArithmeticException {
+        if(generic instanceof Rational) {
+            return multiply(generic.inverse());
+        } else if(generic instanceof JSCLInteger) {
+            return divide(valueof(generic));
+        } else {
+            return generic.valueof(this).divide(generic);
+        }
+    }
+
+    public Generic inverse() {
+        if(signum()<0) return new Rational(denominator.negate(),numerator.negate());
+        else return new Rational(denominator,numerator);
+    }
+
+    public Rational gcd(Rational rational) {
+        return new Rational(numerator.gcd(rational.numerator),scm(denominator,rational.denominator));
+    }
+
+    public Generic gcd(Generic generic) {
+        if(generic instanceof Rational) {
+            return gcd((Rational)generic);
+        } else if(generic instanceof JSCLInteger) {
+            return gcd(valueof(generic));
+        } else {
+            return generic.valueof(this).gcd(generic);
+        }
+    }
+
+    static BigInteger scm(BigInteger b1, BigInteger b2) {
+        return b1.multiply(b2).divide(b1.gcd(b2));
+    }
+
+    public Generic gcd() {
+        return null;
+    }
+
+    public Generic pow(int exponent) {
+        return null;
+    }
+
+    public Generic negate() {
+        return new Rational(numerator.negate(),denominator);
+    }
+
+    public int signum() {
+        return numerator.signum();
+    }
+
+    public int degree() {
+        return 0;
+    }
+
+    public Generic antiderivative(Variable variable) throws NotIntegrableException {
+        return multiply(variable.expressionValue());
+    }
+
+    public Generic derivative(Variable variable) {
+        return JSCLInteger.valueOf(0);
+    }
+
+    public Generic substitute(Variable variable, Generic generic) {
+        return this;
+    }
+
+    public Generic expand() {
+        return this;
+    }
+
+    public Generic factorize() {
+        return expressionValue().factorize();
+    }
+
+    public Generic elementary() {
+        return this;
+    }
+
+    public Generic simplify() {
+        return reduce();
+    }
+
+    public Generic numeric() {
+        return new NumericWrapper(this);
+    }
+
+    public Generic valueof(Generic generic) {
+        if(generic instanceof Rational) {
+            Rational r=(Rational)generic;
+            return new Rational(r.numerator,r.denominator);
+        } else if(generic instanceof Expression) {
+            boolean sign=generic.signum()<0;
+            Generic g[]=((Frac)(sign?generic.negate():generic).variableValue()).parameters();
+            JSCLInteger numerator=(JSCLInteger)(sign?g[0].negate():g[0]);
+            JSCLInteger denominator=(JSCLInteger)g[1];
+            return new Rational(numerator.content(),denominator.content());
+        } else {
+            JSCLInteger en=(JSCLInteger)generic;
+            return new Rational(en.content(),BigInteger.valueOf(1));
+        }
+    }
+
+    public Generic[] sumValue() {
+        try {
+            if(integerValue().signum()==0) return new Generic[0];
+            else return new Generic[] {this};
+        } catch (NotIntegerException e) {
+            return new Generic[] {this};
+        }
+    }
+
+    public Generic[] productValue() throws NotProductException {
+        try {
+            if(integerValue().compareTo(JSCLInteger.valueOf(1))==0) return new Generic[0];
+            else return new Generic[] {this};
+        } catch (NotIntegerException e) {
+            return new Generic[] {this};
+        }
+    }
+
+    public Power powerValue() throws NotPowerException {
+        return new Power(this,1);
+    }
+
+    public Expression expressionValue() throws NotExpressionException {
+        return Expression.valueOf(this);
+    }
+
+    public JSCLInteger integerValue() throws NotIntegerException {
+        if(denominator.compareTo(BigInteger.valueOf(1))==0) return new JSCLInteger(numerator);
+        else throw new NotIntegerException();
+    }
+
+    public Variable variableValue() throws NotVariableException {
+        try {
+            integerValue();
+            throw new NotVariableException();
+        } catch (NotIntegerException e) {
+            if(numerator.compareTo(BigInteger.valueOf(1))==0) return new Inv(new JSCLInteger(denominator));
+            else return new Frac(new JSCLInteger(numerator), new JSCLInteger(denominator));
+        }
+    }
+
+    public Variable[] variables() {
+        return new Variable[0];
+    }
+
+    public boolean isPolynomial(Variable variable) {
+        return true;
+    }
+
+    public boolean isConstant(Variable variable) {
+        return true;
+    }
+
+    public int compareTo(Rational rational) {
+        int c=denominator.compareTo(rational.denominator);
+        if(c<0) return -1;
+        else if(c>0) return 1;
+        else return numerator.compareTo(rational.numerator);
+    }
+
+    public int compareTo(Generic generic) {
+        if(generic instanceof Rational) {
+            return compareTo((Rational)generic);
+        } else if(generic instanceof JSCLInteger) {
+            return compareTo(valueof(generic));
+        } else {
+            return generic.valueof(this).compareTo(generic);
+        }
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        try {
+            buffer.append(integerValue());
+        } catch (NotIntegerException e) {
+            buffer.append(numerator);
+            buffer.append("/");
+            buffer.append(denominator);
+        }
+        return buffer.toString();
+    }
+
+    public String toJava() {
+        return "JSCLDouble.valueOf("+numerator+"/"+denominator+")";
+    }
+
+    public void toMathML(MathML element, Object data) {
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) bodyToMathML(element);
+        else {
+            MathML e1=element.element("msup");
+            bodyToMathML(e1);
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+
+    void bodyToMathML(MathML element) {
+        try {
+            MathML e1=element.element("mn");
+            e1.appendChild(element.text(String.valueOf(integerValue())));
+            element.appendChild(e1);
+        } catch (NotIntegerException e) {
+            MathML e1=element.element("mfrac");
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(numerator)));
+            e1.appendChild(e2);
+            e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(denominator)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+}
diff --git a/src/misc/src/jscl/math/Simplification.java b/src/misc/src/jscl/math/Simplification.java
new file mode 100644
index 00000000..d1f2eb9c
--- /dev/null
+++ b/src/misc/src/jscl/math/Simplification.java
@@ -0,0 +1,226 @@
+package jscl.math;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import jscl.math.function.Cubic;
+import jscl.math.function.Frac;
+import jscl.math.function.NotRootException;
+import jscl.math.function.Pow;
+import jscl.math.function.Root;
+import jscl.math.function.Sqrt;
+import jscl.math.polynomial.Basis;
+import jscl.math.polynomial.Monomial;
+import jscl.math.polynomial.Polynomial;
+import jscl.math.polynomial.UnivariatePolynomial;
+
+public class Simplification {
+    Map cache=new TreeMap();
+    Generic result;
+    List constraint;
+    boolean linear;
+
+    Simplification() {}
+
+    public static Generic compute(Generic generic) {
+        Simplification s=new Simplification();
+        s.computeValue(generic);
+        return s.getValue();
+    }
+
+    void computeValue(Generic generic) {
+        Debug.println("simplification");
+        Debug.increment();
+        Variable t=new TechnicalVariable("t");
+        linear=false;
+        constraint=new ArrayList();
+        process(new Constraint(t,t.expressionValue().subtract(generic),false));
+        UnivariatePolynomial p=polynomial(t);
+        switch(p.degree()) {
+            case 0:
+                result=generic;
+                break;
+            case 1:
+                result=new Root(p,0).evalsimp();
+                break;
+//          case 2:
+//              int n=branch(generic,p);
+//              if(n<p.degree()) linear(new Root(p,n).expressionValue());
+//              else linear(generic);
+//              break;
+            default:
+                linear(generic);
+        }
+        Debug.decrement();
+    }
+
+    void linear(Generic generic) {
+        Variable t=new TechnicalVariable("t");
+        linear=true;
+        constraint.clear();
+        process(new Constraint(t,t.expressionValue().subtract(generic),false));
+        UnivariatePolynomial p=polynomial(t);
+        switch(p.degree()) {
+            case 0:
+                result=generic;
+                break;
+            default:
+                result=new Root(p,0).evalsimp();
+        }
+    }
+
+    int branch(Generic generic, UnivariatePolynomial polynomial) {
+        int n=polynomial.degree();
+        Variable t=new TechnicalVariable("t");
+        linear=true;
+        for(int i=0;i<n;i++) {
+            constraint.clear();
+            process(new Constraint(t,t.expressionValue().subtract(generic.subtract(new Root(polynomial,i).expressionValue())),false));
+            Generic a=polynomial(t).solve();
+            if(a!=null?a.signum()==0:false) return i;
+        }
+        return n;
+    }
+
+    UnivariatePolynomial polynomial(Variable t) {
+        Polynomial fact=Polynomial.factory(t);
+        int n=constraint.size();
+        Generic a[]=new Generic[n];
+        Variable unk[]=new Variable[n];
+        if(linear) {
+            int j=0;
+            for(int i=0;i<n;i++) {
+                Constraint c=(Constraint)constraint.get(i);
+                if(c.reduce) {
+                    a[j]=c.generic;
+                    unk[j]=c.unknown;
+                    j++;
+                }
+            }
+            int k=0;
+            for(int i=0;i<n;i++) {
+                Constraint c=(Constraint)constraint.get(i);
+                if(!c.reduce) {
+                    a[j]=c.generic;
+                    unk[j]=c.unknown;
+                    j++;
+                    k++;
+                }
+            }
+            a=solve(a,unk,k);
+            for(int i=0;i<a.length;i++) {
+                UnivariatePolynomial p=(UnivariatePolynomial)fact.valueof(a[i]);
+                if(p.degree()==1) return p;
+            }
+            return null;
+        } else {
+            for(int i=0;i<n;i++) {
+                Constraint c=(Constraint)constraint.get(i);
+                a[i]=c.generic;
+                unk[i]=c.unknown;
+            }
+            a=solve(a,unk,n);
+            return (UnivariatePolynomial)fact.valueof(a[0]);
+        }
+    }
+
+    Generic[] solve(Generic generic[], Variable unknown[], int n) {
+        Variable unk[]=Basis.augmentUnknown(unknown,generic);
+        return Basis.compute(generic,unk,Monomial.kthElimination(n)).elements();
+    }
+
+    void process(Constraint co) {
+        int n1=0;
+        int n2=0;
+        constraint.add(co);
+        do {
+            n1=n2;
+            n2=constraint.size();
+            for(int i=n1;i<n2;i++) {
+                co=(Constraint)constraint.get(i);
+                subProcess(co);
+            }
+        } while(n1<n2);
+    }
+
+    void subProcess(Constraint co) {
+        Variable va[]=co.generic.variables();
+        for(int i=0;i<va.length;i++) {
+            Variable v=va[i];
+            if(constraint.contains(new Constraint(v))) continue;
+            co=null;
+            if(v instanceof Frac) {
+                Generic g[]=((Frac)v).parameters();
+                co=new Constraint(v,v.expressionValue().multiply(g[1]).subtract(g[0]),false);
+            } else if(v instanceof Sqrt) {
+                Generic g[]=((Sqrt)v).parameters();
+                if(linear) co=linearConstraint(v);
+                if(co==null) co=new Constraint(v,v.expressionValue().pow(2).subtract(g[0]),true);
+            } else if(v instanceof Cubic) {
+                Generic g[]=((Cubic)v).parameters();
+                if(linear) co=linearConstraint(v);
+                if(co==null) co=new Constraint(v,v.expressionValue().pow(3).subtract(g[0]),true);
+            } else if(v instanceof Pow) {
+                try {
+                    Root r=((Pow)v).rootValue();
+                    int d=r.degree();
+                    Generic g[]=r.parameters();
+                    if(linear) co=linearConstraint(v);
+                    if(co==null) co=new Constraint(v,v.expressionValue().pow(d).subtract(g[0].negate()),d>1);
+                } catch (NotRootException e) {
+                    co=linearConstraint(v);
+                }
+            } else if(v instanceof Root) {
+                try {
+                    Root r=(Root)v;
+                    int d=r.degree();
+                    int n=r.subscript().integerValue().intValue();
+                    Generic g[]=r.parameters();
+                    if(linear) co=linearConstraint(v);
+                    if(co==null) co=new Constraint(v,Root.sigma(g,d-n).multiply(JSCLInteger.valueOf(-1).pow(d-n)).multiply(g[d]).subtract(g[n]),d>1);
+                } catch (NotIntegerException e) {
+                    co=linearConstraint(v);
+                }
+            } else co=linearConstraint(v);
+            if(co!=null) constraint.add(co);
+        }
+    }
+
+    Constraint linearConstraint(Variable v) {
+        Generic s;
+        Object o=cache.get(v);
+        if(o!=null) s=(Generic)o;
+        else {
+            s=v.simplify();
+            cache.put(v,s);
+        }
+        Generic a=v.expressionValue().subtract(s);
+        if(a.signum()!=0) return new Constraint(v,a,false);
+        else return null;
+    }
+
+    Generic getValue() {
+        return result;
+    }
+}
+
+class Constraint {
+    Variable unknown;
+    Generic generic;
+    boolean reduce;
+
+    Constraint(Variable unknown, Generic generic, boolean reduce) {
+        this.unknown=unknown;
+        this.generic=generic;
+        this.reduce=reduce;
+    }
+
+    Constraint(Variable unknown) {
+        this(unknown,null,false);
+    }
+
+    public boolean equals(Object obj) {
+        return unknown.compareTo(((Constraint)obj).unknown)==0;
+    }
+}
diff --git a/src/misc/src/jscl/math/TechnicalVariable.java b/src/misc/src/jscl/math/TechnicalVariable.java
new file mode 100644
index 00000000..06cfbfc1
--- /dev/null
+++ b/src/misc/src/jscl/math/TechnicalVariable.java
@@ -0,0 +1,96 @@
+package jscl.math;
+
+public class TechnicalVariable extends Variable {
+        public int subscript[];
+
+        public TechnicalVariable(String name) {
+                this(name,new int[0]);
+        }
+
+        public TechnicalVariable(String name, int subscript[]) {
+                super(name);
+                this.subscript=subscript;
+        }
+
+        public Generic antiderivative(Variable variable) throws NotIntegrableException {
+                throw new NotIntegrableException();
+        }
+
+        public Generic derivative(Variable variable) {
+                if(isIdentity(variable)) return JSCLInteger.valueOf(1);
+                else return JSCLInteger.valueOf(0);
+        }
+
+        public Generic substitute(Variable variable, Generic generic) {
+                if(isIdentity(variable)) return generic;
+                else return expressionValue();
+        }
+
+        public Generic expand() {
+                return expressionValue();
+        }
+
+        public Generic factorize() {
+                return expressionValue();
+        }
+
+        public Generic elementary() {
+                return expressionValue();
+        }
+
+        public Generic simplify() {
+                return expressionValue();
+        }
+
+        public Generic numeric() {
+                throw new ArithmeticException();
+        }
+
+        public boolean isConstant(Variable variable) {
+                return !isIdentity(variable);
+        }
+
+        public int compareTo(Variable variable) {
+                if(this==variable) return 0;
+                int c=comparator.compare(this,variable);
+                if(c<0) return -1;
+                else if(c>0) return 1;
+                else {
+                        TechnicalVariable v=(TechnicalVariable)variable;
+                        c=name.compareTo(v.name);
+                        if(c<0) return -1;
+                        else if(c>0) return 1;
+                        else return compareSubscript(subscript,v.subscript);
+                }
+        }
+
+        public int compareSubscript(int c1[], int c2[]) {
+                if(c1.length<c2.length) return -1;
+                else if(c1.length>c2.length) return 1;
+                for(int i=0;i<c1.length;i++) {
+                        if(c1[i]<c2[i]) return -1;
+                        else if(c1[i]>c2[i]) return 1;
+                }
+                return 0;
+        }
+
+        public String toString() {
+                StringBuffer buffer=new StringBuffer();
+                buffer.append(name);
+                if(subscript.length==1) buffer.append(subscript[0]);
+                else for(int i=0;i<subscript.length;i++) buffer.append("[").append(subscript[i]).append("]");
+                return buffer.toString();
+        }
+
+        public String toJava() {
+                return null;
+        }
+
+        public String toMathML(Object data) {
+                return null;
+        }
+
+        protected Variable newinstance() {
+                return new TechnicalVariable(name);
+        }
+}
diff --git a/src/misc/src/jscl/math/Variable.java b/src/misc/src/jscl/math/Variable.java
new file mode 100644
index 00000000..4ce6f341
--- /dev/null
+++ b/src/misc/src/jscl/math/Variable.java
@@ -0,0 +1,188 @@
+package jscl.math;
+
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Map;
+import jscl.math.function.Algebraic;
+import jscl.math.function.Constant;
+import jscl.math.function.Frac;
+import jscl.math.function.Function;
+import jscl.math.function.ImplicitFunction;
+import jscl.math.function.Root;
+import jscl.math.function.Sqrt;
+import jscl.math.operator.Factorial;
+import jscl.math.operator.Operator;
+import jscl.mathml.MathML;
+import jscl.text.ParseException;
+
+public abstract class Variable implements Comparable {
+    public static final Comparator comparator=VariableComparator.comparator;
+    protected String name;
+
+    public Variable(String name) {
+        this.name=name;
+    }
+
+    public String name() {
+        return name;
+    }
+
+    public abstract Generic antiderivative(Variable variable) throws NotIntegrableException;
+    public abstract Generic derivative(Variable variable);
+    public abstract Generic substitute(Variable variable, Generic generic);
+    public abstract Generic expand();
+    public abstract Generic factorize();
+    public abstract Generic elementary();
+    public abstract Generic simplify();
+    public abstract Generic numeric();
+
+    public Expression expressionValue() {
+        return Expression.valueOf(this);
+    }
+
+    public abstract boolean isConstant(Variable variable);
+
+    public boolean isIdentity(Variable variable) {
+        return compareTo(variable)==0;
+    }
+
+    public abstract int compareTo(Variable variable);
+
+    public int compareTo(Object o) {
+        return compareTo((Variable)o);
+    }
+
+    public boolean equals(Object obj) {
+        if(obj instanceof Variable) {
+            return compareTo((Variable)obj)==0;
+        } else return false;
+    }
+
+    public static Variable valueOf(String str) throws ParseException, NotVariableException {
+        return Expression.valueOf(str).variableValue();
+    }
+
+    public static Variable[] valueOf(String str[]) throws ParseException, NotVariableException {
+            int n=str.length;
+            Variable var[]=new Variable[n];
+            for(int i=0;i<n;i++) var[i]=valueOf(str[i]);
+            return var;
+    }
+
+    public String toString() {
+        return name;
+    }
+
+    public String toJava() {
+        return name;
+    }
+
+    public void toMathML(MathML element, Object data) {
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) nameToMathML(element);
+        else {
+            MathML e1=element.element("msup");
+            nameToMathML(e1);
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+
+    protected void nameToMathML(MathML element) {
+        MathML e1=element.element("mi");
+        e1.appendChild(element.text(special.containsKey(name)?(String)special.get(name):name));
+        element.appendChild(e1);
+    }
+
+    protected abstract Variable newinstance();
+
+        static final Map special=new HashMap();
+        static {
+            special.put("Alpha","\u0391");
+            special.put("Beta","\u0392");
+            special.put("Gamma","\u0393");
+            special.put("Delta","\u0394");
+            special.put("Epsilon","\u0395");
+            special.put("Zeta","\u0396");
+            special.put("Eta","\u0397");
+            special.put("Theta","\u0398");
+            special.put("Iota","\u0399");
+            special.put("Kappa","\u039A");
+            special.put("Lambda","\u039B");
+            special.put("Mu","\u039C");
+            special.put("Nu","\u039D");
+            special.put("Xi","\u039E");
+            special.put("Pi","\u03A0");
+            special.put("Rho","\u03A1");
+            special.put("Sigma","\u03A3");
+            special.put("Tau","\u03A4");
+            special.put("Upsilon","\u03A5");
+            special.put("Phi","\u03A6");
+            special.put("Chi","\u03A7");
+            special.put("Psi","\u03A8");
+            special.put("Omega","\u03A9");
+            special.put("alpha","\u03B1");
+            special.put("beta","\u03B2");
+            special.put("gamma","\u03B3");
+            special.put("delta","\u03B4");
+            special.put("epsilon","\u03B5");
+            special.put("zeta","\u03B6");
+            special.put("eta","\u03B7");
+            special.put("theta","\u03B8");
+            special.put("iota","\u03B9");
+            special.put("kappa","\u03BA");
+            special.put("lambda","\u03BB");
+            special.put("mu","\u03BC");
+            special.put("nu","\u03BD");
+            special.put("xi","\u03BE");
+            special.put("pi","\u03C0");
+            special.put("rho","\u03C1");
+            special.put("sigma","\u03C3");
+            special.put("tau","\u03C4");
+            special.put("upsilon","\u03C5");
+            special.put("phi","\u03C6");
+            special.put("chi","\u03C7");
+            special.put("psi","\u03C8");
+            special.put("omega","\u03C9");
+            special.put("infin","\u221E");
+            special.put("nabla","\u2207");
+            special.put("aleph","\u2135");
+            special.put("hbar","\u210F");
+            special.put("hamilt","\u210B");
+            special.put("lagran","\u2112");
+            special.put("square","\u25A1");
+        }
+}
+
+class VariableComparator implements Comparator {
+    public static final Comparator comparator=new VariableComparator();
+
+    private VariableComparator() {}
+
+    public int compare(Object o1, Object o2) {
+        return value((Variable)o1)-value((Variable)o2);
+    }
+
+    static int value(Variable v) {
+        int n;
+        if(v instanceof TechnicalVariable) n=0;
+        else if(v instanceof IntegerVariable) n=1;
+        else if(v instanceof DoubleVariable) n=2;
+        else if(v instanceof Frac && ((Frac)v).integer()) n=3;
+        else if(v instanceof Sqrt && ((Sqrt)v).imaginary()) n=4;
+        else if(v instanceof Constant) n=5;
+        else if(v instanceof Root) n=6;
+        else if(v instanceof Algebraic) n=7;
+        else if(v instanceof ImplicitFunction) n=8;
+        else if(v instanceof Function) n=9;
+        else if(v instanceof Factorial) n=10;
+        else if(v instanceof Operator) n=11;
+        else if(v instanceof ExpressionVariable) n=12;
+        else if(v instanceof VectorVariable) n=13;
+        else if(v instanceof MatrixVariable) n=14;
+        else throw new ArithmeticException();
+        return n;
+    }
+}
diff --git a/src/misc/src/jscl/math/VectorVariable.java b/src/misc/src/jscl/math/VectorVariable.java
new file mode 100644
index 00000000..2b9d15b9
--- /dev/null
+++ b/src/misc/src/jscl/math/VectorVariable.java
@@ -0,0 +1,11 @@
+package jscl.math;
+
+public class VectorVariable extends GenericVariable {
+        public VectorVariable(Generic generic) {
+                super(generic);
+        }
+
+        protected Variable newinstance() {
+                return new VectorVariable(null);
+        }
+}
diff --git a/src/misc/src/jscl/math/function/Abs.java b/src/misc/src/jscl/math/function/Abs.java
new file mode 100644
index 00000000..cdec493a
--- /dev/null
+++ b/src/misc/src/jscl/math/function/Abs.java
@@ -0,0 +1,95 @@
+package jscl.math.function;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegerException;
+import jscl.math.NotIntegrableException;
+import jscl.math.NotVariableException;
+import jscl.math.NumericWrapper;
+import jscl.math.Variable;
+import jscl.mathml.MathML;
+
+public class Abs extends Function {
+    public Abs(Generic generic) {
+        super("abs",new Generic[] {generic});
+    }
+
+    public Generic antiderivative(int n) throws NotIntegrableException {
+        return Constant.half.multiply(parameter[0]).multiply(new Abs(parameter[0]).evaluate());
+    }
+
+    public Generic derivative(int n) {
+        return new Sgn(parameter[0]).evaluate();
+    }
+
+    public Generic evaluate() {
+        if(parameter[0].signum()<0) {
+            return new Abs(parameter[0].negate()).evaluate();
+        }
+        try {
+            return parameter[0].integerValue().abs();
+        } catch (NotIntegerException e) {}
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return new Sqrt(
+            parameter[0].pow(2)
+        ).evalelem();
+    }
+
+    public Generic evalsimp() {
+        if(parameter[0].signum()<0) {
+            return new Abs(parameter[0].negate()).evalsimp();
+        }
+        try {
+            return parameter[0].integerValue().abs();
+        } catch (NotIntegerException e) {}
+        try {
+            Variable v=parameter[0].variableValue();
+            if(v instanceof Abs) {
+                Function f=(Function)v;
+                return f.evalsimp();
+            } else if(v instanceof Sgn) {
+                return JSCLInteger.valueOf(1);
+            }
+        } catch (NotVariableException e) {}
+        return expressionValue();
+    }
+
+    public Generic evalnum() {
+        return ((NumericWrapper)parameter[0]).abs();
+    }
+
+    public String toJava() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append(parameter[0].toJava());
+        buffer.append(".abs()");
+        return buffer.toString();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) bodyToMathML(element);
+        else {
+            MathML e1=element.element("msup");
+            bodyToMathML(e1);
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+
+    void bodyToMathML(MathML element) {
+        MathML e1=element.element("mfenced");
+        e1.setAttribute("open","|");
+        e1.setAttribute("close","|");
+        parameter[0].toMathML(e1,null);
+        element.appendChild(e1);
+    }
+
+    protected Variable newinstance() {
+        return new Abs(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/Algebraic.java b/src/misc/src/jscl/math/function/Algebraic.java
new file mode 100644
index 00000000..63ecdd7b
--- /dev/null
+++ b/src/misc/src/jscl/math/function/Algebraic.java
@@ -0,0 +1,32 @@
+package jscl.math.function;
+
+import jscl.math.Generic;
+import jscl.math.NotIntegrableException;
+import jscl.mathml.MathML;
+
+public abstract class Algebraic extends Function {
+    public Algebraic(String name, Generic parameter[]) {
+        super(name,parameter);
+    }
+
+    public abstract Root rootValue() throws NotRootException;
+
+    public Generic antiderivative(int n) throws NotIntegrableException {
+        return null;
+    }
+
+    public void toMathML(MathML element, Object data) {
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) bodyToMathML(element,false);
+        else {
+            MathML e1=element.element("msup");
+            bodyToMathML(e1,true);
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+
+    abstract void bodyToMathML(MathML element, boolean fenced);
+}
diff --git a/src/misc/src/jscl/math/function/ArcTrigonometric.java b/src/misc/src/jscl/math/function/ArcTrigonometric.java
new file mode 100644
index 00000000..b603f4e7
--- /dev/null
+++ b/src/misc/src/jscl/math/function/ArcTrigonometric.java
@@ -0,0 +1,18 @@
+package jscl.math.function;
+
+import jscl.math.Generic;
+import jscl.math.NotIntegrableException;
+
+public abstract class ArcTrigonometric extends Function {
+    public ArcTrigonometric(String name, Generic parameter[]) {
+        super(name,parameter);
+    }
+
+    public Generic antiderivative(int n) throws NotIntegrableException {
+        throw new NotIntegrableException();
+    }
+
+    public Generic evalsimp() {
+        return evaluate();
+    }
+}
diff --git a/src/misc/src/jscl/math/function/Comparison.java b/src/misc/src/jscl/math/function/Comparison.java
new file mode 100644
index 00000000..1da08b65
--- /dev/null
+++ b/src/misc/src/jscl/math/function/Comparison.java
@@ -0,0 +1,97 @@
+package jscl.math.function;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegerException;
+import jscl.math.NotIntegrableException;
+import jscl.math.NumericWrapper;
+import jscl.math.Variable;
+import jscl.mathml.MathML;
+
+public class Comparison extends Function {
+    int operator;
+
+    public Comparison(String name, Generic expression1, Generic expression2) {
+        super(name,new Generic[] {expression1,expression2});
+        for(int i=0;i<easo.length;i++) if(name.compareTo(easo[i])==0) operator=i;
+    }
+
+    public Generic antiderivative(int n) throws NotIntegrableException {
+        throw new NotIntegrableException();
+    }
+
+    public Generic derivative(int n) {
+        return JSCLInteger.valueOf(0);
+    }
+
+    public Generic evaluate() {
+        try {
+            return compare(parameter[0].integerValue(),parameter[1].integerValue());
+        } catch (NotIntegerException e) {}
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return expressionValue();
+    }
+
+    public Generic evalsimp() {
+        return expressionValue();
+    }
+
+    public Generic evalnum() {
+        return compare((NumericWrapper)parameter[0],(NumericWrapper)parameter[1]);
+    }
+
+    JSCLInteger compare(JSCLInteger a1, JSCLInteger a2) {
+        return JSCLInteger.valueOf(compare((Generic)a1,(Generic)a2)?1:0);
+    }
+
+    NumericWrapper compare(NumericWrapper a1, NumericWrapper a2) {
+        return new NumericWrapper(JSCLInteger.valueOf(compare((Generic)a1,(Generic)a2)?1:0));
+    }
+
+    boolean compare(Generic a1, Generic a2) {
+        switch(operator) {
+            case 0:
+                return a1.compareTo(a2)==0;
+            case 1:
+                return a1.compareTo(a2)<0;
+            case 2:
+                return a1.compareTo(a2)>0;
+            case 3:
+                return a1.compareTo(a2)!=0;
+            case 4:
+                return a1.compareTo(a2)<=0;
+            case 5:
+                return a1.compareTo(a2)>=0;
+            case 6:
+                return a1.compareTo(a2)==0;
+            default:
+                return false;
+        }
+    }
+
+    public String toJava() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append(parameter[0].toJava()).append(easj[operator]).append(parameter[1].toJava());
+        return buffer.toString();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        parameter[0].toMathML(element,null);
+        MathML e1=element.element("mo");
+        e1.appendChild(element.text(easm[operator]));
+        element.appendChild(e1);
+        parameter[1].toMathML(element,null);
+    }
+
+    protected Variable newinstance() {
+        return new Comparison(name,null,null);
+    }
+
+    private static final String eass[]={"=","<=",">=","<>","<",">","~"};
+    private static final String easj[]={"==","<=",">=","!=","<",">","=="};
+    private static final String easm[]={"=","\u2264","\u2265","\u2260","<",">","\u2248"};
+    private static final String easo[]={"eq","le","ge","ne","lt","gt","ap"};
+}
diff --git a/src/misc/src/jscl/math/function/Conjugate.java b/src/misc/src/jscl/math/function/Conjugate.java
new file mode 100644
index 00000000..40d52ece
--- /dev/null
+++ b/src/misc/src/jscl/math/function/Conjugate.java
@@ -0,0 +1,132 @@
+package jscl.math.function;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.JSCLVector;
+import jscl.math.Matrix;
+import jscl.math.NotIntegerException;
+import jscl.math.NotIntegrableException;
+import jscl.math.NotVariableException;
+import jscl.math.NumericWrapper;
+import jscl.math.Power;
+import jscl.math.Variable;
+import jscl.mathml.MathML;
+
+public class Conjugate extends Function {
+    public Conjugate(Generic generic) {
+        super("conjugate",new Generic[] {generic});
+    }
+
+    public Generic antiderivative(int n) throws NotIntegrableException {
+        return Constant.half.multiply(evaluate().pow(2));
+    }
+
+    public Generic derivative(int n) {
+        return JSCLInteger.valueOf(1);
+    }
+
+    public Generic evaluate() {
+        try {
+            return parameter[0].integerValue();
+        } catch (NotIntegerException e) {}
+        if(parameter[0] instanceof Matrix) {
+            return ((Matrix)parameter[0]).conjugate();
+        } else if(parameter[0] instanceof JSCLVector) {
+            return ((JSCLVector)parameter[0]).conjugate();
+        }
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        try {
+            return parameter[0].integerValue();
+        } catch (NotIntegerException e) {}
+        return expressionValue();
+    }
+
+    public Generic evalsimp() {
+        try {
+            return parameter[0].integerValue();
+        } catch (NotIntegerException e) {}
+        if(parameter[0].signum()<0) {
+            return new Conjugate(parameter[0].negate()).evalsimp().negate();
+        } else if(parameter[0].compareTo(Constant.i)==0) {
+            return Constant.i.negate();
+        }
+        try {
+            Variable v=parameter[0].variableValue();
+            if(v instanceof Conjugate) {
+                Generic g[]=((Conjugate)v).parameters();
+                return g[0];
+            } else if(v instanceof Exp) {
+                Generic g[]=((Exp)v).parameters();
+                return new Exp(new Conjugate(g[0]).evalsimp()).evalsimp();
+            } else if(v instanceof Log) {
+                Generic g[]=((Log)v).parameters();
+                return new Log(new Conjugate(g[0]).evalsimp()).evalsimp();
+            }
+        } catch (NotVariableException e) {
+            Generic a[]=parameter[0].sumValue();
+            if(a.length>1) {
+                Generic s=JSCLInteger.valueOf(0);
+                for(int i=0;i<a.length;i++) {
+                    s=s.add(new Conjugate(a[i]).evalsimp());
+                }
+                return s;
+            } else {
+                Generic p[]=a[0].productValue();
+                Generic s=JSCLInteger.valueOf(1);
+                for(int i=0;i<p.length;i++) {
+                    Power o=p[i].powerValue();
+                    s=s.multiply(new Conjugate(o.value()).evalsimp().pow(o.exponent()));
+                }
+                return s;
+            }
+        }
+        Generic n[]=Frac.separateCoefficient(parameter[0]);
+        if(n[0].compareTo(JSCLInteger.valueOf(1))==0 && n[1].compareTo(JSCLInteger.valueOf(1))==0);
+        else return new Conjugate(n[2]).evalsimp().multiply(
+            new Frac(n[0],n[1]).evalsimp()
+        );
+        return expressionValue();
+    }
+
+    public Generic evalnum() {
+        return ((NumericWrapper)parameter[0]).conjugate();
+    }
+
+    public String toJava() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append(parameter[0].toJava());
+        buffer.append(".conjugate()");
+        return buffer.toString();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) bodyToMathML(element);
+        else {
+            MathML e1=element.element("msup");
+            MathML e2=element.element("mfenced");
+            bodyToMathML(e2);
+            e1.appendChild(e2);
+            e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+
+    void bodyToMathML(MathML element) {
+        MathML e1=element.element("mover");
+        parameter[0].toMathML(e1,null);
+        MathML e2=element.element("mo");
+        e2.appendChild(element.text("_"));
+        e1.appendChild(e2);
+        element.appendChild(e1);
+    }
+
+    protected Variable newinstance() {
+        return new Conjugate(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/Constant.java b/src/misc/src/jscl/math/function/Constant.java
new file mode 100644
index 00000000..eb87fdc4
--- /dev/null
+++ b/src/misc/src/jscl/math/function/Constant.java
@@ -0,0 +1,229 @@
+package jscl.math.function;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegrableException;
+import jscl.math.NumericWrapper;
+import jscl.math.Variable;
+import jscl.mathml.MathML;
+import jscl.util.ArrayComparator;
+
+public class Constant extends Variable {
+    public static final Generic e=new Exp(JSCLInteger.valueOf(1)).expressionValue();
+    public static final Generic pi=new Constant("pi").expressionValue();
+    public static final Generic i=new Sqrt(JSCLInteger.valueOf(-1)).expressionValue();
+    public static final Generic half=new Inv(JSCLInteger.valueOf(2)).expressionValue();
+    public static final Generic third=new Inv(JSCLInteger.valueOf(3)).expressionValue();
+    public static final Generic j=half.negate().multiply(JSCLInteger.valueOf(1).subtract(i.multiply(new Sqrt(JSCLInteger.valueOf(3)).expressionValue())));
+    public static final Generic jbar=half.negate().multiply(JSCLInteger.valueOf(1).add(i.multiply(new Sqrt(JSCLInteger.valueOf(3)).expressionValue())));
+    public static final Generic infinity=new Constant("infin").expressionValue();
+    static final int PRIMECHARS=3;
+    protected int prime;
+    protected Generic subscript[];
+
+    public Constant(String name) {
+        this(name,0,new Generic[0]);
+    }
+
+    public Constant(String name, int prime, Generic subscript[]) {
+        super(name);
+        this.prime=prime;
+        this.subscript=subscript;
+    }
+
+    public int prime() {
+        return prime;
+    }
+
+    public Generic[] subscript() {
+        return subscript;
+    }
+
+    public Generic antiderivative(Variable variable) throws NotIntegrableException {
+        return null;
+    }
+
+    public Generic derivative(Variable variable) {
+        if(isIdentity(variable)) return JSCLInteger.valueOf(1);
+        else return JSCLInteger.valueOf(0);
+    }
+
+    public Generic substitute(Variable variable, Generic generic) {
+        Constant v=(Constant)newinstance();
+        for(int i=0;i<subscript.length;i++) {
+            v.subscript[i]=subscript[i].substitute(variable,generic);
+        }
+        if(v.isIdentity(variable)) return generic;
+        else return v.expressionValue();
+    }
+
+    public Generic expand() {
+        Constant v=(Constant)newinstance();
+        for(int i=0;i<subscript.length;i++) {
+            v.subscript[i]=subscript[i].expand();
+        }
+        return v.expressionValue();
+    }
+
+    public Generic factorize() {
+        Constant v=(Constant)newinstance();
+        for(int i=0;i<subscript.length;i++) {
+            v.subscript[i]=subscript[i].factorize();
+        }
+        return v.expressionValue();
+    }
+
+    public Generic elementary() {
+        Constant v=(Constant)newinstance();
+        for(int i=0;i<subscript.length;i++) {
+            v.subscript[i]=subscript[i].elementary();
+        }
+        return v.expressionValue();
+    }
+
+    public Generic simplify() {
+        Constant v=(Constant)newinstance();
+        for(int i=0;i<subscript.length;i++) {
+            v.subscript[i]=subscript[i].simplify();
+        }
+        return v.expressionValue();
+    }
+
+    public Generic numeric() {
+        return new NumericWrapper(this);
+    }
+
+    public boolean isConstant(Variable variable) {
+        return !isIdentity(variable);
+    }
+
+    public int compareTo(Variable variable) {
+        if(this==variable) return 0;
+        int c=comparator.compare(this,variable);
+        if(c<0) return -1;
+        else if(c>0) return 1;
+        else {
+            Constant v=(Constant)variable;
+            c=name.compareTo(v.name);
+            if(c<0) return -1;
+            else if(c>0) return 1;
+            else {
+                c=ArrayComparator.comparator.compare(subscript,v.subscript);
+                if(c<0) return -1;
+                else if(c>0) return 1;
+                else {
+                    if(prime<v.prime) return -1;
+                    else if(prime>v.prime) return 1;
+                    else return 0;
+                }
+            }
+        }
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append(name);
+        for(int i=0;i<subscript.length;i++) {
+            buffer.append("[").append(subscript[i]).append("]");
+        }
+        if(prime==0);
+        else if(prime<=PRIMECHARS) buffer.append(primechars(prime));
+        else buffer.append("{").append(prime).append("}");
+        return buffer.toString();
+    }
+
+    static String primechars(int n) {
+        StringBuffer buffer=new StringBuffer();
+        for(int i=0;i<n;i++) buffer.append("'");
+        return buffer.toString();
+    }
+
+    public String toJava() {
+        if(compareTo(new Constant("pi"))==0) return "JSCLDouble.valueOf(Math.PI)";
+        else if(compareTo(new Constant("infin"))==0) return "JSCLDouble.valueOf(Double.POSITIVE_INFINITY)";
+        StringBuffer buffer=new StringBuffer();
+        buffer.append(name);
+        if(prime==0);
+        else if(prime<=PRIMECHARS) buffer.append(underscores(prime));
+        else buffer.append("_").append(prime);
+        for(int i=0;i<subscript.length;i++) {
+            buffer.append("[").append(subscript[i].integerValue().intValue()).append("]");
+        }
+        return buffer.toString();
+    }
+
+    static String underscores(int n) {
+        StringBuffer buffer=new StringBuffer();
+        for(int i=0;i<n;i++) buffer.append("_");
+        return buffer.toString();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) bodyToMathML(element);
+        else {
+            MathML e1=element.element("msup");
+            bodyToMathML(e1);
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+
+    public void bodyToMathML(MathML element) {
+        if(subscript.length==0) {
+            if(prime==0) {
+                nameToMathML(element);
+            } else {
+                MathML e1=element.element("msup");
+                nameToMathML(e1);
+                primeToMathML(e1);
+                element.appendChild(e1);
+            }
+        } else {
+            if(prime==0) {
+                MathML e1=element.element("msub");
+                nameToMathML(e1);
+                MathML e2=element.element("mrow");
+                for(int i=0;i<subscript.length;i++) {
+                    subscript[i].toMathML(e2,null);
+                }
+                e1.appendChild(e2);
+                element.appendChild(e1);
+            } else {
+                MathML e1=element.element("msubsup");
+                nameToMathML(e1);
+                MathML e2=element.element("mrow");
+                for(int i=0;i<subscript.length;i++) {
+                    subscript[i].toMathML(e2,null);
+                }
+                e1.appendChild(e2);
+                primeToMathML(e1);
+                element.appendChild(e1);
+            }
+        }
+    }
+
+    void primeToMathML(MathML element) {
+        if(prime<=PRIMECHARS) {
+            primecharsToMathML(element,prime);
+        } else {
+            MathML e1=element.element("mfenced");
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(prime)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+
+    static void primecharsToMathML(MathML element, int n) {
+        MathML e1=element.element("mo");
+        for(int i=0;i<n;i++) e1.appendChild(element.text("\u2032"));
+        element.appendChild(e1);
+    }
+
+    protected Variable newinstance() {
+        return new Constant(name,prime,new Generic[subscript.length]);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/Cubic.java b/src/misc/src/jscl/math/function/Cubic.java
new file mode 100644
index 00000000..51a1d657
--- /dev/null
+++ b/src/misc/src/jscl/math/function/Cubic.java
@@ -0,0 +1,96 @@
+package jscl.math.function;
+
+import jscl.math.Antiderivative;
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegerException;
+import jscl.math.NotIntegrableException;
+import jscl.math.NumericWrapper;
+import jscl.math.Variable;
+import jscl.mathml.MathML;
+
+public class Cubic extends Algebraic {
+    public Cubic(Generic generic) {
+        super("cubic",new Generic[] {generic});
+    }
+
+    public Root rootValue() {
+        return new Root(
+            new Generic[] {
+                parameter[0].negate(),
+                JSCLInteger.valueOf(0),
+                JSCLInteger.valueOf(0),
+                JSCLInteger.valueOf(1)
+            },
+            0
+        );
+    }
+
+    public Generic antiderivative(Variable variable) throws NotIntegrableException {
+        Root r=rootValue();
+        Generic g[]=r.parameters();
+        if(g[0].isPolynomial(variable)) {
+            return Antiderivative.compute(r,variable);
+        } else throw new NotIntegrableException();
+    }
+
+    public Generic derivative(int n) {
+        return Constant.third.multiply(
+            new Inv(
+                evaluate().pow(2)
+            ).evaluate()
+        );
+    }
+
+    public Generic evaluate() {
+        try {
+            JSCLInteger en=parameter[0].integerValue();
+            if(en.signum()<0);
+            else {
+                Generic rt=en.nthrt(3);
+                if(rt.pow(3).compareTo(en)==0) return rt;
+            }
+        } catch (NotIntegerException e) {}
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return evaluate();
+    }
+
+    public Generic evalsimp() {
+        try {
+            JSCLInteger en=parameter[0].integerValue();
+            if(en.signum()<0) return new Cubic(en.negate()).evalsimp().negate();
+            else {
+                Generic rt=en.nthrt(3);
+                if(rt.pow(3).compareTo(en)==0) return rt;
+            }
+        } catch (NotIntegerException e) {}
+        return expressionValue();
+    }
+
+    public Generic evalnum() {
+        return ((NumericWrapper)parameter[0]).nthrt(3);
+    }
+
+    public String toJava() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append(parameter[0].toJava());
+        buffer.append(".pow(");
+        buffer.append(Constant.third.toJava());
+        buffer.append(")");
+        return buffer.toString();
+    }
+
+    void bodyToMathML(MathML element, boolean fenced) {
+        MathML e1=element.element("mroot");
+        parameter[0].toMathML(e1,null);
+        JSCLInteger.valueOf(3).toMathML(e1,null);
+        element.appendChild(e1);
+    }
+
+    protected Variable newinstance() {
+        return new Cubic(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/Exp.java b/src/misc/src/jscl/math/function/Exp.java
new file mode 100644
index 00000000..0e7be2f8
--- /dev/null
+++ b/src/misc/src/jscl/math/function/Exp.java
@@ -0,0 +1,121 @@
+package jscl.math.function;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegrableException;
+import jscl.math.NotVariableException;
+import jscl.math.NumericWrapper;
+import jscl.math.Variable;
+import jscl.math.polynomial.Polynomial;
+import jscl.mathml.MathML;
+
+public class Exp extends Function {
+    public Exp(Generic generic) {
+        super("exp",new Generic[] {generic});
+    }
+
+    public Generic antiderivative(Variable variable) throws NotIntegrableException {
+        Generic s=parameter[0];
+        if(s.isPolynomial(variable)) {
+            Polynomial p=Polynomial.factory(variable).valueof(s);
+            if(p.degree()==1) {
+                Generic a[]=p.elements();
+                return new Inv(a[1]).evaluate().multiply(antiderivative(0));
+            } else throw new NotIntegrableException();
+        } else throw new NotIntegrableException();
+    }
+
+    public Generic antiderivative(int n) throws NotIntegrableException {
+        return evaluate();
+    }
+
+    public Generic derivative(int n) {
+        return evaluate();
+    }
+
+    public Generic evaluate() {
+        if(parameter[0].signum()<0) {
+            return new Inv(new Exp(parameter[0].negate()).evaluate()).evaluate();
+        } else if(parameter[0].signum()==0) {
+            return JSCLInteger.valueOf(1);
+        }
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return evaluate();
+    }
+
+    public Generic evalsimp() {
+        if(parameter[0].signum()<0) {
+            return new Inv(new Exp(parameter[0].negate()).evalsimp()).evalsimp();
+        } else if(parameter[0].signum()==0) {
+            return JSCLInteger.valueOf(1);
+        } else if(parameter[0].compareTo(Constant.i.multiply(Constant.pi))==0) {
+            return JSCLInteger.valueOf(-1);
+        }
+        try {
+            Variable v=parameter[0].variableValue();
+            if(v instanceof Log) {
+                Generic g[]=((Log)v).parameters();
+                return g[0];
+            }
+        } catch (NotVariableException e) {
+            Generic a[]=parameter[0].sumValue();
+            if(a.length>1) {
+                Generic s=JSCLInteger.valueOf(1);
+                for(int i=0;i<a.length;i++) {
+                    s=s.multiply(new Exp(a[i]).evalsimp());
+                }
+                return s;
+            }
+        }
+        Generic n[]=Frac.separateCoefficient(parameter[0]);
+        if(n[0].compareTo(JSCLInteger.valueOf(1))==0 && n[1].compareTo(JSCLInteger.valueOf(1))==0);
+        else return new Pow(
+            new Exp(n[2]).evalsimp(),
+            new Frac(n[0],n[1]).evalsimp()
+        ).evalsimp();
+        return expressionValue();
+    }
+
+    public Generic evalnum() {
+        return ((NumericWrapper)parameter[0]).exp();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) bodyToMathML(element,false);
+        else {
+            MathML e1=element.element("msup");
+            bodyToMathML(e1,true);
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+
+    void bodyToMathML(MathML element, boolean fenced) {
+        if(fenced) {
+            MathML e1=element.element("mfenced");
+            bodyToMathML(e1);
+            element.appendChild(e1);
+        } else {
+            bodyToMathML(element);
+        }
+    }
+
+    void bodyToMathML(MathML element) {
+        MathML e1=element.element("msup");
+        MathML e2=element.element("mi");
+        e2.appendChild(element.text(/*"\u2147"*/"e"));
+        e1.appendChild(e2);
+        parameter[0].toMathML(e1,null);
+        element.appendChild(e1);
+    }
+    
+    protected Variable newinstance() {
+        return new Exp(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/Frac.java b/src/misc/src/jscl/math/function/Frac.java
new file mode 100644
index 00000000..96bf63e8
--- /dev/null
+++ b/src/misc/src/jscl/math/function/Frac.java
@@ -0,0 +1,162 @@
+package jscl.math.function;
+
+import jscl.math.Antiderivative;
+import jscl.math.Generic;
+import jscl.math.GenericVariable;
+import jscl.math.JSCLInteger;
+import jscl.math.NotDivisibleException;
+import jscl.math.NotExpressionException;
+import jscl.math.NotIntegerException;
+import jscl.math.NotIntegrableException;
+import jscl.math.NotPowerException;
+import jscl.math.NotVariableException;
+import jscl.math.NumericWrapper;
+import jscl.math.Variable;
+import jscl.mathml.MathML;
+
+public class Frac extends Algebraic {
+    public Frac(Generic numerator, Generic denominator) {
+        super("frac",new Generic[] {numerator,denominator});
+    }
+
+    public Root rootValue() {
+        return new Root(
+            new Generic[] {
+                parameter[0].negate(),
+                parameter[1]
+            },
+            0
+        );
+    }
+
+    public Generic antiderivative(Variable variable) throws NotIntegrableException {
+        if(parameter[0].isPolynomial(variable) && parameter[1].isPolynomial(variable)) {
+            return Antiderivative.compute(this,variable);
+        } else throw new NotIntegrableException();
+    }
+
+    public Generic derivative(int n) {
+        if(n==0) {
+            return new Inv(parameter[1]).evaluate();
+        } else {
+            return parameter[0].multiply(new Inv(parameter[1]).evaluate().pow(2).negate());
+        }
+    }
+
+    public boolean integer() {
+        try {
+            parameter[0].integerValue().intValue();
+            parameter[1].integerValue().intValue();
+            return true;
+        } catch (NotIntegerException e) {}
+        return false;
+    }
+
+    public Generic evaluate() {
+        if(parameter[0].compareTo(JSCLInteger.valueOf(1))==0) {
+            return new Inv(parameter[1]).evaluate();
+        }
+        try {
+            return parameter[0].divide(parameter[1]);
+        } catch (NotDivisibleException e) {}
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return evaluate();
+    }
+
+    public Generic evalsimp() {
+        if(parameter[0].signum()<0) {
+            return new Frac(parameter[0].negate(),parameter[1]).evalsimp().negate();
+        }
+        if(parameter[1].signum()<0) {
+            return new Frac(parameter[0].negate(),parameter[1].negate()).evalsimp();
+        }
+        return evaluate();
+    }
+
+    public Generic evalnum() {
+        return ((NumericWrapper)parameter[0]).divide((NumericWrapper)parameter[1]);
+    }
+
+    static Generic[] separateCoefficient(Generic generic) {
+        if(generic.signum()<0) {
+            Generic n[]=separateCoefficient(generic.negate());
+            return new Generic[] {n[0],n[1],n[2].negate()};
+        }
+        try {
+            Variable v=generic.variableValue();
+            if(v instanceof Frac) {
+                Generic g[]=((Frac)v).parameters();
+                Generic a=g[0].expressionValue();
+                Generic d=g[1].expressionValue();
+                Generic na[]=a.gcdAndNormalize();
+                Generic nd[]=d.gcdAndNormalize();
+                return new Generic[] {na[0],nd[0],new Frac(na[1],nd[1]).evaluate()};
+            }
+        } catch (NotVariableException e) {
+            try {
+                Generic a=generic.expressionValue();
+                Generic n[]=a.gcdAndNormalize();
+                return new Generic[] {n[0],JSCLInteger.valueOf(1),n[1]};
+            } catch (NotExpressionException e2) {}
+        }
+        return new Generic[] {JSCLInteger.valueOf(1),JSCLInteger.valueOf(1),generic};
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        try {
+            parameter[0].powerValue();
+            buffer.append(parameter[0]);
+        } catch (NotPowerException e) {
+            buffer.append(GenericVariable.valueOf(parameter[0]));
+        }
+        buffer.append("/");
+        try {
+            Variable v=parameter[1].variableValue();
+            if(v instanceof Frac) {
+                buffer.append(GenericVariable.valueOf(parameter[1]));
+            } else buffer.append(v);
+        } catch (NotVariableException e) {
+            try {
+                parameter[1].abs().powerValue();
+                buffer.append(parameter[1]);
+            } catch (NotPowerException e2) {
+                buffer.append(GenericVariable.valueOf(parameter[1]));
+            }
+        }
+        return buffer.toString();
+    }
+
+    public String toJava() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append(parameter[0].toJava());
+        buffer.append(".divide(");
+        buffer.append(parameter[1].toJava());
+        buffer.append(")");
+        return buffer.toString();
+    }
+
+    void bodyToMathML(MathML element, boolean fenced) {
+        if(fenced) {
+            MathML e1=element.element("mfenced");
+            bodyToMathML(e1);
+            element.appendChild(e1);
+        } else {
+            bodyToMathML(element);
+        }
+    }
+
+    void bodyToMathML(MathML element) {
+        MathML e1=element.element("mfrac");
+        parameter[0].toMathML(e1,null);
+        parameter[1].toMathML(e1,null);
+        element.appendChild(e1);
+    }
+
+    protected Variable newinstance() {
+        return new Frac(null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/Function.java b/src/misc/src/jscl/math/function/Function.java
new file mode 100644
index 00000000..5d418386
--- /dev/null
+++ b/src/misc/src/jscl/math/function/Function.java
@@ -0,0 +1,166 @@
+package jscl.math.function;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegrableException;
+import jscl.math.Variable;
+import jscl.mathml.MathML;
+import jscl.util.ArrayComparator;
+
+public abstract class Function extends Variable {
+    protected Generic parameter[];
+
+    public Function(String name, Generic parameter[]) {
+        super(name);
+        this.parameter=parameter;
+    }
+
+    public Generic[] parameters() {
+        return parameter;
+    }
+
+    public abstract Generic evaluate();
+
+    public abstract Generic evalelem();
+
+    public abstract Generic evalsimp();
+
+    public abstract Generic evalnum();
+
+    public Generic antiderivative(Variable variable) throws NotIntegrableException {
+        int n=-1;
+        for(int i=0;i<parameter.length;i++) {
+            if(n==-1 && parameter[i].isIdentity(variable)) n=i;
+            else if(parameter[i].isConstant(variable));
+            else {
+                n=-1;
+                break;
+            }
+        }
+        if(n<0) throw new NotIntegrableException();
+        else return antiderivative(n);
+    }
+
+    public abstract Generic antiderivative(int n) throws NotIntegrableException;
+
+    public Generic derivative(Variable variable) {
+        if(isIdentity(variable)) return JSCLInteger.valueOf(1);
+        else {
+            Generic a=JSCLInteger.valueOf(0);
+            for(int i=0;i<parameter.length;i++) {
+                a=a.add(parameter[i].derivative(variable).multiply(derivative(i)));
+            }
+            return a;
+        }
+    }
+
+    public abstract Generic derivative(int n);
+
+    public Generic substitute(Variable variable, Generic generic) {
+        Function v=(Function)newinstance();
+        for(int i=0;i<parameter.length;i++) {
+            v.parameter[i]=parameter[i].substitute(variable,generic);
+        }
+        if(v.isIdentity(variable)) return generic;
+        else return v.evaluate();
+    }
+
+    public Generic expand() {
+        Function v=(Function)newinstance();
+        for(int i=0;i<parameter.length;i++) {
+            v.parameter[i]=parameter[i].expand();
+        }
+        return v.evaluate();
+    }
+
+    public Generic factorize() {
+        Function v=(Function)newinstance();
+        for(int i=0;i<parameter.length;i++) {
+            v.parameter[i]=parameter[i].factorize();
+        }
+        return v.expressionValue();
+    }
+
+    public Generic elementary() {
+        Function v=(Function)newinstance();
+        for(int i=0;i<parameter.length;i++) {
+            v.parameter[i]=parameter[i].elementary();
+        }
+        return v.evalelem();
+    }
+
+    public Generic simplify() {
+        Function v=(Function)newinstance();
+        for(int i=0;i<parameter.length;i++) {
+            v.parameter[i]=parameter[i].simplify();
+        }
+        return v.evalsimp();
+    }
+
+    public Generic numeric() {
+        Function v=(Function)newinstance();
+        for(int i=0;i<parameter.length;i++) {
+            v.parameter[i]=parameter[i].numeric();
+        }
+        return v.evalnum();
+    }
+
+    public boolean isConstant(Variable variable) {
+        boolean s=!isIdentity(variable);
+        for(int i=0;i<parameter.length;i++) {
+            s=s && parameter[i].isConstant(variable);
+        }
+        return s;
+    }
+
+    public int compareTo(Variable variable) {
+        if(this==variable) return 0;
+        int c=comparator.compare(this,variable);
+        if(c<0) return -1;
+        else if(c>0) return 1;
+        else {
+            Function v=(Function)variable;
+            c=name.compareTo(v.name);
+            if(c<0) return -1;
+            else if(c>0) return 1;
+            else return ArrayComparator.comparator.compare(parameter,v.parameter);
+        }
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append(name);
+        buffer.append("(");
+        for(int i=0;i<parameter.length;i++) {
+            buffer.append(parameter[i]).append(i<parameter.length-1?", ":"");
+        }
+        buffer.append(")");
+        return buffer.toString();
+    }
+
+    public String toJava() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append(parameter[0].toJava());
+        buffer.append(".").append(name).append("()");
+        return buffer.toString();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        MathML e1;
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) nameToMathML(element);
+        else {
+            e1=element.element("msup");
+            nameToMathML(e1);
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+        e1=element.element("mfenced");
+        for(int i=0;i<parameter.length;i++) {
+            parameter[i].toMathML(e1,null);
+        }
+        element.appendChild(e1);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/ImplicitFunction.java b/src/misc/src/jscl/math/function/ImplicitFunction.java
new file mode 100644
index 00000000..18108e27
--- /dev/null
+++ b/src/misc/src/jscl/math/function/ImplicitFunction.java
@@ -0,0 +1,223 @@
+package jscl.math.function;
+
+import jscl.math.Generic;
+import jscl.math.NotIntegrableException;
+import jscl.math.Variable;
+import jscl.mathml.MathML;
+import jscl.util.ArrayComparator;
+
+public class ImplicitFunction extends Function {
+    protected int derivation[];
+    protected Generic subscript[];
+
+    public ImplicitFunction(String name, Generic parameter[], int derivation[], Generic subscript[]) {
+        super(name,parameter);
+        this.derivation=derivation;
+        this.subscript=subscript;
+    }
+
+    public int[] derivation() {
+        return derivation;
+    }
+
+    public Generic[] subscript() {
+        return subscript;
+    }
+
+    public Generic antiderivative(int n) throws NotIntegrableException {
+        int c[]=new int[derivation.length];
+        for(int i=0;i<c.length;i++) {
+            if(i==n) {
+                if(derivation[i]>0) c[i]=derivation[i]-1;
+                else throw new NotIntegrableException();
+            } else c[i]=derivation[i];
+        }
+        return new ImplicitFunction(name,parameter,c,subscript).evaluate();
+    }
+
+    public Generic derivative(int n) {
+        int c[]=new int[derivation.length];
+        for(int i=0;i<c.length;i++) {
+            if(i==n) c[i]=derivation[i]+1;
+            else c[i]=derivation[i];
+        }
+        return new ImplicitFunction(name,parameter,c,subscript).evaluate();
+    }
+
+    public Generic evaluate() {
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return expressionValue();
+    }
+
+    public Generic evalsimp() {
+        return expressionValue();
+    }
+
+    public Generic evalnum() {
+        throw new ArithmeticException();
+    }
+
+    public int compareTo(Variable variable) {
+        if(this==variable) return 0;
+        int c=comparator.compare(this,variable);
+        if(c<0) return -1;
+        else if(c>0) return 1;
+        else {
+            ImplicitFunction v=(ImplicitFunction)variable;
+            c=name.compareTo(v.name);
+            if(c<0) return -1;
+            else if(c>0) return 1;
+            else {
+                c=ArrayComparator.comparator.compare(subscript,v.subscript);
+                if(c<0) return -1;
+                else if(c>0) return 1;
+                else {
+                    c=compareDerivation(derivation,v.derivation);
+                    if(c<0) return -1;
+                    else if(c>0) return 1;
+                    else return ArrayComparator.comparator.compare(parameter,v.parameter);
+                }
+            }
+        }
+    }
+
+    static int compareDerivation(int c1[], int c2[]) {
+        int n=c1.length;
+        for(int i=n-1;i>=0;i--) {
+            if(c1[i]<c2[i]) return -1;
+            else if(c1[i]>c2[i]) return 1;
+        }
+        return 0;
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        int n=0;
+        for(int i=0;i<derivation.length;i++) n+=derivation[i];
+        buffer.append(name);
+        for(int i=0;i<subscript.length;i++) {
+            buffer.append("[").append(subscript[i]).append("]");
+        }
+        if(n==0);
+        else if(parameter.length==1?n<=Constant.PRIMECHARS:false) buffer.append(Constant.primechars(n));
+        else buffer.append(derivationToString());
+        buffer.append("(");
+        for(int i=0;i<parameter.length;i++) {
+            buffer.append(parameter[i]).append(i<parameter.length-1?", ":"");
+        }
+        buffer.append(")");
+        return buffer.toString();
+    }
+
+    String derivationToString() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append("{");
+        for(int i=0;i<derivation.length;i++) {
+            buffer.append(derivation[i]).append(i<derivation.length-1?", ":"");
+        }
+        buffer.append("}");
+        return buffer.toString();
+    }
+
+    public String toJava() {
+        StringBuffer buffer=new StringBuffer();
+        int n=0;
+        for(int i=0;i<derivation.length;i++) n+=derivation[i];
+        buffer.append(name);
+        if(n==0);
+        else if(parameter.length==1?n<=Constant.PRIMECHARS:false) buffer.append(Constant.underscores(n));
+        else buffer.append(derivationToJava());
+        buffer.append("(");
+        for(int i=0;i<parameter.length;i++) {
+            buffer.append(parameter[i].toJava()).append(i<parameter.length-1?", ":"");
+        }
+        buffer.append(")");
+        for(int i=0;i<subscript.length;i++) {
+            buffer.append("[").append(subscript[i].integerValue().intValue()).append("]");
+        }
+        return buffer.toString();
+    }
+
+    String derivationToJava() {
+        StringBuffer buffer=new StringBuffer();
+        for(int i=0;i<derivation.length;i++) {
+            buffer.append("_").append(derivation[i]);
+        }
+        return buffer.toString();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        MathML e1;
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) bodyToMathML(element);
+        else {
+            e1=element.element("msup");
+            bodyToMathML(e1);
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+        e1=element.element("mfenced");
+        for(int i=0;i<parameter.length;i++) {
+            parameter[i].toMathML(e1,null);
+        }
+        element.appendChild(e1);
+    }
+
+    void bodyToMathML(MathML element) {
+        int n=0;
+        for(int i=0;i<derivation.length;i++) n+=derivation[i];
+        if(subscript.length==0) {
+            if(n==0) {
+                nameToMathML(element);
+            } else {
+                MathML e1=element.element("msup");
+                nameToMathML(e1);
+                derivationToMathML(e1,n);
+                element.appendChild(e1);
+            }
+        } else {
+            if(n==0) {
+                MathML e1=element.element("msub");
+                nameToMathML(e1);
+                MathML e2=element.element("mrow");
+                for(int i=0;i<subscript.length;i++) {
+                    subscript[i].toMathML(e2,null);
+                }
+                e1.appendChild(e2);
+                element.appendChild(e1);
+            } else {
+                MathML e1=element.element("msubsup");
+                nameToMathML(e1);
+                MathML e2=element.element("mrow");
+                for(int i=0;i<subscript.length;i++) {
+                    subscript[i].toMathML(e2,null);
+                }
+                e1.appendChild(e2);
+                derivationToMathML(e1,n);
+                element.appendChild(e1);
+            }
+        }
+    }
+
+    void derivationToMathML(MathML element, int n) {
+        if(parameter.length==1?n<=Constant.PRIMECHARS:false) Constant.primecharsToMathML(element,n);
+        else {
+            MathML e1=element.element("mfenced");
+            for(int i=0;i<derivation.length;i++) {
+                MathML e2=element.element("mn");
+                e2.appendChild(element.text(String.valueOf(derivation[i])));
+                e1.appendChild(e2);
+            }
+            element.appendChild(e1);
+        }
+    }
+
+    protected Variable newinstance() {
+        return new ImplicitFunction(name,new Generic[parameter.length],derivation,subscript);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/Inv.java b/src/misc/src/jscl/math/function/Inv.java
new file mode 100644
index 00000000..352be12f
--- /dev/null
+++ b/src/misc/src/jscl/math/function/Inv.java
@@ -0,0 +1,27 @@
+package jscl.math.function;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotDivisibleException;
+import jscl.math.Variable;
+
+public class Inv extends Frac {
+    public Inv(Generic generic) {
+        super(JSCLInteger.valueOf(1),generic);
+    }
+
+    public Generic evaluate() {
+        try {
+            return JSCLInteger.valueOf(1).divide(parameter());
+        } catch (NotDivisibleException e) {}
+        return expressionValue();
+    }
+
+    public Generic parameter() {
+        return parameter[1];
+    }
+
+    protected Variable newinstance() {
+        return new Inv(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/Log.java b/src/misc/src/jscl/math/function/Log.java
new file mode 100644
index 00000000..f1f9f67c
--- /dev/null
+++ b/src/misc/src/jscl/math/function/Log.java
@@ -0,0 +1,75 @@
+package jscl.math.function;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegerException;
+import jscl.math.NotIntegrableException;
+import jscl.math.NotVariableException;
+import jscl.math.NumericWrapper;
+import jscl.math.Power;
+import jscl.math.Variable;
+
+public class Log extends Function {
+    public Log(Generic generic) {
+        super("log",new Generic[] {generic});
+    }
+
+    public Generic antiderivative(int n) throws NotIntegrableException {
+        throw new NotIntegrableException();
+    }
+
+    public Generic derivative(int n) {
+        return new Inv(parameter[0]).evaluate();
+    }
+
+    public Generic evaluate() {
+        if(parameter[0].compareTo(JSCLInteger.valueOf(1))==0) {
+            return JSCLInteger.valueOf(0);
+        }
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return evaluate();
+    }
+
+    public Generic evalsimp() {
+        try {
+            JSCLInteger en=parameter[0].integerValue();
+            if(en.signum()<0) return Constant.i.multiply(Constant.pi).add(new Log(en.negate()).evalsimp());
+            else {
+                Generic a=en.factorize();
+                Generic p[]=a.productValue();
+                Generic s=JSCLInteger.valueOf(0);
+                for(int i=0;i<p.length;i++) {
+                    Power o=p[i].powerValue();
+                    s=s.add(JSCLInteger.valueOf(o.exponent()).multiply(new Log(o.value(true)).expressionValue()));
+                }
+                return s;
+            }
+        } catch (NotIntegerException e) {}
+        try {
+            Variable v=parameter[0].variableValue();
+            if(v instanceof Sqrt) {
+                Generic g[]=((Sqrt)v).parameters();
+                return Constant.half.multiply(new Log(g[0]).evalsimp());
+            }
+        } catch (NotVariableException e) {}
+        Generic n[]=Frac.separateCoefficient(parameter[0]);
+        if(n[0].compareTo(JSCLInteger.valueOf(1))==0 && n[1].compareTo(JSCLInteger.valueOf(1))==0);
+        else return new Log(n[2]).evalsimp().add(
+            new Log(n[0]).evalsimp()
+        ).subtract(
+            new Log(n[1]).evalsimp()
+        );
+        return expressionValue();
+    }
+
+    public Generic evalnum() {
+        return ((NumericWrapper)parameter[0]).log();
+    }
+
+    protected Variable newinstance() {
+        return new Log(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/NotRootException.java b/src/misc/src/jscl/math/function/NotRootException.java
new file mode 100644
index 00000000..2d77a448
--- /dev/null
+++ b/src/misc/src/jscl/math/function/NotRootException.java
@@ -0,0 +1,9 @@
+package jscl.math.function;
+
+public class NotRootException extends ArithmeticException {
+        public NotRootException() {}
+
+        public NotRootException(String s) {
+                super(s);
+        }
+}
diff --git a/src/misc/src/jscl/math/function/Pow.java b/src/misc/src/jscl/math/function/Pow.java
new file mode 100644
index 00000000..779de746
--- /dev/null
+++ b/src/misc/src/jscl/math/function/Pow.java
@@ -0,0 +1,264 @@
+package jscl.math.function;
+
+import jscl.math.Antiderivative;
+import jscl.math.Generic;
+import jscl.math.GenericVariable;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegerException;
+import jscl.math.NotIntegrableException;
+import jscl.math.NotPowerException;
+import jscl.math.NotVariableException;
+import jscl.math.NumericWrapper;
+import jscl.math.Power;
+import jscl.math.Variable;
+import jscl.mathml.MathML;
+
+public class Pow extends Algebraic {
+    public Pow(Generic generic, Generic exponent) {
+        super("pow",new Generic[] {generic,exponent});
+    }
+
+    public Root rootValue() throws NotRootException {
+        try {
+            Variable v=parameter[1].variableValue();
+            if(v instanceof Inv) {
+                Generic g=((Inv)v).parameter();
+                try {
+                    int d=g.integerValue().intValue();
+                    if(d>0) {
+                        Generic a[]=new Generic[d+1];
+                        a[0]=parameter[0].negate();
+                        for(int i=1;i<d;i++) a[i]=JSCLInteger.valueOf(0);
+                        a[d]=JSCLInteger.valueOf(1);
+                        return new Root(a,0);
+                    }
+                } catch (NotIntegerException e) {}
+            }
+        } catch (NotVariableException e) {}
+        throw new NotRootException();
+    }
+
+    public Generic antiderivative(Variable variable) throws NotIntegrableException {
+        try {
+            Root r=rootValue();
+            Generic g[]=r.parameters();
+            if(g[0].isPolynomial(variable)) {
+                return Antiderivative.compute(r,variable);
+            } else throw new NotIntegrableException();
+        } catch (NotRootException e) {}
+        return super.antiderivative(variable);
+    }
+
+    public Generic antiderivative(int n) throws NotIntegrableException {
+        if(n==0) {
+            return new Pow(parameter[0],parameter[1].add(JSCLInteger.valueOf(1))).evaluate().multiply(new Inv(parameter[1].add(JSCLInteger.valueOf(1))).evaluate());
+        } else {
+            return new Pow(parameter[0],parameter[1]).evaluate().multiply(new Inv(new Log(parameter[0]).evaluate()).evaluate());
+        }
+    }
+
+    public Generic derivative(int n) {
+        if(n==0) {
+            return new Pow(parameter[0],parameter[1].subtract(JSCLInteger.valueOf(1))).evaluate().multiply(parameter[1]);
+        } else {
+            return new Pow(parameter[0],parameter[1]).evaluate().multiply(new Log(parameter[0]).evaluate());
+        }
+    }
+
+    public Generic evaluate() {
+        if(parameter[0].compareTo(JSCLInteger.valueOf(1))==0) {
+            return JSCLInteger.valueOf(1);
+        }
+        if(parameter[1].signum()<0) {
+            return new Pow(new Inv(parameter[0]).evaluate(),parameter[1].negate()).evaluate();
+        }
+        try {
+            int c=parameter[1].integerValue().intValue();
+            return parameter[0].pow(c);
+        } catch (NotIntegerException e) {}
+        try {
+            Root r=rootValue();
+            int d=r.degree();
+            Generic g[]=r.parameters();
+            Generic a=g[0].negate();
+            try {
+                JSCLInteger en=a.integerValue();
+                if(en.signum()<0);
+                else {
+                    Generic rt=en.nthrt(d);
+                    if(rt.pow(d).compareTo(en)==0) return rt;
+                }
+            } catch (NotIntegerException e) {}
+        } catch (NotRootException e) {}
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return new Exp(
+            new Log(
+                parameter[0]
+            ).evalelem().multiply(
+                parameter[1]
+            )
+        ).evalelem();
+    }
+
+    public Generic evalsimp() {
+        if(parameter[0].compareTo(JSCLInteger.valueOf(1))==0) {
+            return JSCLInteger.valueOf(1);
+        }
+        if(parameter[1].signum()<0) {
+            return new Pow(new Inv(parameter[0]).evalsimp(),parameter[1].negate()).evalsimp();
+        }
+        try {
+            int c=parameter[1].integerValue().intValue();
+            return parameter[0].pow(c);
+        } catch (NotIntegerException e) {}
+        try {
+            Root r=rootValue();
+            int d=r.degree();
+            Generic g[]=r.parameters();
+            Generic a=g[0].negate();
+            try {
+                JSCLInteger en=a.integerValue();
+                if(en.signum()<0);
+                else {
+                    Generic rt=en.nthrt(d);
+                    if(rt.pow(d).compareTo(en)==0) return rt;
+                }
+            } catch (NotIntegerException e) {}
+            switch(d) {
+                case 2:
+                    return new Sqrt(a).evalsimp();
+                case 3:
+                case 4:
+                case 6:
+                    if(a.compareTo(JSCLInteger.valueOf(-1))==0) return root_minus_1(d);
+            }
+        } catch (NotRootException e) {
+            Generic n[]=Frac.separateCoefficient(parameter[1]);
+            if(n[0].compareTo(JSCLInteger.valueOf(1))==0 && n[1].compareTo(JSCLInteger.valueOf(1))==0);
+            else return new Pow(
+                new Pow(
+                    new Pow(
+                        parameter[0],
+                        n[2]
+                    ).evalsimp(),
+                    new Inv(
+                        n[1]
+                    ).evalsimp()
+                ).evalsimp(),
+                n[0]
+            ).evalsimp();
+        }
+        return expressionValue();
+    }
+
+    static Generic root_minus_1(int d) {
+        switch(d) {
+            case 1:
+                return JSCLInteger.valueOf(-1);
+            case 2:
+                return Constant.i;
+            case 3:
+                return Constant.jbar.negate();
+            case 4:
+                return new Sqrt(Constant.half).expressionValue().multiply(JSCLInteger.valueOf(1).add(Constant.i));
+            case 6:
+                return Constant.half.multiply(new Sqrt(JSCLInteger.valueOf(3)).expressionValue().add(Constant.i));
+            default:
+                return null;
+        }
+    }
+
+    public Generic evalnum() {
+        return ((NumericWrapper)parameter[0]).pow((NumericWrapper)parameter[1]);
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        try {
+            JSCLInteger en=parameter[0].integerValue();
+            if(en.signum()<0) buffer.append(GenericVariable.valueOf(en,true));
+            else buffer.append(en);
+        } catch (NotIntegerException e) {
+            try {
+                Variable v=parameter[0].variableValue();
+                if(v instanceof Frac || v instanceof Pow) {
+                    buffer.append(GenericVariable.valueOf(parameter[0]));
+                } else buffer.append(v);
+            } catch (NotVariableException e2) {
+                try {
+                    Power o=parameter[0].powerValue();
+                    if(o.exponent()==1) buffer.append(o.value(true));
+                    else buffer.append(GenericVariable.valueOf(parameter[0]));
+                } catch (NotPowerException e3) {
+                    buffer.append(GenericVariable.valueOf(parameter[0]));
+                }
+            }
+        }
+        buffer.append("^");
+        try {
+            JSCLInteger en=parameter[1].integerValue();
+            buffer.append(en);
+        } catch (NotIntegerException e) {
+            try {
+                Variable v=parameter[1].variableValue();
+                if(v instanceof Frac) {
+                    buffer.append(GenericVariable.valueOf(parameter[1]));
+                } else buffer.append(v);
+            } catch (NotVariableException e2) {
+                try {
+                    parameter[1].powerValue();
+                    buffer.append(parameter[1]);
+                } catch (NotPowerException e3) {
+                    buffer.append(GenericVariable.valueOf(parameter[1]));
+                }
+            }
+        }
+        return buffer.toString();
+    }
+
+    public String toJava() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append(parameter[0].toJava());
+        buffer.append(".pow(");
+        buffer.append(parameter[1].toJava());
+        buffer.append(")");
+        return buffer.toString();
+    }
+
+    void bodyToMathML(MathML element, boolean fenced) {
+        if(fenced) {
+            MathML e1=element.element("mfenced");
+            bodyToMathML(e1);
+            element.appendChild(e1);
+        } else {
+            bodyToMathML(element);
+        }
+    }
+
+    void bodyToMathML(MathML element) {
+        MathML e1=element.element("msup");
+        try {
+            Variable v=parameter[0].variableValue();
+            if(v instanceof Frac || v instanceof Pow || v instanceof Exp) {
+                GenericVariable.valueOf(parameter[0]).toMathML(e1,null);
+            } else parameter[0].toMathML(e1,null);
+        } catch (NotVariableException e2) {
+            try {
+                Power o=parameter[0].powerValue();
+                if(o.exponent()==1) o.value(true).toMathML(e1,null);
+                else GenericVariable.valueOf(parameter[0]).toMathML(e1,null);
+            } catch (NotPowerException e3) {
+                GenericVariable.valueOf(parameter[0]).toMathML(e1,null);
+            }
+        }
+        parameter[1].toMathML(e1,null);
+        element.appendChild(e1);
+    }
+
+    protected Variable newinstance() {
+        return new Pow(null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/Root.java b/src/misc/src/jscl/math/function/Root.java
new file mode 100644
index 00000000..ab636af4
--- /dev/null
+++ b/src/misc/src/jscl/math/function/Root.java
@@ -0,0 +1,404 @@
+package jscl.math.function;
+
+import jscl.math.Antiderivative;
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegerException;
+import jscl.math.NotIntegrableException;
+import jscl.math.NumericWrapper;
+import jscl.math.TechnicalVariable;
+import jscl.math.Variable;
+import jscl.math.polynomial.Polynomial;
+import jscl.math.polynomial.UnivariatePolynomial;
+import jscl.mathml.MathML;
+import jscl.util.ArrayComparator;
+
+public class Root extends Algebraic {
+    protected Generic subscript;
+
+    public Root(Generic parameter[], Generic subscript) {
+        super("root",parameter);
+        this.subscript=subscript;
+    }
+
+    public Root(Generic parameter[], int s) {
+        this(parameter, JSCLInteger.valueOf(s));
+    }
+
+    public Root(UnivariatePolynomial polynomial, int s) {
+        this(polynomial.normalize().elements(),s);
+    }
+
+    public Generic subscript() {
+        return subscript;
+    }
+
+    public Root rootValue() {
+        return this;
+    }
+
+    public Generic antiderivative(Variable variable) throws NotIntegrableException {
+        boolean b=true;
+        for(int i=0;i<parameter.length;i++) b=b && parameter[i].isPolynomial(variable);
+        if(b) {
+            return Antiderivative.compute(this,variable);
+        } else throw new NotIntegrableException();
+    }
+
+    public Generic derivative(Variable variable) {
+        if(compareTo(variable)==0) return JSCLInteger.valueOf(1);
+        else {
+            Variable t=new TechnicalVariable("t");
+            Generic a[]=new Generic[parameter.length];
+            for(int i=0;i<parameter.length;i++) a[i]=parameter[i].derivative(variable);
+            UnivariatePolynomial fact=(UnivariatePolynomial)Polynomial.factory(this);
+            UnivariatePolynomial p=fact.valueof(parameter);
+            UnivariatePolynomial q=(UnivariatePolynomial)p.derivative().multiply(t.expressionValue()).add(fact.valueof(a));
+            UnivariatePolynomial r=(UnivariatePolynomial)Polynomial.factory(t).valueof(p.resultant(q));
+            return new Root(r.elements(),subscript).evaluate();
+        }
+    }
+
+    public Generic derivative(int n) {
+        return null;
+    }
+
+    public Generic substitute(Variable variable, Generic generic) {
+        Root v=(Root)newinstance();
+        for(int i=0;i<parameter.length;i++) {
+            v.parameter[i]=parameter[i].substitute(variable,generic);
+        }
+        v.subscript=subscript.substitute(variable,generic);
+        if(v.isIdentity(variable)) return generic;
+        else return v.evaluate();
+    }
+
+    public Generic expand() {
+        Root v=(Root)newinstance();
+        for(int i=0;i<parameter.length;i++) {
+            v.parameter[i]=parameter[i].expand();
+        }
+        v.subscript=subscript.expand();
+        return v.evaluate();
+    }
+
+    public Generic factorize() {
+        Root v=(Root)newinstance();
+        for(int i=0;i<parameter.length;i++) {
+            v.parameter[i]=parameter[i].factorize();
+        }
+        v.subscript=subscript;
+        return v.expressionValue();
+    }
+
+    public Generic elementary() {
+        Root v=(Root)newinstance();
+        for(int i=0;i<parameter.length;i++) {
+            v.parameter[i]=parameter[i].elementary();
+        }
+        v.subscript=subscript.elementary();
+        return v.evalelem();
+    }
+
+    public Generic simplify() {
+        Root v=(Root)newinstance();
+        for(int i=0;i<parameter.length;i++) {
+            v.parameter[i]=parameter[i].simplify();
+        }
+        v.subscript=subscript.simplify();
+        return v.evalsimp();
+    }
+
+    public Generic numeric() {
+        Root v=(Root)newinstance();
+        for(int i=0;i<parameter.length;i++) {
+            v.parameter[i]=parameter[i].numeric();
+        }
+        v.subscript=subscript;
+        return v.evalnum();
+    }
+
+    public Generic evaluate() {
+        if(isZero()) return JSCLInteger.valueOf(0);
+        try {
+            int s=subscript.integerValue().intValue();
+            switch(degree()) {
+            case 1:
+                return new Frac(parameter[0],parameter[1]).evaluate().negate();
+            }
+        } catch (NotIntegerException e) {}
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return evaluate();
+    }
+
+    public Generic evalsimp() {
+        if(isZero()) return JSCLInteger.valueOf(0);
+        try {
+            int s=subscript.integerValue().intValue();
+            switch(degree()) {
+            case 1:
+                return linear(parameter);
+            case 2:
+                return quadratic(parameter,s);
+            case 3:
+                return cubic(parameter,s);
+            case 4:
+                return quartic(parameter,s);
+            default:
+                if(isNth() && s==0) return nth(parameter);
+            }
+        } catch (NotIntegerException e) {}
+        return expressionValue();
+    }
+
+    boolean isZero() {
+        boolean b=degree()>0;
+        for(int i=0;i<degree();i++) b=b && parameter[i].signum()==0;
+        b=b && parameter[degree()].signum()!=0;
+        return b;
+    }
+
+    boolean isNth() {
+        boolean b=degree()>0;
+        for(int i=1;i<degree();i++) b=b && parameter[i].signum()==0;
+        b=b && parameter[degree()].signum()!=0;
+        return b;
+    }
+
+    static Generic nth(Generic parameter[]) {
+        int degree=parameter.length-1;
+        Generic a=new Frac(parameter[0],parameter[degree]).evalsimp();
+        return new Pow(
+            a.negate(),
+            new Inv(JSCLInteger.valueOf(degree)).evalsimp()
+        ).evalsimp();
+    }
+
+    static Generic linear(Generic parameter[]) {
+        Generic a=new Frac(parameter[0],parameter[1]).evalsimp();
+        return a.negate();
+    }
+
+    static Generic quadratic(Generic parameter[], int subscript) {
+        Generic a=new Frac(parameter[1],parameter[2]).evalsimp();
+        Generic b=new Frac(parameter[0],parameter[2]).evalsimp();
+        Generic y=new Sqrt(
+            a.pow(2).subtract(JSCLInteger.valueOf(4).multiply(b))
+        ).evalsimp();
+        switch(subscript) {
+        case 0:
+            return new Frac(
+                a.subtract(y),
+                JSCLInteger.valueOf(2)
+            ).evalsimp().negate();
+        default:
+            return new Frac(
+                a.add(y),
+                JSCLInteger.valueOf(2)
+            ).evalsimp().negate();
+        }
+    }
+
+    static Generic cubic(Generic parameter[], int subscript) {
+        Generic a=new Frac(parameter[2],parameter[3]).evalsimp();
+        Generic b=new Frac(parameter[1],parameter[3]).evalsimp();
+        Generic c=new Frac(parameter[0],parameter[3]).evalsimp();
+        Generic y[]=new Generic[2];
+        for(int i=0;i<y.length;i++) {
+            y[i]=new Cubic(
+                new Root(
+                    new Generic[] {
+                        a.pow(6).subtract(JSCLInteger.valueOf(9).multiply(a.pow(4)).multiply(b)).add(JSCLInteger.valueOf(27).multiply(a.pow(2)).multiply(b.pow(2))).subtract(JSCLInteger.valueOf(27).multiply(b.pow(3))),
+                        JSCLInteger.valueOf(2).multiply(a.pow(3)).subtract(JSCLInteger.valueOf(9).multiply(a).multiply(b)).add(JSCLInteger.valueOf(27).multiply(c)),
+                        JSCLInteger.valueOf(1)
+                    },
+                    i
+                ).evalsimp()
+            ).evalsimp();
+        }
+        switch(subscript) {
+        case 0:
+            return new Frac(
+                a.subtract(y[0]).subtract(y[1]),
+                JSCLInteger.valueOf(3)
+            ).evalsimp().negate();
+        case 1:
+            return new Frac(
+                a.subtract(Constant.j.multiply(y[0])).subtract(Constant.jbar.multiply(y[1])),
+                JSCLInteger.valueOf(3)
+            ).evalsimp().negate();
+        default:
+            return new Frac(
+                a.subtract(Constant.jbar.multiply(y[0])).subtract(Constant.j.multiply(y[1])),
+                JSCLInteger.valueOf(3)
+            ).evalsimp().negate();
+        }
+    }
+
+    static Generic quartic(Generic parameter[], int subscript) {
+        Generic a=new Frac(parameter[3],parameter[4]).evalsimp();
+        Generic b=new Frac(parameter[2],parameter[4]).evalsimp();
+        Generic c=new Frac(parameter[1],parameter[4]).evalsimp();
+        Generic d=new Frac(parameter[0],parameter[4]).evalsimp();
+        Generic y[]=new Generic[3];
+        for(int i=0;i<y.length;i++) {
+            y[i]=new Sqrt(
+                new Root(
+                    new Generic[] {
+                        a.pow(6).subtract(JSCLInteger.valueOf(8).multiply(a.pow(4)).multiply(b)).add(JSCLInteger.valueOf(16).multiply(a.pow(2)).multiply(b.pow(2))).add(JSCLInteger.valueOf(16).multiply(a.pow(3)).multiply(c)).subtract(JSCLInteger.valueOf(64).multiply(a).multiply(b).multiply(c)).add(JSCLInteger.valueOf(64).multiply(c.pow(2))),
+                        JSCLInteger.valueOf(-3).multiply(a.pow(4)).add(JSCLInteger.valueOf(16).multiply(a.pow(2)).multiply(b)).subtract(JSCLInteger.valueOf(16).multiply(b.pow(2))).subtract(JSCLInteger.valueOf(16).multiply(a).multiply(c)).add(JSCLInteger.valueOf(64).multiply(d)),
+                        JSCLInteger.valueOf(3).multiply(a.pow(2)).subtract(JSCLInteger.valueOf(8).multiply(b)),
+                        JSCLInteger.valueOf(-1)
+                    },
+                    i
+                ).evalsimp()
+            ).evalsimp();
+        }
+        switch(subscript) {
+        case 0:
+            return new Frac(
+                a.add(y[0]).subtract(y[1]).subtract(y[2]),
+                JSCLInteger.valueOf(4)
+            ).evalsimp().negate();
+        case 1:
+            return new Frac(
+                a.subtract(y[0]).subtract(y[1]).add(y[2]),
+                JSCLInteger.valueOf(4)
+            ).evalsimp().negate();
+        case 2:
+            return new Frac(
+                a.add(y[0]).add(y[1]).add(y[2]),
+                JSCLInteger.valueOf(4)
+            ).evalsimp().negate();
+        default:
+            return new Frac(
+                a.subtract(y[0]).add(y[1]).subtract(y[2]),
+                JSCLInteger.valueOf(4)
+            ).evalsimp().negate();
+        }
+    }
+
+    public int degree() {
+        return parameter.length-1;
+    }
+
+    public Generic evalnum() {
+        return NumericWrapper.root(subscript.integerValue().intValue(),parameter);
+    }
+
+    public int compareTo(Variable variable) {
+        if(this==variable) return 0;
+        int c=comparator.compare(this,variable);
+        if(c<0) return -1;
+        else if(c>0) return 1;
+        else {
+            Root v=(Root)variable;
+            c=ArrayComparator.comparator.compare(parameter,v.parameter);
+            if(c<0) return -1;
+            else if(c>0) return 1;
+            else return subscript.compareTo(v.subscript);
+        }
+    }
+
+    public static Generic sigma(Generic parameter[], int n) {
+        Sigma s=new Sigma(parameter,n);
+        s.compute();
+        return s.getValue();
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append(name);
+        buffer.append("[").append(subscript).append("]");
+        buffer.append("(");
+        for(int i=0;i<parameter.length;i++) {
+            buffer.append(parameter[i]).append(i<parameter.length-1?", ":"");
+        }
+        buffer.append(")");
+        return buffer.toString();
+    }
+
+    public String toJava() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append("Numeric.").append(name).append("(");
+        buffer.append(subscript.integerValue().intValue());
+        buffer.append(", new Numeric[] {");
+        for(int i=0;i<parameter.length;i++) {
+            buffer.append(parameter[i].toJava()).append(i<parameter.length-1?", ":"");
+        }
+        buffer.append("})");
+        return buffer.toString();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        MathML e1;
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) {
+            e1=element.element("msub");
+            nameToMathML(e1);
+            subscript.toMathML(e1,null);
+            element.appendChild(e1);
+        } else {
+            e1=element.element("msubsup");
+            nameToMathML(e1);
+            subscript.toMathML(e1,null);
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+        e1=element.element("mfenced");
+        for(int i=0;i<parameter.length;i++) {
+            parameter[i].toMathML(e1,null);
+        }
+        element.appendChild(e1);
+    }
+
+    void bodyToMathML(MathML element, boolean fenced) {}
+
+    protected Variable newinstance() {
+        return new Root(new Generic[parameter.length],null);
+    }
+}
+
+class Sigma {
+    Generic root[];
+    Generic generic;
+    boolean place[];
+    int n;
+
+    Sigma(Generic parameter[], int n) {
+        root=new Generic[parameter.length-1];
+        for(int i=0;i<root.length;i++) root[i]=new Root(parameter,i).expressionValue();
+        place=new boolean[root.length];
+        this.n=n;
+    }
+
+    void compute() {
+        generic=JSCLInteger.valueOf(0);
+        compute(0,n);
+    }
+
+    void compute(int p, int nn) {
+        if(nn>0) {
+            for(int i=p;i<root.length;i++) {
+                place[i]=true;
+                compute(i+1,nn-1);
+                place[i]=false;
+            }
+        } else {
+            Generic s=JSCLInteger.valueOf(1);
+            for(int i=0;i<root.length;i++) {
+                if(place[i]) s=s.multiply(root[i]);
+            }
+            generic=generic.add(s);
+        }
+    }
+
+    Generic getValue() {
+        return generic;
+    }
+}
diff --git a/src/misc/src/jscl/math/function/Sgn.java b/src/misc/src/jscl/math/function/Sgn.java
new file mode 100644
index 00000000..4105f652
--- /dev/null
+++ b/src/misc/src/jscl/math/function/Sgn.java
@@ -0,0 +1,78 @@
+package jscl.math.function;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegerException;
+import jscl.math.NotIntegrableException;
+import jscl.math.NotVariableException;
+import jscl.math.NumericWrapper;
+import jscl.math.Variable;
+
+public class Sgn extends Function {
+    public Sgn(Generic generic) {
+        super("sgn",new Generic[] {generic});
+    }
+
+    public Generic antiderivative(int n) throws NotIntegrableException {
+        return new Abs(parameter[0]).evaluate();
+    }
+
+    public Generic derivative(int n) {
+        return JSCLInteger.valueOf(0);
+    }
+
+    public Generic evaluate() {
+        if(parameter[0].signum()<0) {
+            return new Sgn(parameter[0].negate()).evaluate().negate();
+        } else if(parameter[0].signum()==0) {
+            return JSCLInteger.valueOf(1);
+        }
+        try {
+            return JSCLInteger.valueOf(parameter[0].integerValue().signum());
+        } catch (NotIntegerException e) {}
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return new Frac(
+            parameter[0],
+            new Abs(parameter[0]).evalelem()
+        ).evalelem();
+    }
+
+    public Generic evalsimp() {
+        if(parameter[0].signum()<0) {
+            return new Sgn(parameter[0].negate()).evaluate().negate();
+        } else if(parameter[0].signum()==0) {
+            return JSCLInteger.valueOf(1);
+        }
+        try {
+            return JSCLInteger.valueOf(parameter[0].integerValue().signum());
+        } catch (NotIntegerException e) {}
+        try {
+            Variable v=parameter[0].variableValue();
+            if(v instanceof Abs) {
+                return JSCLInteger.valueOf(1);
+            } else if(v instanceof Sgn) {
+                Function f=(Function)v;
+                return f.evalsimp();
+            }
+        } catch (NotVariableException e) {}
+        return expressionValue();
+    }
+
+    public Generic evalnum() {
+        return ((NumericWrapper)parameter[0]).sgn();
+    }
+
+    public String toJava() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append(parameter[0].toJava());
+        buffer.append(".sgn()");
+        return buffer.toString();
+    }
+
+    protected Variable newinstance() {
+        return new Sgn(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/Sqrt.java b/src/misc/src/jscl/math/function/Sqrt.java
new file mode 100644
index 00000000..4c9a5392
--- /dev/null
+++ b/src/misc/src/jscl/math/function/Sqrt.java
@@ -0,0 +1,123 @@
+package jscl.math.function;
+
+import jscl.math.Antiderivative;
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegerException;
+import jscl.math.NotIntegrableException;
+import jscl.math.NumericWrapper;
+import jscl.math.Power;
+import jscl.math.Variable;
+import jscl.mathml.MathML;
+
+public class Sqrt extends Algebraic {
+    public Sqrt(Generic generic) {
+        super("sqrt",new Generic[] {generic});
+    }
+
+    public Root rootValue() {
+        return new Root(
+            new Generic[] {
+                parameter[0].negate(),
+                JSCLInteger.valueOf(0),
+                JSCLInteger.valueOf(1)
+            },
+            0
+        );
+    }
+
+    public Generic antiderivative(Variable variable) throws NotIntegrableException {
+        Root r=rootValue();
+        Generic g[]=r.parameters();
+        if(g[0].isPolynomial(variable)) {
+            return Antiderivative.compute(r,variable);
+        } else throw new NotIntegrableException();
+    }
+
+    public Generic derivative(int n) {
+        return Constant.half.multiply(
+            new Inv(
+                evaluate()
+            ).evaluate()
+        );
+    }
+
+    public boolean imaginary() {
+        return parameter[0].compareTo(JSCLInteger.valueOf(-1))==0;
+    }
+
+    public Generic evaluate() {
+        try {
+            JSCLInteger en=parameter[0].integerValue();
+            if(en.signum()<0);
+            else {
+                Generic rt=en.sqrt();
+                if(rt.pow(2).compareTo(en)==0) return rt;
+            }
+        } catch (NotIntegerException e) {}
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return evaluate();
+    }
+
+    public Generic evalsimp() {
+        try {
+            JSCLInteger en=parameter[0].integerValue();
+            if(en.signum()<0) return Constant.i.multiply(new Sqrt(en.negate()).evalsimp());
+            else {
+                Generic rt=en.sqrt();
+                if(rt.pow(2).compareTo(en)==0) return rt;
+            }
+            Generic a=en.factorize();
+            Generic p[]=a.productValue();
+            Generic s=JSCLInteger.valueOf(1);
+            for(int i=0;i<p.length;i++) {
+                Power o=p[i].powerValue();
+                Generic q=o.value(true);
+                int c=o.exponent();
+                s=s.multiply(q.pow(c/2).multiply(new Sqrt(q).expressionValue().pow(c%2)));
+            }
+            return s;
+        } catch (NotIntegerException e) {
+            Generic n[]=Frac.separateCoefficient(parameter[0]);
+            if(n[0].compareTo(JSCLInteger.valueOf(1))==0 && n[1].compareTo(JSCLInteger.valueOf(1))==0);
+            else return new Sqrt(n[2]).evalsimp().multiply(
+                new Frac(
+                    new Sqrt(n[0]).evalsimp(),
+                    new Sqrt(n[1]).evalsimp()
+                ).evalsimp()
+            );
+        }
+        return expressionValue();
+    }
+
+    public Generic evalnum() {
+        return ((NumericWrapper)parameter[0]).sqrt();
+    }
+
+    public String toJava() {
+        if(parameter[0].compareTo(JSCLInteger.valueOf(-1))==0) return "Complex.valueOf(0, 1)";
+        StringBuffer buffer=new StringBuffer();
+        buffer.append(parameter[0].toJava());
+        buffer.append(".").append(name).append("()");
+        return buffer.toString();
+    }
+
+    void bodyToMathML(MathML element, boolean fenced) {
+        if(parameter[0].compareTo(JSCLInteger.valueOf(-1))==0) {
+            MathML e1=element.element("mi");
+            e1.appendChild(element.text(/*"\u2148"*/"i"));
+            element.appendChild(e1);
+        } else {
+            MathML e1=element.element("msqrt");
+            parameter[0].toMathML(e1,null);
+            element.appendChild(e1);
+        }
+    }
+
+    protected Variable newinstance() {
+        return new Sqrt(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/Trigonometric.java b/src/misc/src/jscl/math/function/Trigonometric.java
new file mode 100644
index 00000000..63a7fa5a
--- /dev/null
+++ b/src/misc/src/jscl/math/function/Trigonometric.java
@@ -0,0 +1,41 @@
+package jscl.math.function;
+
+import jscl.math.Generic;
+import jscl.math.NotIntegrableException;
+import jscl.math.Variable;
+import jscl.math.polynomial.Polynomial;
+
+public abstract class Trigonometric extends Function {
+    public Trigonometric(String name, Generic parameter[]) {
+        super(name,parameter);
+    }
+
+    public Generic antiderivative(Variable variable) throws NotIntegrableException {
+        Generic s=parameter[0];
+        if(s.isPolynomial(variable)) {
+            Polynomial p=Polynomial.factory(variable).valueof(s);
+            if(p.degree()==1) {
+                Generic a[]=p.elements();
+                return new Inv(a[1]).evaluate().multiply(antiderivative(0));
+            } else throw new NotIntegrableException();
+        } else throw new NotIntegrableException();
+    }
+
+    public Generic identity() {
+//      Generic a[]=parameter[0].sumValue();
+//      if(a.length>1) {
+//          Generic s=JSCLInteger.valueOf(0);
+//          for(int i=1;i<a.length;i++) s=s.add(a[i]);
+//          return identity(a[0],s);
+//      }
+//      Generic n[]=Frac.separateCoefficient(parameter[0]);
+//      if(n[0].compareTo(JSCLInteger.valueOf(1))==0);
+//      else {
+//          Generic s=new Frac(n[2],n[1]).evalsimp();
+//          return identity(s,n[0].subtract(JSCLInteger.valueOf(1)).multiply(s));
+//      }
+        return expressionValue();
+    }
+
+    public abstract Generic identity(Generic a, Generic b);
+}
diff --git a/src/misc/src/jscl/math/function/hyperbolic/Acosh.java b/src/misc/src/jscl/math/function/hyperbolic/Acosh.java
new file mode 100644
index 00000000..7dcebe3f
--- /dev/null
+++ b/src/misc/src/jscl/math/function/hyperbolic/Acosh.java
@@ -0,0 +1,55 @@
+package jscl.math.function.hyperbolic;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NumericWrapper;
+import jscl.math.Variable;
+import jscl.math.function.ArcTrigonometric;
+import jscl.math.function.Inv;
+import jscl.math.function.Log;
+import jscl.math.function.Root;
+import jscl.math.function.Sqrt;
+
+public class Acosh extends ArcTrigonometric {
+    public Acosh(Generic generic) {
+        super("acosh",new Generic[] {generic});
+    }
+
+    public Generic derivative(int n) {
+        return new Inv(
+            new Sqrt(
+                parameter[0].pow(2).subtract(
+                    JSCLInteger.valueOf(1)
+                )
+            ).evaluate()
+        ).evaluate();
+    }
+
+    public Generic evaluate() {
+        if(parameter[0].signum()==0) {
+            return JSCLInteger.valueOf(0);
+        }
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return new Log(
+            new Root(
+                new Generic[] {
+                    JSCLInteger.valueOf(-1),
+                    JSCLInteger.valueOf(2).multiply(parameter[0]),
+                    JSCLInteger.valueOf(-1)
+                },
+                0
+            ).evalelem()
+        ).evalelem();
+    }
+
+    public Generic evalnum() {
+        return ((NumericWrapper)parameter[0]).acosh();
+    }
+
+    protected Variable newinstance() {
+        return new Acosh(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/hyperbolic/Acoth.java b/src/misc/src/jscl/math/function/hyperbolic/Acoth.java
new file mode 100644
index 00000000..2ee3e2f4
--- /dev/null
+++ b/src/misc/src/jscl/math/function/hyperbolic/Acoth.java
@@ -0,0 +1,52 @@
+package jscl.math.function.hyperbolic;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NumericWrapper;
+import jscl.math.Variable;
+import jscl.math.function.ArcTrigonometric;
+import jscl.math.function.Inv;
+import jscl.math.function.Log;
+import jscl.math.function.Root;
+
+public class Acoth extends ArcTrigonometric {
+    public Acoth(Generic generic) {
+        super("acoth",new Generic[] {generic});
+    }
+
+    public Generic derivative(int n) {
+        return new Inv(
+            JSCLInteger.valueOf(1).subtract(
+                parameter[0].pow(2)
+            )
+        ).evaluate();
+    }
+
+    public Generic evaluate() {
+        if(parameter[0].signum()<0) {
+            return new Acoth(parameter[0].negate()).evaluate().negate();
+        }
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return new Log(
+            new Root(
+                new Generic[] {
+                    JSCLInteger.valueOf(1).add(parameter[0]),
+                    JSCLInteger.valueOf(0),
+                    JSCLInteger.valueOf(1).subtract(parameter[0])
+                },
+                0
+            ).evalelem()
+        ).evalelem();
+    }
+
+    public Generic evalnum() {
+        return ((NumericWrapper)parameter[0]).acoth();
+    }
+
+    protected Variable newinstance() {
+        return new Acoth(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/hyperbolic/Asinh.java b/src/misc/src/jscl/math/function/hyperbolic/Asinh.java
new file mode 100644
index 00000000..ac41b485
--- /dev/null
+++ b/src/misc/src/jscl/math/function/hyperbolic/Asinh.java
@@ -0,0 +1,57 @@
+package jscl.math.function.hyperbolic;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NumericWrapper;
+import jscl.math.Variable;
+import jscl.math.function.ArcTrigonometric;
+import jscl.math.function.Inv;
+import jscl.math.function.Log;
+import jscl.math.function.Root;
+import jscl.math.function.Sqrt;
+
+public class Asinh extends ArcTrigonometric {
+    public Asinh(Generic generic) {
+        super("asinh",new Generic[] {generic});
+    }
+
+    public Generic derivative(int n) {
+        return new Inv(
+            new Sqrt(
+                JSCLInteger.valueOf(1).add(
+                    parameter[0].pow(2)
+                )
+            ).evaluate()
+        ).evaluate();
+    }
+
+    public Generic evaluate() {
+        if(parameter[0].signum()<0) {
+            return new Asinh(parameter[0].negate()).evaluate().negate();
+        } else if(parameter[0].signum()==0) {
+            return JSCLInteger.valueOf(0);
+        }
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return new Log(
+            new Root(
+                new Generic[] {
+                    JSCLInteger.valueOf(1),
+                    JSCLInteger.valueOf(2).multiply(parameter[0]),
+                    JSCLInteger.valueOf(-1)
+                },
+                0
+            ).evalelem()
+        ).evalelem();
+    }
+
+    public Generic evalnum() {
+        return ((NumericWrapper)parameter[0]).asinh();
+    }
+
+    protected Variable newinstance() {
+        return new Asinh(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/hyperbolic/Atanh.java b/src/misc/src/jscl/math/function/hyperbolic/Atanh.java
new file mode 100644
index 00000000..3c3bcbc0
--- /dev/null
+++ b/src/misc/src/jscl/math/function/hyperbolic/Atanh.java
@@ -0,0 +1,54 @@
+package jscl.math.function.hyperbolic;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NumericWrapper;
+import jscl.math.Variable;
+import jscl.math.function.ArcTrigonometric;
+import jscl.math.function.Inv;
+import jscl.math.function.Log;
+import jscl.math.function.Root;
+
+public class Atanh extends ArcTrigonometric {
+    public Atanh(Generic generic) {
+        super("atanh",new Generic[] {generic});
+    }
+
+    public Generic derivative(int n) {
+        return new Inv(
+            JSCLInteger.valueOf(1).subtract(
+                parameter[0].pow(2)
+            )
+        ).evaluate();
+    }
+
+    public Generic evaluate() {
+        if(parameter[0].signum()<0) {
+            return new Atanh(parameter[0].negate()).evaluate().negate();
+        } else if(parameter[0].signum()==0) {
+            return JSCLInteger.valueOf(0);
+        }
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return new Log(
+            new Root(
+                new Generic[] {
+                    JSCLInteger.valueOf(1).add(parameter[0]),
+                    JSCLInteger.valueOf(0),
+                    JSCLInteger.valueOf(-1).add(parameter[0])
+                },
+                0
+            ).evalelem()
+        ).evalelem();
+    }
+
+    public Generic evalnum() {
+        return ((NumericWrapper)parameter[0]).atanh();
+    }
+
+    protected Variable newinstance() {
+        return new Atanh(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/hyperbolic/Cosh.java b/src/misc/src/jscl/math/function/hyperbolic/Cosh.java
new file mode 100644
index 00000000..64366626
--- /dev/null
+++ b/src/misc/src/jscl/math/function/hyperbolic/Cosh.java
@@ -0,0 +1,78 @@
+package jscl.math.function.hyperbolic;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegrableException;
+import jscl.math.NotVariableException;
+import jscl.math.NumericWrapper;
+import jscl.math.Variable;
+import jscl.math.function.Constant;
+import jscl.math.function.Exp;
+import jscl.math.function.Trigonometric;
+
+public class Cosh extends Trigonometric {
+    public Cosh(Generic generic) {
+        super("cosh",new Generic[] {generic});
+    }
+
+    public Generic antiderivative(int n) throws NotIntegrableException {
+        return new Sinh(parameter[0]).evaluate();
+    }
+
+    public Generic derivative(int n) {
+        return new Sinh(parameter[0]).evaluate();
+    }
+
+    public Generic evaluate() {
+        if(parameter[0].signum()<0) {
+            return new Cosh(parameter[0].negate()).evaluate();
+        } else if(parameter[0].signum()==0) {
+            return JSCLInteger.valueOf(1);
+        }
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return new Exp(
+            parameter[0]
+        ).evalelem().add(
+            new Exp(
+                parameter[0].negate()
+            ).evalelem()
+        ).multiply(Constant.half);
+    }
+
+    public Generic evalsimp() {
+        if(parameter[0].signum()<0) {
+            return new Cosh(parameter[0].negate()).evaluate();
+        } else if(parameter[0].signum()==0) {
+            return JSCLInteger.valueOf(1);
+        }
+        try {
+            Variable v=parameter[0].variableValue();
+            if(v instanceof Acosh) {
+                Generic g[]=((Acosh)v).parameters();
+                return g[0];
+            }
+        } catch (NotVariableException e) {}
+        return identity();
+    }
+
+    public Generic identity(Generic a, Generic b) {
+        return new Cosh(a).evalsimp().multiply(
+            new Cosh(b).evalsimp()
+        ).add(
+            new Sinh(a).evalsimp().multiply(
+                new Sinh(b).evalsimp()
+            )
+        );
+    }
+
+    public Generic evalnum() {
+        return ((NumericWrapper)parameter[0]).cosh();
+    }
+
+    protected Variable newinstance() {
+        return new Cosh(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/hyperbolic/Coth.java b/src/misc/src/jscl/math/function/hyperbolic/Coth.java
new file mode 100644
index 00000000..c0889169
--- /dev/null
+++ b/src/misc/src/jscl/math/function/hyperbolic/Coth.java
@@ -0,0 +1,76 @@
+package jscl.math.function.hyperbolic;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegrableException;
+import jscl.math.NotVariableException;
+import jscl.math.NumericWrapper;
+import jscl.math.Variable;
+import jscl.math.function.Frac;
+import jscl.math.function.Log;
+import jscl.math.function.Trigonometric;
+
+public class Coth extends Trigonometric {
+    public Coth(Generic generic) {
+        super("coth",new Generic[] {generic});
+    }
+
+    public Generic antiderivative(int n) throws NotIntegrableException {
+        return new Log(
+            JSCLInteger.valueOf(4).multiply(
+                new Sinh(parameter[0]).evaluate()
+            )
+        ).evaluate();
+    }
+
+    public Generic derivative(int n) {
+        return JSCLInteger.valueOf(1).subtract(
+            new Coth(parameter[0]).evaluate().pow(2)
+        );
+    }
+
+    public Generic evaluate() {
+        if(parameter[0].signum()<0) {
+            return new Coth(parameter[0].negate()).evaluate().negate();
+        }
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return new Frac(
+            new Cosh(parameter[0]).evalelem(),
+            new Sinh(parameter[0]).evalelem()
+        ).evalelem();
+    }
+
+    public Generic evalsimp() {
+        if(parameter[0].signum()<0) {
+            return new Coth(parameter[0].negate()).evaluate().negate();
+        }
+        try {
+            Variable v=parameter[0].variableValue();
+            if(v instanceof Acoth) {
+                Generic g[]=((Acoth)v).parameters();
+                return g[0];
+            }
+        } catch (NotVariableException e) {}
+        return identity();
+    }
+
+    public Generic identity(Generic a, Generic b) {
+        Generic ta=new Coth(a).evalsimp();
+        Generic tb=new Coth(b).evalsimp();
+        return new Frac(
+            ta.multiply(tb).add(JSCLInteger.valueOf(1)),
+                        ta.add(tb)
+        ).evalsimp();
+    }
+
+    public Generic evalnum() {
+        return ((NumericWrapper)parameter[0]).coth();
+    }
+
+    protected Variable newinstance() {
+        return new Coth(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/hyperbolic/Sinh.java b/src/misc/src/jscl/math/function/hyperbolic/Sinh.java
new file mode 100644
index 00000000..2e27bd8f
--- /dev/null
+++ b/src/misc/src/jscl/math/function/hyperbolic/Sinh.java
@@ -0,0 +1,78 @@
+package jscl.math.function.hyperbolic;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegrableException;
+import jscl.math.NotVariableException;
+import jscl.math.NumericWrapper;
+import jscl.math.Variable;
+import jscl.math.function.Constant;
+import jscl.math.function.Exp;
+import jscl.math.function.Trigonometric;
+
+public class Sinh extends Trigonometric {
+    public Sinh(Generic generic) {
+        super("sinh",new Generic[] {generic});
+    }
+
+    public Generic antiderivative(int n) throws NotIntegrableException {
+        return new Cosh(parameter[0]).evaluate();
+    }
+
+    public Generic derivative(int n) {
+        return new Cosh(parameter[0]).evaluate();
+    }
+
+    public Generic evaluate() {
+        if(parameter[0].signum()<0) {
+            return new Sinh(parameter[0].negate()).evaluate().negate();
+        } else if(parameter[0].signum()==0) {
+            return JSCLInteger.valueOf(0);
+        }
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return new Exp(
+            parameter[0]
+        ).evalelem().subtract(
+            new Exp(
+                parameter[0].negate()
+            ).evalelem()
+        ).multiply(Constant.half);
+    }
+
+    public Generic evalsimp() {
+        if(parameter[0].signum()<0) {
+            return new Sinh(parameter[0].negate()).evaluate().negate();
+        } else if(parameter[0].signum()==0) {
+            return JSCLInteger.valueOf(0);
+        }
+        try {
+            Variable v=parameter[0].variableValue();
+            if(v instanceof Asinh) {
+                Generic g[]=((Asinh)v).parameters();
+                return g[0];
+            }
+        } catch (NotVariableException e) {}
+        return identity();
+    }
+
+    public Generic identity(Generic a, Generic b) {
+        return new Cosh(b).evalsimp().multiply(
+            new Sinh(a).evalsimp()
+        ).add(
+            new Cosh(a).evalsimp().multiply(
+                new Sinh(b).evalsimp()
+            )
+        );
+    }
+
+    public Generic evalnum() {
+        return ((NumericWrapper)parameter[0]).sinh();
+    }
+
+    protected Variable newinstance() {
+        return new Sinh(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/hyperbolic/Tanh.java b/src/misc/src/jscl/math/function/hyperbolic/Tanh.java
new file mode 100644
index 00000000..e00509af
--- /dev/null
+++ b/src/misc/src/jscl/math/function/hyperbolic/Tanh.java
@@ -0,0 +1,82 @@
+package jscl.math.function.hyperbolic;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegrableException;
+import jscl.math.NotVariableException;
+import jscl.math.NumericWrapper;
+import jscl.math.Variable;
+import jscl.math.function.Frac;
+import jscl.math.function.Log;
+import jscl.math.function.Trigonometric;
+
+public class Tanh extends Trigonometric {
+    public Tanh(Generic generic) {
+        super("tanh",new Generic[] {generic});
+    }
+
+    public Generic antiderivative(int n) throws NotIntegrableException {
+        return new Log(
+            JSCLInteger.valueOf(4).multiply(
+                new Cosh(parameter[0]).evaluate()
+            )
+        ).evaluate();
+    }
+
+    public Generic derivative(int n) {
+        return JSCLInteger.valueOf(1).subtract(
+            new Tanh(parameter[0]).evaluate().pow(2)
+        );
+    }
+
+    public Generic evaluate() {
+        if(parameter[0].signum()<0) {
+            return new Tanh(parameter[0].negate()).evaluate().negate();
+        } else if(parameter[0].signum()==0) {
+            return JSCLInteger.valueOf(0);
+        }
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return new Frac(
+            new Sinh(parameter[0]).evalelem(),
+            new Cosh(parameter[0]).evalelem()
+        ).evalelem();
+    }
+
+    public Generic evalsimp() {
+        if(parameter[0].signum()<0) {
+            return new Tanh(parameter[0].negate()).evaluate().negate();
+        } else if(parameter[0].signum()==0) {
+            return JSCLInteger.valueOf(0);
+        }
+        try {
+            Variable v=parameter[0].variableValue();
+            if(v instanceof Atanh) {
+                Generic g[]=((Atanh)v).parameters();
+                return g[0];
+            }
+        } catch (NotVariableException e) {}
+        return identity();
+    }
+
+    public Generic identity(Generic a, Generic b) {
+        Generic ta=new Tanh(a).evalsimp();
+        Generic tb=new Tanh(b).evalsimp();
+        return new Frac(
+            ta.add(tb),
+            JSCLInteger.valueOf(1).add(
+                ta.multiply(tb)
+            )
+        ).evalsimp();
+    }
+
+    public Generic evalnum() {
+        return ((NumericWrapper)parameter[0]).tanh();
+    }
+
+    protected Variable newinstance() {
+        return new Tanh(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/trigonometric/Acos.java b/src/misc/src/jscl/math/function/trigonometric/Acos.java
new file mode 100644
index 00000000..15ebe7bd
--- /dev/null
+++ b/src/misc/src/jscl/math/function/trigonometric/Acos.java
@@ -0,0 +1,58 @@
+package jscl.math.function.trigonometric;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NumericWrapper;
+import jscl.math.Variable;
+import jscl.math.function.ArcTrigonometric;
+import jscl.math.function.Constant;
+import jscl.math.function.Inv;
+import jscl.math.function.Log;
+import jscl.math.function.Root;
+import jscl.math.function.Sqrt;
+
+public class Acos extends ArcTrigonometric {
+    public Acos(Generic generic) {
+        super("acos",new Generic[] {generic});
+    }
+
+    public Generic derivative(int n) {
+        return new Inv(
+            new Sqrt(
+                JSCLInteger.valueOf(1).subtract(parameter[0].pow(2))
+            ).evaluate()
+        ).evaluate().negate();
+    }
+
+    public Generic evaluate() {
+        if(parameter[0].signum()<0) {
+            return Constant.pi.subtract(new Acos(parameter[0].negate()).evaluate());
+        } else if(parameter[0].compareTo(JSCLInteger.valueOf(1))==0) {
+            return JSCLInteger.valueOf(0);
+        }
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return Constant.i.multiply(
+            new Log(
+                new Root(
+                    new Generic[] {
+                        JSCLInteger.valueOf(-1),
+                        JSCLInteger.valueOf(2).multiply(parameter[0]),
+                        JSCLInteger.valueOf(-1)
+                    },
+                    0
+                ).evalelem()
+            ).evalelem()
+        );
+    }
+
+    public Generic evalnum() {
+        return ((NumericWrapper)parameter[0]).acos();
+    }
+
+    protected Variable newinstance() {
+        return new Acos(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/trigonometric/Acot.java b/src/misc/src/jscl/math/function/trigonometric/Acot.java
new file mode 100644
index 00000000..d589dddb
--- /dev/null
+++ b/src/misc/src/jscl/math/function/trigonometric/Acot.java
@@ -0,0 +1,53 @@
+package jscl.math.function.trigonometric;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NumericWrapper;
+import jscl.math.Variable;
+import jscl.math.function.ArcTrigonometric;
+import jscl.math.function.Constant;
+import jscl.math.function.Inv;
+import jscl.math.function.Log;
+import jscl.math.function.Root;
+
+public class Acot extends ArcTrigonometric {
+    public Acot(Generic generic) {
+        super("acot",new Generic[] {generic});
+    }
+
+    public Generic derivative(int n) {
+        return new Inv(
+            JSCLInteger.valueOf(1).add(parameter[0].pow(2))
+        ).evaluate().negate();
+    }
+
+    public Generic evaluate() {
+        if(parameter[0].signum()<0) {
+            return Constant.pi.subtract(new Acot(parameter[0].negate()).evaluate());
+        }
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return Constant.i.multiply(
+            new Log(
+                new Root(
+                    new Generic[] {
+                        Constant.i.add(parameter[0]),
+                        JSCLInteger.valueOf(0),
+                        Constant.i.subtract(parameter[0])
+                    },
+                    0
+                ).evalelem()
+            ).evalelem()
+        );
+    }
+
+    public Generic evalnum() {
+        return ((NumericWrapper)parameter[0]).acot();
+    }
+
+    protected Variable newinstance() {
+        return new Acot(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/trigonometric/Asin.java b/src/misc/src/jscl/math/function/trigonometric/Asin.java
new file mode 100644
index 00000000..5cd9be3b
--- /dev/null
+++ b/src/misc/src/jscl/math/function/trigonometric/Asin.java
@@ -0,0 +1,58 @@
+package jscl.math.function.trigonometric;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NumericWrapper;
+import jscl.math.Variable;
+import jscl.math.function.ArcTrigonometric;
+import jscl.math.function.Constant;
+import jscl.math.function.Inv;
+import jscl.math.function.Log;
+import jscl.math.function.Root;
+import jscl.math.function.Sqrt;
+
+public class Asin extends ArcTrigonometric {
+    public Asin(Generic generic) {
+        super("asin",new Generic[] {generic});
+    }
+
+    public Generic derivative(int n) {
+        return new Inv(
+            new Sqrt(
+                JSCLInteger.valueOf(1).subtract(parameter[0].pow(2))
+            ).evaluate()
+        ).evaluate();
+    }
+
+    public Generic evaluate() {
+        if(parameter[0].signum()<0) {
+            return new Asin(parameter[0].negate()).evaluate().negate();
+        } else if(parameter[0].signum()==0) {
+            return JSCLInteger.valueOf(0);
+        }
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return Constant.i.multiply(
+            new Log(
+                new Root(
+                    new Generic[] {
+                        JSCLInteger.valueOf(-1),
+                        JSCLInteger.valueOf(2).multiply(Constant.i.multiply(parameter[0])),
+                        JSCLInteger.valueOf(1)
+                    },
+                    0
+                ).evalelem()
+            ).evalelem()
+        );
+    }
+
+    public Generic evalnum() {
+        return ((NumericWrapper)parameter[0]).asin();
+    }
+
+    protected Variable newinstance() {
+        return new Asin(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/trigonometric/Atan.java b/src/misc/src/jscl/math/function/trigonometric/Atan.java
new file mode 100644
index 00000000..7905ce92
--- /dev/null
+++ b/src/misc/src/jscl/math/function/trigonometric/Atan.java
@@ -0,0 +1,55 @@
+package jscl.math.function.trigonometric;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NumericWrapper;
+import jscl.math.Variable;
+import jscl.math.function.ArcTrigonometric;
+import jscl.math.function.Constant;
+import jscl.math.function.Inv;
+import jscl.math.function.Log;
+import jscl.math.function.Root;
+
+public class Atan extends ArcTrigonometric {
+    public Atan(Generic generic) {
+        super("atan",new Generic[] {generic});
+    }
+
+    public Generic derivative(int n) {
+        return new Inv(
+            JSCLInteger.valueOf(1).add(parameter[0].pow(2))
+        ).evaluate();
+    }
+
+    public Generic evaluate() {
+        if(parameter[0].signum()<0) {
+            return new Atan(parameter[0].negate()).evaluate().negate();
+        } else if(parameter[0].signum()==0) {
+            return JSCLInteger.valueOf(0);
+        }
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return Constant.i.multiply(
+            new Log(
+                new Root(
+                    new Generic[] {
+                        JSCLInteger.valueOf(-1).add(Constant.i.multiply(parameter[0])),
+                        JSCLInteger.valueOf(0),
+                        JSCLInteger.valueOf(1).add(Constant.i.multiply(parameter[0]))
+                    },
+                    0
+                ).evalelem()
+            ).evalelem()
+        );
+    }
+
+    public Generic evalnum() {
+        return ((NumericWrapper)parameter[0]).atan();
+    }
+
+    protected Variable newinstance() {
+        return new Atan(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/trigonometric/Cos.java b/src/misc/src/jscl/math/function/trigonometric/Cos.java
new file mode 100644
index 00000000..8c1060b2
--- /dev/null
+++ b/src/misc/src/jscl/math/function/trigonometric/Cos.java
@@ -0,0 +1,82 @@
+package jscl.math.function.trigonometric;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegrableException;
+import jscl.math.NotVariableException;
+import jscl.math.NumericWrapper;
+import jscl.math.Variable;
+import jscl.math.function.Constant;
+import jscl.math.function.Exp;
+import jscl.math.function.Trigonometric;
+
+public class Cos extends Trigonometric {
+    public Cos(Generic generic) {
+        super("cos",new Generic[] {generic});
+    }
+
+    public Generic antiderivative(int n) throws NotIntegrableException {
+        return new Sin(parameter[0]).evaluate();
+    }
+
+    public Generic derivative(int n) {
+        return new Sin(parameter[0]).evaluate().negate();
+    }
+
+    public Generic evaluate() {
+        if(parameter[0].signum()<0) {
+            return new Cos(parameter[0].negate()).evaluate();
+        } else if(parameter[0].signum()==0) {
+            return JSCLInteger.valueOf(1);
+        } else if(parameter[0].compareTo(Constant.pi)==0) {
+            return JSCLInteger.valueOf(-1);
+        }
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return new Exp(
+            Constant.i.multiply(parameter[0])
+        ).evalelem().add(
+            new Exp(
+                Constant.i.multiply(parameter[0].negate())
+            ).evalelem()
+        ).multiply(Constant.half);
+    }
+
+    public Generic evalsimp() {
+        if(parameter[0].signum()<0) {
+            return new Cos(parameter[0].negate()).evaluate();
+        } else if(parameter[0].signum()==0) {
+            return JSCLInteger.valueOf(1);
+        } else if(parameter[0].compareTo(Constant.pi)==0) {
+            return JSCLInteger.valueOf(-1);
+        }
+        try {
+            Variable v=parameter[0].variableValue();
+            if(v instanceof Acos) {
+                Generic g[]=((Acos)v).parameters();
+                return g[0];
+            }
+        } catch (NotVariableException e) {}
+        return identity();
+    }
+
+    public Generic identity(Generic a, Generic b) {
+        return new Cos(a).evalsimp().multiply(
+            new Cos(b).evalsimp()
+        ).subtract(
+            new Sin(a).evalsimp().multiply(
+                new Sin(b).evalsimp()
+            )
+        );
+    }
+
+    public Generic evalnum() {
+        return ((NumericWrapper)parameter[0]).cos();
+    }
+
+    protected Variable newinstance() {
+        return new Cos(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/trigonometric/Cot.java b/src/misc/src/jscl/math/function/trigonometric/Cot.java
new file mode 100644
index 00000000..b1109db9
--- /dev/null
+++ b/src/misc/src/jscl/math/function/trigonometric/Cot.java
@@ -0,0 +1,76 @@
+package jscl.math.function.trigonometric;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegrableException;
+import jscl.math.NotVariableException;
+import jscl.math.NumericWrapper;
+import jscl.math.Variable;
+import jscl.math.function.Frac;
+import jscl.math.function.Log;
+import jscl.math.function.Trigonometric;
+
+public class Cot extends Trigonometric {
+    public Cot(Generic generic) {
+        super("cot",new Generic[] {generic});
+    }
+
+    public Generic antiderivative(int n) throws NotIntegrableException {
+        return new Log(
+            JSCLInteger.valueOf(4).multiply(
+                new Sin(parameter[0]).evaluate()
+            )
+        ).evaluate();
+    }
+
+    public Generic derivative(int n) {
+        return JSCLInteger.valueOf(1).add(
+            new Cot(parameter[0]).evaluate().pow(2)
+        ).negate();
+    }
+
+    public Generic evaluate() {
+        if(parameter[0].signum()<0) {
+            return new Cot(parameter[0].negate()).evaluate().negate();
+        }
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return new Frac(
+            new Cos(parameter[0]).evalelem(),
+            new Sin(parameter[0]).evalelem()
+        ).evalelem();
+    }
+
+    public Generic evalsimp() {
+        if(parameter[0].signum()<0) {
+            return new Cot(parameter[0].negate()).evaluate().negate();
+        }
+        try {
+            Variable v=parameter[0].variableValue();
+            if(v instanceof Acot) {
+                Generic g[]=((Acot)v).parameters();
+                return g[0];
+            }
+        } catch (NotVariableException e) {}
+        return identity();
+    }
+
+    public Generic identity(Generic a, Generic b) {
+        Generic ta=new Cot(a).evalsimp();
+        Generic tb=new Cot(b).evalsimp();
+        return new Frac(
+            ta.multiply(tb).subtract(JSCLInteger.valueOf(1)),
+                        ta.add(tb)
+        ).evalsimp();
+    }
+
+    public Generic evalnum() {
+        return ((NumericWrapper)parameter[0]).cot();
+    }
+
+    protected Variable newinstance() {
+        return new Cot(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/trigonometric/Sin.java b/src/misc/src/jscl/math/function/trigonometric/Sin.java
new file mode 100644
index 00000000..4d730b00
--- /dev/null
+++ b/src/misc/src/jscl/math/function/trigonometric/Sin.java
@@ -0,0 +1,82 @@
+package jscl.math.function.trigonometric;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegrableException;
+import jscl.math.NotVariableException;
+import jscl.math.NumericWrapper;
+import jscl.math.Variable;
+import jscl.math.function.Constant;
+import jscl.math.function.Exp;
+import jscl.math.function.Trigonometric;
+
+public class Sin extends Trigonometric {
+    public Sin(Generic generic) {
+        super("sin",new Generic[] {generic});
+    }
+
+    public Generic antiderivative(int n) throws NotIntegrableException {
+        return new Cos(parameter[0]).evaluate().negate();
+    }
+
+    public Generic derivative(int n) {
+        return new Cos(parameter[0]).evaluate();
+    }
+
+    public Generic evaluate() {
+        if(parameter[0].signum()<0) {
+            return new Sin(parameter[0].negate()).evaluate().negate();
+        } else if(parameter[0].signum()==0) {
+            return JSCLInteger.valueOf(0);
+        } else if(parameter[0].compareTo(Constant.pi)==0) {
+            return JSCLInteger.valueOf(0);
+        }
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return new Exp(
+            Constant.i.multiply(parameter[0])
+        ).evalelem().subtract(
+            new Exp(
+                Constant.i.multiply(parameter[0].negate())
+            ).evalelem()
+        ).multiply(Constant.i.negate().multiply(Constant.half));
+    }
+
+    public Generic evalsimp() {
+        if(parameter[0].signum()<0) {
+            return new Sin(parameter[0].negate()).evaluate().negate();
+        } else if(parameter[0].signum()==0) {
+            return JSCLInteger.valueOf(0);
+        } else if(parameter[0].compareTo(Constant.pi)==0) {
+            return JSCLInteger.valueOf(0);
+        }
+        try {
+            Variable v=parameter[0].variableValue();
+            if(v instanceof Asin) {
+                Generic g[]=((Asin)v).parameters();
+                return g[0];
+            }
+        } catch (NotVariableException e) {}
+        return identity();
+    }
+
+    public Generic identity(Generic a, Generic b) {
+        return new Cos(b).evalsimp().multiply(
+            new Sin(a).evalsimp()
+        ).add(
+            new Cos(a).evalsimp().multiply(
+                new Sin(b).evalsimp()
+            )
+        );
+    }
+
+    public Generic evalnum() {
+        return ((NumericWrapper)parameter[0]).sin();
+    }
+
+    protected Variable newinstance() {
+        return new Sin(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/function/trigonometric/Tan.java b/src/misc/src/jscl/math/function/trigonometric/Tan.java
new file mode 100644
index 00000000..bc652288
--- /dev/null
+++ b/src/misc/src/jscl/math/function/trigonometric/Tan.java
@@ -0,0 +1,87 @@
+package jscl.math.function.trigonometric;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegrableException;
+import jscl.math.NotVariableException;
+import jscl.math.NumericWrapper;
+import jscl.math.Variable;
+import jscl.math.function.Constant;
+import jscl.math.function.Frac;
+import jscl.math.function.Log;
+import jscl.math.function.Trigonometric;
+
+public class Tan extends Trigonometric {
+    public Tan(Generic generic) {
+        super("tan",new Generic[] {generic});
+    }
+
+    public Generic antiderivative(int n) throws NotIntegrableException {
+        return new Log(
+            JSCLInteger.valueOf(4).multiply(
+                new Cos(parameter[0]).evaluate()
+            )
+        ).evaluate().negate();
+    }
+
+    public Generic derivative(int n) {
+        return JSCLInteger.valueOf(1).add(
+            new Tan(parameter[0]).evaluate().pow(2)
+        );
+    }
+
+    public Generic evaluate() {
+        if(parameter[0].signum()<0) {
+            return new Tan(parameter[0].negate()).evaluate().negate();
+        } else if(parameter[0].signum()==0) {
+            return JSCLInteger.valueOf(0);
+        } else if(parameter[0].compareTo(Constant.pi)==0) {
+            return JSCLInteger.valueOf(0);
+        }
+        return expressionValue();
+    }
+
+    public Generic evalelem() {
+        return new Frac(
+            new Sin(parameter[0]).evalelem(),
+            new Cos(parameter[0]).evalelem()
+        ).evalelem();
+    }
+
+    public Generic evalsimp() {
+        if(parameter[0].signum()<0) {
+            return new Tan(parameter[0].negate()).evaluate().negate();
+        } else if(parameter[0].signum()==0) {
+            return JSCLInteger.valueOf(0);
+        } else if(parameter[0].compareTo(Constant.pi)==0) {
+            return JSCLInteger.valueOf(0);
+        }
+        try {
+            Variable v=parameter[0].variableValue();
+            if(v instanceof Atan) {
+                Generic g[]=((Atan)v).parameters();
+                return g[0];
+            }
+        } catch (NotVariableException e) {}
+        return identity();
+    }
+
+    public Generic identity(Generic a, Generic b) {
+        Generic ta=new Tan(a).evalsimp();
+        Generic tb=new Tan(b).evalsimp();
+        return new Frac(
+            ta.add(tb),
+            JSCLInteger.valueOf(1).subtract(
+                ta.multiply(tb)
+            )
+        ).evalsimp();
+    }
+
+    public Generic evalnum() {
+        return ((NumericWrapper)parameter[0]).tan();
+    }
+
+    protected Variable newinstance() {
+        return new Tan(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/numeric/Complex.java b/src/misc/src/jscl/math/numeric/Complex.java
new file mode 100644
index 00000000..9e9634d7
--- /dev/null
+++ b/src/misc/src/jscl/math/numeric/Complex.java
@@ -0,0 +1,182 @@
+package jscl.math.numeric;
+
+public final class Complex extends Numeric {
+    double real, imag;
+
+    Complex(double real, double imag) {
+        this.real=real;
+        this.imag=imag;
+    }
+
+    public Complex add(Complex complex) {
+        return new Complex(real+complex.real,imag+complex.imag);
+    }
+
+    public Numeric add(Numeric numeric) {
+        if(numeric instanceof Complex) {
+            return add((Complex)numeric);
+        } else if(numeric instanceof JSCLDouble) {
+            return add(valueof(numeric));
+        } else {
+            return numeric.valueof(this).add(numeric);
+        }
+    }
+
+    public Complex subtract(Complex complex) {
+        return new Complex(real-complex.real,imag-complex.imag);
+    }
+
+    public Numeric subtract(Numeric numeric) {
+        if(numeric instanceof Complex) {
+            return subtract((Complex)numeric);
+        } else if(numeric instanceof JSCLDouble) {
+            return subtract(valueof(numeric));
+        } else {
+            return numeric.valueof(this).subtract(numeric);
+        }
+    }
+
+    public Complex multiply(Complex complex) {
+        return new Complex(real*complex.real-imag*complex.imag,real*complex.imag+imag*complex.real);
+    }
+
+    public Numeric multiply(Numeric numeric) {
+        if(numeric instanceof Complex) {
+            return multiply((Complex)numeric);
+        } else if(numeric instanceof JSCLDouble) {
+            return multiply(valueof(numeric));
+        } else {
+            return numeric.multiply(this);
+        }
+    }
+
+    public Complex divide(Complex complex) throws ArithmeticException {
+        return multiply((Complex)complex.inverse());
+    }
+
+    public Numeric divide(Numeric numeric) throws ArithmeticException {
+        if(numeric instanceof Complex) {
+            return divide((Complex)numeric);
+        } else if(numeric instanceof JSCLDouble) {
+            return divide(valueof(numeric));
+        } else {
+            return numeric.valueof(this).divide(numeric);
+        }
+    }
+
+    public Numeric negate() {
+        return new Complex(-real,-imag);
+    }
+
+    public int signum() {
+        return imag==0.?(real==0.?0:(real<0.?-1:1)):(imag<0.?-1:1);
+    }
+
+    public Complex valueof(Complex complex) {
+        return new Complex(complex.real,complex.imag);
+    }
+
+    public Numeric valueof(Numeric numeric) {
+        if(numeric instanceof Complex) {
+            return valueof((Complex)numeric);
+        } else if(numeric instanceof JSCLDouble) {
+            JSCLDouble d=(JSCLDouble)numeric;
+            return new Complex(d.content,0.);
+        } else throw new ArithmeticException();
+    }
+
+    public double magnitude() {
+        return Math.sqrt(real*real+imag*imag);
+    }
+
+    public double magnitude2() {
+        return real*real+imag*imag;
+    }
+
+    public double angle() {
+        return Math.atan2(imag,real);
+    }
+
+    public Numeric log() {
+        if(signum()==0) {
+            return JSCLDouble.valueOf(0).log();
+        } else {
+            return new Complex(Math.log(magnitude()),angle());
+        }
+    }
+
+    public Numeric exp() {
+        return new Complex(Math.cos(imag),Math.sin(imag)).multiply(Math.exp(real));
+    }
+
+    public Numeric inverse() {
+        return ((Complex)conjugate()).divide(magnitude2());
+    }
+
+    Complex multiply(double d) {
+        return new Complex(real*d,imag*d);
+    }
+
+    Complex divide(double d) {
+        return new Complex(real/d,imag/d);
+    }
+
+    public Numeric conjugate() {
+        return new Complex(real,-imag);
+    }
+
+    public double realPart() {
+        return real;
+    }
+
+    public double imaginaryPart() {
+        return imag;
+    }
+
+    public int compareTo(Complex complex) {
+        if(imag<complex.imag) return -1;
+        else if(imag>complex.imag) return 1;
+        else if(imag==complex.imag) {
+            if(real<complex.real) return -1;
+            else if(real>complex.real) return 1;
+            else if(real==complex.real) return 0;
+            else throw new ArithmeticException();
+        } else throw new ArithmeticException();
+    }
+
+    public int compareTo(Numeric numeric) {
+        if(numeric instanceof Complex) {
+            return compareTo((Complex)numeric);
+        } else if(numeric instanceof JSCLDouble) {
+            return compareTo(valueof(numeric));
+        } else {
+            return numeric.valueof(this).compareTo(numeric);
+        }
+    }
+
+    public static Complex valueOf(double real, double imag) {
+        return new Complex(real,imag);
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        if(imag==0.) {
+            buffer.append(real);
+        } else {
+            if(real==0.);
+            else {
+                buffer.append(real);
+                if(imag<=0.);
+                                else buffer.append("+");
+            }
+            if(imag==1.);
+            else if(imag==-1.) buffer.append("-");
+            else {
+                buffer.append(imag);
+                buffer.append("*");
+            }
+            buffer.append("sqrt(-1)");
+        }
+        return buffer.toString();
+    }
+}
diff --git a/src/misc/src/jscl/math/numeric/JSCLDouble.java b/src/misc/src/jscl/math/numeric/JSCLDouble.java
new file mode 100644
index 00000000..cc10d65e
--- /dev/null
+++ b/src/misc/src/jscl/math/numeric/JSCLDouble.java
@@ -0,0 +1,174 @@
+package jscl.math.numeric;
+
+public final class JSCLDouble extends Numeric {
+    double content;
+
+    JSCLDouble(double val) {
+        content=val;
+    }
+
+    public JSCLDouble add(JSCLDouble dble) {
+        return new JSCLDouble(content+dble.content);
+    }
+
+    public Numeric add(Numeric numeric) {
+        if(numeric instanceof JSCLDouble) {
+            return add((JSCLDouble)numeric);
+        } else {
+            return numeric.valueof(this).add(numeric);
+        }
+    }
+
+    public JSCLDouble subtract(JSCLDouble dble) {
+        return new JSCLDouble(content-dble.content);
+    }
+
+    public Numeric subtract(Numeric numeric) {
+        if(numeric instanceof JSCLDouble) {
+            return subtract((JSCLDouble)numeric);
+        } else {
+            return numeric.valueof(this).subtract(numeric);
+        }
+    }
+
+    public JSCLDouble multiply(JSCLDouble dble) {
+        return new JSCLDouble(content*dble.content);
+    }
+
+    public Numeric multiply(Numeric numeric) {
+        if(numeric instanceof JSCLDouble) {
+            return multiply((JSCLDouble)numeric);
+        } else {
+            return numeric.multiply(this);
+        }
+    }
+
+    public JSCLDouble divide(JSCLDouble dble) throws ArithmeticException {
+        return new JSCLDouble(content/dble.content);
+    }
+
+    public Numeric divide(Numeric numeric) throws ArithmeticException {
+        if(numeric instanceof JSCLDouble) {
+            return divide((JSCLDouble)numeric);
+        } else {
+            return numeric.valueof(this).divide(numeric);
+        }
+    }
+
+    public Numeric negate() {
+        return new JSCLDouble(-content);
+    }
+
+    public int signum() {
+        return content==0.?0:(content<0.?-1:1);
+    }
+
+    public Numeric log() {
+        return new JSCLDouble(Math.log(content));
+    }
+
+    public Numeric exp() {
+        return new JSCLDouble(Math.exp(content));
+    }
+
+    public Numeric inverse() {
+        return new JSCLDouble(1./content);
+    }
+
+    public Numeric pow(JSCLDouble dble) {
+        if(signum()<0) {
+            return Complex.valueOf(content,0).pow(dble);
+        } else {
+            return new JSCLDouble(Math.pow(content,dble.content));
+        }
+    }
+
+    public Numeric pow(Numeric numeric) {
+        if(numeric instanceof JSCLDouble) {
+            return pow((JSCLDouble)numeric);
+        } else {
+            return numeric.valueof(this).pow(numeric);
+        }
+    }
+
+    public Numeric sqrt() {
+        if(signum()<0) {
+            return Complex.valueOf(0,1).multiply(negate().sqrt());
+        } else {
+            return new JSCLDouble(Math.sqrt(content));
+        }
+    }
+
+    public Numeric nthrt(int n) {
+        if(signum()<0) {
+            return n%2==0?sqrt().nthrt(n/2):negate().nthrt(n).negate();
+        } else {
+            return super.nthrt(n);
+        }
+    }
+
+    public Numeric conjugate() {
+        return this;
+    }
+
+    public Numeric acos() {
+        return new JSCLDouble(Math.acos(content));
+    }
+
+    public Numeric asin() {
+        return new JSCLDouble(Math.asin(content));
+    }
+
+    public Numeric atan() {
+        return new JSCLDouble(Math.atan(content));
+    }
+
+    public Numeric cos() {
+        return new JSCLDouble(Math.cos(content));
+    }
+
+    public Numeric sin() {
+        return new JSCLDouble(Math.sin(content));
+    }
+
+    public Numeric tan() {
+        return new JSCLDouble(Math.tan(content));
+    }
+
+    public JSCLDouble valueof(JSCLDouble dble) {
+        return new JSCLDouble(dble.content);
+    }
+
+    public Numeric valueof(Numeric numeric) {
+        if(numeric instanceof JSCLDouble) {
+            return valueof((JSCLDouble)numeric);
+        } else throw new ArithmeticException();
+    }
+
+    public double doubleValue() {
+        return content;
+    }
+
+    public int compareTo(JSCLDouble dble) {
+        if(content<dble.content) return -1;
+        else if(content>dble.content) return 1;
+        else if(content==dble.content) return 0;
+        else throw new ArithmeticException();
+    }
+
+    public int compareTo(Numeric numeric) {
+        if(numeric instanceof JSCLDouble) {
+            return compareTo((JSCLDouble)numeric);
+        } else {
+            return numeric.valueof(this).compareTo(numeric);
+        }
+    }
+
+    public static JSCLDouble valueOf(double val) {
+        return new JSCLDouble(val);
+    }
+
+    public String toString() {
+        return new Double(content).toString();
+    }
+}
diff --git a/src/misc/src/jscl/math/numeric/Numeric.java b/src/misc/src/jscl/math/numeric/Numeric.java
new file mode 100644
index 00000000..c2044ee0
--- /dev/null
+++ b/src/misc/src/jscl/math/numeric/Numeric.java
@@ -0,0 +1,156 @@
+package jscl.math.numeric;
+
+import jscl.math.Arithmetic;
+
+public abstract class Numeric implements Arithmetic, Comparable {
+    public abstract Numeric add(Numeric numeric);
+
+    public Numeric subtract(Numeric numeric) {
+        return add(numeric.negate());
+    }
+
+    public abstract Numeric multiply(Numeric numeric);
+    public abstract Numeric divide(Numeric numeric) throws ArithmeticException;
+
+    public Arithmetic add(Arithmetic arithmetic) {
+        return add((Numeric)arithmetic);
+    }
+
+    public Arithmetic subtract(Arithmetic arithmetic) {
+        return subtract((Numeric)arithmetic);
+    }
+
+    public Arithmetic multiply(Arithmetic arithmetic) {
+        return multiply((Numeric)arithmetic);
+    }
+
+    public Arithmetic divide(Arithmetic arithmetic) throws ArithmeticException {
+        return divide((Numeric)arithmetic);
+    }
+
+    public Numeric pow(int exponent) {
+        Numeric a=JSCLDouble.valueOf(1);
+        for(int i=0;i<exponent;i++) a=a.multiply(this);
+        return a;
+    }
+
+    public Numeric abs() {
+        return signum()<0?negate():(signum()==0?JSCLDouble.valueOf(1):this);
+    }
+
+    public abstract Numeric negate();
+    public abstract int signum();
+
+    public Numeric sgn() {
+        return divide(abs());
+    }
+
+    public abstract Numeric log();
+    public abstract Numeric exp();
+
+    public Numeric inverse() {
+        return JSCLDouble.valueOf(1).divide(this);
+    }
+
+    public Numeric pow(Numeric numeric) {
+        if(numeric.signum()==0) {
+            return JSCLDouble.valueOf(1);
+        } else if(numeric.compareTo(JSCLDouble.valueOf(1))==0) {
+            return this;
+        } else {
+            return numeric.multiply(log()).exp();
+        }
+    }
+
+    public Numeric sqrt() {
+        return nthrt(2);
+    }
+
+    public Numeric nthrt(int n) {
+        return pow(JSCLDouble.valueOf(1./n));
+    }
+
+    public static Numeric root(int subscript, Numeric parameter[]) {
+        throw new ArithmeticException();
+    }
+
+    public abstract Numeric conjugate();
+
+    public Numeric acos() {
+        return add(JSCLDouble.valueOf(-1).add(pow(2)).sqrt()).log().multiply(Complex.valueOf(0, 1));
+    }
+
+    public Numeric asin() {
+        return multiply(Complex.valueOf(0, 1)).negate().add(JSCLDouble.valueOf(1).subtract(pow(2)).sqrt()).log().multiply(Complex.valueOf(0, 1));
+    }
+
+    public Numeric atan() {
+        return Complex.valueOf(0, 1).multiply(Complex.valueOf(0, 1).add(this).divide(Complex.valueOf(0, 1).subtract(this)).log()).divide(JSCLDouble.valueOf(2));
+    }
+
+    public Numeric acot() {
+            return Complex.valueOf(0, 1).multiply(Complex.valueOf(0, 1).add(this).divide(Complex.valueOf(0, 1).subtract(this)).negate().log()).divide(JSCLDouble.valueOf(2));
+        }
+
+    public Numeric cos() {
+        return JSCLDouble.valueOf(1).add(multiply(Complex.valueOf(0, 1)).exp().pow(2)).divide(JSCLDouble.valueOf(2).multiply(multiply(Complex.valueOf(0, 1)).exp()));
+    }
+
+    public Numeric sin() {
+        return Complex.valueOf(0, 1).subtract(multiply(Complex.valueOf(0, 1)).exp().pow(2).multiply(Complex.valueOf(0, 1))).divide(JSCLDouble.valueOf(2).multiply(multiply(Complex.valueOf(0, 1)).exp()));
+    }
+
+    public Numeric tan() {
+        return Complex.valueOf(0, 1).subtract(multiply(Complex.valueOf(0, 1)).exp().pow(2).multiply(Complex.valueOf(0, 1))).divide(JSCLDouble.valueOf(1).add(multiply(Complex.valueOf(0, 1)).exp().pow(2)));
+    }
+
+    public Numeric cot() {
+        return Complex.valueOf(0, 1).add(Complex.valueOf(0, 1).multiply(Complex.valueOf(0, 1).multiply(this).exp().pow(2))).divide(JSCLDouble.valueOf(1).subtract(Complex.valueOf(0, 1).multiply(this).exp().pow(2))).negate();
+    }
+
+    public Numeric acosh() {
+        return add(JSCLDouble.valueOf(-1).add(pow(2)).sqrt()).log();
+    }
+
+    public Numeric asinh() {
+        return add(JSCLDouble.valueOf(1).add(pow(2)).sqrt()).log();
+    }
+
+    public Numeric atanh() {
+        return JSCLDouble.valueOf(1).add(this).divide(JSCLDouble.valueOf(1).subtract(this)).log().divide(JSCLDouble.valueOf(2));
+    }
+
+    public Numeric acoth() {
+        return JSCLDouble.valueOf(1).add(this).divide(JSCLDouble.valueOf(1).subtract(this)).negate().log().divide(JSCLDouble.valueOf(2));
+    }
+
+    public Numeric cosh() {
+        return JSCLDouble.valueOf(1).add(exp().pow(2)).divide(JSCLDouble.valueOf(2).multiply(exp()));
+    }
+
+    public Numeric sinh() {
+        return JSCLDouble.valueOf(1).subtract(exp().pow(2)).divide(JSCLDouble.valueOf(2).multiply(exp())).negate();
+    }
+
+    public Numeric tanh() {
+        return JSCLDouble.valueOf(1).subtract(exp().pow(2)).divide(JSCLDouble.valueOf(1).add(exp().pow(2))).negate();
+    }
+
+    public Numeric coth() {
+        return JSCLDouble.valueOf(1).add(exp().pow(2)).divide(JSCLDouble.valueOf(1).subtract(exp().pow(2))).negate();
+    }
+
+    public abstract Numeric valueof(Numeric numeric);
+
+    public abstract int compareTo(Numeric numeric);
+
+    public int compareTo(Object o) {
+        return compareTo((Numeric)o);
+    }
+
+    public boolean equals(Object obj) {
+        if(obj instanceof Numeric) {
+            return compareTo((Numeric)obj)==0;
+        } else return false;
+    }
+}
diff --git a/src/misc/src/jscl/math/numeric/NumericMatrix.java b/src/misc/src/jscl/math/numeric/NumericMatrix.java
new file mode 100644
index 00000000..74e30e6b
--- /dev/null
+++ b/src/misc/src/jscl/math/numeric/NumericMatrix.java
@@ -0,0 +1,277 @@
+package jscl.math.numeric;
+
+import jscl.util.ArrayComparator;
+
+public class NumericMatrix extends Numeric {
+    protected final Numeric element[][];
+    protected final int n,p;
+
+    public NumericMatrix(Numeric element[][]) {
+        this.element=element;
+        n=element.length;
+        p=element.length>0?element[0].length:0;
+    }
+
+    public Numeric[][] elements() {
+        return element;
+    }
+
+    public NumericMatrix add(NumericMatrix matrix) {
+        NumericMatrix m=(NumericMatrix)newinstance();
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<p;j++) {
+                m.element[i][j]=element[i][j].add(matrix.element[i][j]);
+            }
+        }
+        return m;
+    }
+
+    public Numeric add(Numeric numeric) {
+        if(numeric instanceof NumericMatrix) {
+            return add((NumericMatrix)numeric);
+        } else {
+            return add(valueof(numeric));
+        }
+    }
+
+    public NumericMatrix subtract(NumericMatrix matrix) {
+        NumericMatrix m=(NumericMatrix)newinstance();
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<p;j++) {
+                m.element[i][j]=element[i][j].subtract(matrix.element[i][j]);
+            }
+        }
+        return m;
+    }
+
+    public Numeric subtract(Numeric numeric) {
+        if(numeric instanceof NumericMatrix) {
+            return subtract((NumericMatrix)numeric);
+        } else {
+            return subtract(valueof(numeric));
+        }
+    }
+
+    public NumericMatrix multiply(NumericMatrix matrix) {
+        if(p!=matrix.n) throw new ArithmeticException();
+        NumericMatrix m=(NumericMatrix)newinstance(new Numeric[n][matrix.p]);
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<matrix.p;j++) {
+                m.element[i][j]=JSCLDouble.valueOf(0);
+                for(int k=0;k<p;k++) {
+                    m.element[i][j]=m.element[i][j].add(element[i][k].multiply(matrix.element[k][j]));
+                }
+            }
+        }
+        return m;
+    }
+
+    public Numeric multiply(Numeric numeric) {
+        if(numeric instanceof NumericMatrix) {
+            return multiply((NumericMatrix)numeric);
+        } else if(numeric instanceof NumericVector) {
+            NumericVector v=(NumericVector)((NumericVector)numeric).newinstance(new Numeric[n]);
+            NumericVector v2=(NumericVector)numeric;
+            if(p!=v2.n) throw new ArithmeticException();
+            for(int i=0;i<n;i++) {
+                v.element[i]=JSCLDouble.valueOf(0);
+                for(int k=0;k<p;k++) {
+                    v.element[i]=v.element[i].add(element[i][k].multiply(v2.element[k]));
+                }
+            }
+            return v;
+        } else {
+            NumericMatrix m=(NumericMatrix)newinstance();
+            for(int i=0;i<n;i++) {
+                for(int j=0;j<p;j++) {
+                    m.element[i][j]=element[i][j].multiply((Numeric)numeric);
+                }
+            }
+            return m;
+        }
+    }
+
+    public Numeric divide(Numeric numeric) throws ArithmeticException {
+        if(numeric instanceof NumericMatrix) {
+            return multiply(((NumericMatrix)numeric).inverse());
+        } else if(numeric instanceof NumericVector) {
+            throw new ArithmeticException();
+        } else {
+            NumericMatrix m=(NumericMatrix)newinstance();
+            for(int i=0;i<n;i++) {
+                for(int j=0;j<p;j++) {
+                    m.element[i][j]=element[i][j].divide((Numeric)numeric);
+                }
+            }
+            return m;
+        }
+    }
+
+    public Numeric negate() {
+        NumericMatrix m=(NumericMatrix)newinstance();
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<p;j++) {
+                m.element[i][j]=element[i][j].negate();
+            }
+        }
+        return m;
+    }
+
+    public int signum() {
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<p;j++) {
+                int c=element[i][j].signum();
+                if(c<0) return -1;
+                else if(c>0) return 1;
+            }
+        }
+        return 0;
+    }
+
+    public Numeric valueof(Numeric numeric) {
+        if(numeric instanceof NumericMatrix || numeric instanceof NumericVector) {
+            throw new ArithmeticException();
+        } else {
+            NumericMatrix m=(NumericMatrix)identity(n,p).multiply(numeric);
+            return newinstance(m.element);
+        }
+    }
+
+    public Numeric[] vectors() {
+        NumericVector v[]=new NumericVector[n];
+        for(int i=0;i<n;i++) {
+            v[i]=new NumericVector(new Numeric[p]);
+            for(int j=0;j<p;j++) {
+                v[i].element[j]=element[i][j];
+            }
+        }
+        return v;
+    }
+
+    public Numeric transpose() {
+        NumericMatrix m=(NumericMatrix)newinstance(new Numeric[p][n]);
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<p;j++) {
+                m.element[j][i]=element[i][j];
+            }
+        }
+        return m;
+    }
+
+    public Numeric trace() {
+        Numeric s=JSCLDouble.valueOf(0);
+        for(int i=0;i<n;i++) {
+            s=s.add(element[i][i]);
+        }
+        return s;
+    }
+
+    public Numeric inverse() {
+        NumericMatrix m=(NumericMatrix)newinstance();
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<n;j++) {
+                m.element[i][j]=inverseElement(i,j);
+            }
+        }
+        return m.transpose().divide(determinant());
+    }
+
+    Numeric inverseElement(int k, int l) {
+        NumericMatrix m=(NumericMatrix)newinstance();
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<n;j++) {
+                m.element[i][j]=i==k?JSCLDouble.valueOf(j==l?1:0):element[i][j];
+            }
+        }
+        return m.determinant();
+    }
+
+    public Numeric determinant() {
+        if(n>1) {
+            Numeric a=JSCLDouble.valueOf(0);
+            for(int i=0;i<n;i++) {
+                if(element[i][0].signum()==0);
+                else {
+                    NumericMatrix m=(NumericMatrix)newinstance(new Numeric[n-1][n-1]);
+                    for(int j=0;j<n-1;j++) {
+                        for(int k=0;k<n-1;k++) m.element[j][k]=element[j<i?j:j+1][k+1];
+                    }
+                    if(i%2==0) a=a.add(element[i][0].multiply(m.determinant()));
+                    else a=a.subtract(element[i][0].multiply(m.determinant()));
+                }
+            }
+            return a;
+        } else if(n>0) return element[0][0];
+        else return JSCLDouble.valueOf(0);
+    }
+
+    public Numeric log() {
+        throw new ArithmeticException();
+    }
+
+    public Numeric exp() {
+        throw new ArithmeticException();
+    }
+
+    public Numeric conjugate() {
+        NumericMatrix m=(NumericMatrix)newinstance();
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<p;j++) {
+                m.element[i][j]=element[i][j].conjugate();
+            }
+        }
+        return m;
+    }
+
+    public int compareTo(NumericMatrix matrix) {
+        return ArrayComparator.comparator.compare(vectors(),matrix.vectors());
+    }
+
+    public int compareTo(Numeric numeric) {
+        if(numeric instanceof NumericMatrix) {
+            return compareTo((NumericMatrix)numeric);
+        } else {
+            return compareTo(valueof(numeric));
+        }
+    }
+
+    public static NumericMatrix identity(int dimension) {
+        return identity(dimension,dimension);
+    }
+
+    public static NumericMatrix identity(int n, int p) {
+        NumericMatrix m=new NumericMatrix(new Numeric[n][p]);
+        for(int i=0;i<n;i++) {
+            for(int j=0;j<p;j++) {
+                if(i==j) {
+                    m.element[i][j]=JSCLDouble.valueOf(1);
+                } else {
+                    m.element[i][j]=JSCLDouble.valueOf(0);
+                }
+            }
+        }
+        return m;
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append("{");
+        for(int i=0;i<n;i++) {
+            buffer.append("{");
+            for(int j=0;j<p;j++) {
+                buffer.append(element[i][j]).append(j<p-1?", ":"");
+            }
+            buffer.append("}").append(i<n-1?",\n":"");
+        }
+        buffer.append("}");
+        return buffer.toString();
+    }
+
+    protected NumericMatrix newinstance() {
+        return newinstance(new Numeric[n][p]);
+    }
+
+    protected NumericMatrix newinstance(Numeric element[][]) {
+        return new NumericMatrix(element);
+    }
+}
diff --git a/src/misc/src/jscl/math/numeric/NumericVector.java b/src/misc/src/jscl/math/numeric/NumericVector.java
new file mode 100644
index 00000000..aa8e3ab2
--- /dev/null
+++ b/src/misc/src/jscl/math/numeric/NumericVector.java
@@ -0,0 +1,160 @@
+package jscl.math.numeric;
+
+import jscl.util.ArrayComparator;
+
+public class NumericVector extends Numeric {
+    protected final Numeric element[];
+    protected final int n;
+
+    public NumericVector(Numeric element[]) {
+        this.element=element;
+        n=element.length;
+    }
+
+    public Numeric[] elements() {
+        return element;
+    }
+
+    public NumericVector add(NumericVector vector) {
+        NumericVector v=(NumericVector)newinstance();
+        for(int i=0;i<n;i++) v.element[i]=element[i].add(vector.element[i]);
+        return v;
+    }
+
+    public Numeric add(Numeric numeric) {
+        if(numeric instanceof NumericVector) {
+            return add((NumericVector)numeric);
+        } else {
+            return add(valueof(numeric));
+        }
+    }
+
+    public NumericVector subtract(NumericVector vector) {
+        NumericVector v=(NumericVector)newinstance();
+        for(int i=0;i<n;i++) v.element[i]=element[i].subtract(vector.element[i]);
+        return v;
+    }
+
+    public Numeric subtract(Numeric numeric) {
+        if(numeric instanceof NumericVector) {
+            return subtract((NumericVector)numeric);
+        } else {
+            return subtract(valueof(numeric));
+        }
+    }
+
+    public Numeric multiply(Numeric numeric) {
+        if(numeric instanceof NumericVector) {
+            return scalarProduct((NumericVector)numeric);
+        } else if(numeric instanceof NumericMatrix) {
+            return ((NumericMatrix)numeric).transpose().multiply(this);
+        } else {
+            NumericVector v=(NumericVector)newinstance();
+            for(int i=0;i<n;i++) v.element[i]=element[i].multiply((Numeric)numeric);
+            return v;
+        }
+    }
+
+    public Numeric divide(Numeric numeric) throws ArithmeticException {
+        if(numeric instanceof NumericVector) {
+            throw new ArithmeticException();
+        } else if(numeric instanceof NumericMatrix) {
+            return multiply(((NumericMatrix)numeric).inverse());
+        } else {
+            NumericVector v=(NumericVector)newinstance();
+            for(int i=0;i<n;i++) {
+                v.element[i]=element[i].divide((Numeric)numeric);
+            }
+            return v;
+        }
+    }
+
+    public Numeric negate() {
+        NumericVector v=(NumericVector)newinstance();
+        for(int i=0;i<n;i++) v.element[i]=element[i].negate();
+        return v;
+    }
+
+    public int signum() {
+        for(int i=0;i<n;i++) {
+            int c=element[i].signum();
+            if(c<0) return -1;
+            else if(c>0) return 1;
+        }
+        return 0;
+    }
+
+    public Numeric valueof(Numeric numeric) {
+        if(numeric instanceof NumericVector ||  numeric instanceof NumericMatrix) {
+            throw new ArithmeticException();
+        } else {
+            NumericVector v=(NumericVector)unity(n).multiply(numeric);
+            return newinstance(v.element);
+        }
+    }
+
+    public Numeric magnitude2() {
+        return scalarProduct(this);
+    }
+
+    public Numeric scalarProduct(NumericVector vector) {
+        Numeric a=JSCLDouble.valueOf(0);
+        for(int i=0;i<n;i++) {
+            a=a.add(element[i].multiply(vector.element[i]));
+        }
+        return a;
+    }
+
+    public Numeric log() {
+        throw new ArithmeticException();
+    }
+
+    public Numeric exp() {
+        throw new ArithmeticException();
+    }
+
+    public Numeric conjugate() {
+        NumericVector v=(NumericVector)newinstance();
+        for(int i=0;i<n;i++) v.element[i]=element[i].conjugate();
+        return v;
+    }
+
+    public int compareTo(NumericVector vector) {
+        return ArrayComparator.comparator.compare(element,vector.element);
+    }
+
+    public int compareTo(Numeric numeric) {
+        if(numeric instanceof NumericVector) {
+            return compareTo((NumericVector)numeric);
+        } else {
+            return compareTo(valueof(numeric));
+        }
+    }
+
+    public static NumericVector unity(int dimension) {
+        NumericVector v=new NumericVector(new Numeric[dimension]);
+        for(int i=0;i<v.n;i++) {
+            if(i==0) v.element[i]=JSCLDouble.valueOf(1);
+            else v.element[i]=JSCLDouble.valueOf(0);
+        }
+        return v;
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append("{");
+        for(int i=0;i<n;i++) {
+            buffer.append(element[i]).append(i<n-1?", ":"");
+        }
+        buffer.append("}");
+        return buffer.toString();
+    }
+
+    protected NumericVector newinstance() {
+        return newinstance(new Numeric[n]);
+    }
+
+    protected NumericVector newinstance(Numeric element[]) {
+        return new NumericVector(element);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/Coefficient.java b/src/misc/src/jscl/math/operator/Coefficient.java
new file mode 100644
index 00000000..0b58a9ad
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/Coefficient.java
@@ -0,0 +1,24 @@
+package jscl.math.operator;
+
+import jscl.math.Generic;
+import jscl.math.JSCLVector;
+import jscl.math.Variable;
+import jscl.math.polynomial.Polynomial;
+
+public class Coefficient extends Operator {
+    public Coefficient(Generic expression, Generic variable) {
+        super("coef",new Generic[] {expression,variable});
+    }
+
+    public Generic compute() {
+        Variable variable=parameter[1].variableValue();
+        if(parameter[0].isPolynomial(variable)) {
+            return new JSCLVector(Polynomial.factory(variable).valueof(parameter[0]).elements());
+        }
+        return expressionValue();
+    }
+
+    protected Variable newinstance() {
+        return new Coefficient(null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/Derivative.java b/src/misc/src/jscl/math/operator/Derivative.java
new file mode 100644
index 00000000..33f1b614
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/Derivative.java
@@ -0,0 +1,112 @@
+package jscl.math.operator;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegerException;
+import jscl.math.Variable;
+import jscl.mathml.MathML;
+
+public class Derivative extends Operator {
+    public Derivative(Generic expression, Generic variable, Generic value, Generic order) {
+        super("d",new Generic[] {expression,variable,value,order});
+    }
+
+    public Generic compute() {
+        Variable variable=parameter[1].variableValue();
+        try {
+            int n=parameter[3].integerValue().intValue();
+            Generic a=parameter[0];
+            for(int i=0;i<n;i++) {
+                a=a.derivative(variable);
+            }
+            return a.substitute(variable,parameter[2]);
+        } catch (NotIntegerException e) {}
+        return expressionValue();
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        int n=4;
+        if(parameter[3].compareTo(JSCLInteger.valueOf(1))==0) {
+            n=3;
+            if(parameter[2].compareTo(parameter[1])==0) n=2;
+        }
+        buffer.append(name);
+        buffer.append("(");
+        for(int i=0;i<n;i++) {
+            buffer.append(parameter[i]).append(i<n-1?", ":"");
+        }
+        buffer.append(")");
+        return buffer.toString();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) derivationToMathML(element,false);
+        else {
+            MathML e1=element.element("msup");
+            derivationToMathML(e1,true);
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+        MathML e1=element.element("mfenced");
+        parameter[0].toMathML(e1,null);
+        if(parameter[2].compareTo(parameter[1])!=0) parameter[2].toMathML(e1,null);
+        element.appendChild(e1);
+    }
+
+    void derivationToMathML(MathML element, boolean fenced) {
+        if(fenced) {
+            MathML e1=element.element("mfenced");
+            derivationToMathML(e1);
+            element.appendChild(e1);
+        } else {
+            derivationToMathML(element);
+        }
+    }
+
+    void derivationToMathML(MathML element) {
+        Variable v=parameter[1].variableValue();
+        int n=0;
+        try {
+            n=parameter[3].integerValue().intValue();
+        } catch (NotIntegerException e) {}
+        if(n==1) {
+            MathML e1=element.element("mfrac");
+            MathML e2=element.element("mo");
+            e2.appendChild(element.text(/*"\u2146"*/"d"));
+            e1.appendChild(e2);
+            e2=element.element("mrow");
+            MathML e3=element.element("mo");
+            e3.appendChild(element.text(/*"\u2146"*/"d"));
+            e2.appendChild(e3);
+            v.toMathML(e2,null);
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        } else {
+            MathML e1=element.element("mfrac");
+            MathML e2=element.element("msup");
+            MathML e3=element.element("mo");
+            e3.appendChild(element.text(/*"\u2146"*/"d"));
+            e2.appendChild(e3);
+            parameter[3].toMathML(e2,null);
+            e1.appendChild(e2);
+            e2=element.element("mrow");
+            e3=element.element("mo");
+            e3.appendChild(element.text(/*"\u2146"*/"d"));
+            e2.appendChild(e3);
+            e3=element.element("msup");
+            parameter[1].toMathML(e3,null);
+            parameter[3].toMathML(e3,null);
+            e2.appendChild(e3);
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+
+    protected Variable newinstance() {
+        return new Derivative(null,null,null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/Division.java b/src/misc/src/jscl/math/operator/Division.java
new file mode 100644
index 00000000..014984ac
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/Division.java
@@ -0,0 +1,18 @@
+package jscl.math.operator;
+
+import jscl.math.Generic;
+import jscl.math.Variable;
+
+public class Division extends Operator {
+    public Division(Generic expression1, Generic expression2) {
+        super("div",new Generic[] {expression1,expression2});
+    }
+
+    public Generic compute() {
+        return parameter[0].divideAndRemainder(parameter[1])[0];
+    }
+
+    protected Variable newinstance() {
+        return new Division(null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/Factorial.java b/src/misc/src/jscl/math/operator/Factorial.java
new file mode 100644
index 00000000..5d0c7b0d
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/Factorial.java
@@ -0,0 +1,98 @@
+package jscl.math.operator;
+
+import jscl.math.Generic;
+import jscl.math.GenericVariable;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegerException;
+import jscl.math.NotVariableException;
+import jscl.math.Variable;
+import jscl.math.function.Frac;
+import jscl.math.function.Pow;
+import jscl.mathml.MathML;
+import jscl.util.ArrayComparator;
+
+public class Factorial extends Operator {
+    public Factorial(Generic expression) {
+        super("",new Generic[] {expression});
+    }
+
+    public Generic compute() {
+        try {
+            int n=parameter[0].integerValue().intValue();
+            Generic a=JSCLInteger.valueOf(1);
+            for(int i=0;i<n;i++) {
+                a=a.multiply(JSCLInteger.valueOf(i+1));
+            }
+            return a;
+        } catch (NotIntegerException e) {}
+        return expressionValue();
+    }
+
+    public int compareTo(Variable variable) {
+        if(this==variable) return 0;
+        int c=comparator.compare(this,variable);
+        if(c<0) return -1;
+        else if(c>0) return 1;
+        else {
+            Factorial v=(Factorial)variable;
+            return ArrayComparator.comparator.compare(parameter,v.parameter);
+        }
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        try {
+            JSCLInteger en=parameter[0].integerValue();
+            buffer.append(en);
+        } catch (NotIntegerException e) {
+            try {
+                Variable v=parameter[0].variableValue();
+                if(v instanceof Frac || v instanceof Pow) {
+                    buffer.append(GenericVariable.valueOf(parameter[0]));
+                } else buffer.append(v);
+            } catch (NotVariableException e2) {
+                buffer.append(GenericVariable.valueOf(parameter[0]));
+            }
+        }
+        buffer.append("!");
+        return buffer.toString();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) bodyToMathML(element);
+        else {
+            MathML e1=element.element("msup");
+            bodyToMathML(e1);
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+
+    void bodyToMathML(MathML element) {
+        MathML e1=element.element("mrow");
+        try {
+            JSCLInteger en=parameter[0].integerValue();
+            en.toMathML(e1,null);
+        } catch (NotIntegerException e) {
+            try {
+                Variable v=parameter[0].variableValue();
+                if(v instanceof Pow) {
+                    GenericVariable.valueOf(parameter[0]).toMathML(e1,null);
+                } else v.toMathML(e1,null);
+            } catch (NotVariableException e2) {
+                GenericVariable.valueOf(parameter[0]).toMathML(e1,null);
+            }
+        }
+        MathML e2=element.element("mo");
+        e2.appendChild(element.text("!"));
+        e1.appendChild(e2);
+        element.appendChild(e1);
+    }
+
+    protected Variable newinstance() {
+        return new Factorial(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/Groebner.java b/src/misc/src/jscl/math/operator/Groebner.java
new file mode 100644
index 00000000..52d9e427
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/Groebner.java
@@ -0,0 +1,138 @@
+package jscl.math.operator;
+
+import jscl.math.Generic;
+import jscl.math.GenericVariable;
+import jscl.math.JSCLInteger;
+import jscl.math.JSCLVector;
+import jscl.math.Variable;
+import jscl.math.function.Constant;
+import jscl.math.function.ImplicitFunction;
+import jscl.math.polynomial.Basis;
+import jscl.math.polynomial.Monomial;
+import jscl.math.polynomial.Ordering;
+import jscl.math.polynomial.Polynomial;
+import jscl.mathml.MathML;
+
+public class Groebner extends Operator {
+    public Groebner(Generic generic, Generic variable, Generic ordering, Generic modulo) {
+        super("groebner",new Generic[] {generic,variable,ordering,modulo});
+    }
+
+    public Generic compute() {
+        Generic generic[]=((JSCLVector)parameter[0]).elements();
+        Variable variable[]=variables(parameter[1]);
+        Ordering ord=ordering(parameter[2]);
+        int m=parameter[3].integerValue().intValue();
+        return new PolynomialVector(Basis.compute(generic,variable,ord,m));
+    }
+
+    public Operator transmute() {
+        Generic p[]=new Generic[] {GenericVariable.content(parameter[0]),GenericVariable.content(parameter[1])};
+        if(p[0] instanceof JSCLVector && p[1] instanceof JSCLVector) {
+            Generic generic[]=((JSCLVector)p[0]).elements();
+            Variable variable[]=variables(p[1]);
+            Ordering ord=ordering(parameter[2]);
+            int m=parameter[3].integerValue().intValue();
+            return new Groebner(new PolynomialVector(new Basis(generic,Polynomial.factory(variable,ord,m))),p[1],parameter[2],parameter[3]);
+        }
+        return this;
+    }
+
+    static Ordering ordering(Generic generic) {
+        Variable v=generic.variableValue();
+        if(v.compareTo(new Constant("lex"))==0) return Monomial.lexicographic;
+        else if(v.compareTo(new Constant("tdl"))==0) return Monomial.totalDegreeLexicographic;
+        else if(v.compareTo(new Constant("drl"))==0) return Monomial.degreeReverseLexicographic;
+        else if(v instanceof ImplicitFunction) {
+            Generic g[]=((ImplicitFunction)v).parameters();
+            int k=g[0].integerValue().intValue();
+            if(v.compareTo(new ImplicitFunction("elim",new Generic[] {JSCLInteger.valueOf(k)},new int[] {0},new Generic[] {}))==0) return Monomial.kthElimination(k);
+        }
+        throw new ArithmeticException();
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        int n=4;
+        if(parameter[3].signum()==0) {
+            n=3;
+            if(ordering(parameter[2])==Monomial.lexicographic) n=2;
+        }
+        buffer.append(name);
+        buffer.append("(");
+        for(int i=0;i<n;i++) {
+            buffer.append(parameter[i]).append(i<n-1?", ":"");
+        }
+        buffer.append(")");
+        return buffer.toString();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        MathML e1;
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        int n=4;
+        if(parameter[3].signum()==0) {
+            n=3;
+            if(ordering(parameter[2])==Monomial.lexicographic) n=2;
+        }
+        if(exponent==1) nameToMathML(element);
+        else {
+            e1=element.element("msup");
+            nameToMathML(e1);
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+        e1=element.element("mfenced");
+        for(int i=0;i<n;i++) {
+            parameter[i].toMathML(e1,null);
+        }
+        element.appendChild(e1);
+    }
+
+    protected Variable newinstance() {
+        return new Groebner(null,null,null,null);
+    }
+}
+
+class PolynomialVector extends JSCLVector {
+    final Basis basis;
+
+    PolynomialVector(Basis basis) {
+        this(basis,basis.elements());
+    }
+
+    PolynomialVector(Basis basis, Generic generic[]) {
+        super(generic.length>0?generic:new Generic[] {JSCLInteger.valueOf(0)});
+        this.basis=basis;
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append("{");
+        for(int i=0;i<n;i++) {
+            buffer.append(basis.polynomial(element[i])).append(i<n-1?", ":"");
+        }
+        buffer.append("}");
+        return buffer.toString();
+    }
+
+    protected void bodyToMathML(MathML e0) {
+        MathML e1=e0.element("mfenced");
+        MathML e2=e0.element("mtable");
+        for(int i=0;i<n;i++) {
+            MathML e3=e0.element("mtr");
+            MathML e4=e0.element("mtd");
+            basis.polynomial(element[i]).toMathML(e4,null);
+            e3.appendChild(e4);
+            e2.appendChild(e3);
+        }
+        e1.appendChild(e2);
+        e0.appendChild(e1);
+    }
+
+    protected Generic newinstance(Generic element[]) {
+        return new PolynomialVector(basis,element);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/IndefiniteIntegral.java b/src/misc/src/jscl/math/operator/IndefiniteIntegral.java
new file mode 100644
index 00000000..ed070fd8
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/IndefiniteIntegral.java
@@ -0,0 +1,53 @@
+package jscl.math.operator;
+
+import jscl.math.Generic;
+import jscl.math.NotIntegrableException;
+import jscl.math.Variable;
+import jscl.mathml.MathML;
+
+public class IndefiniteIntegral extends Operator {
+    public IndefiniteIntegral(Generic expression, Generic variable) {
+        super("integral",new Generic[] {expression,variable});
+    }
+
+    public Generic compute() {
+        Variable variable=parameter[1].variableValue();
+        try {
+            return parameter[0].antiderivative(variable);
+        } catch (NotIntegrableException e) {}
+        return expressionValue();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) bodyToMathML(element);
+        else {
+            MathML e1=element.element("msup");
+            MathML e2=element.element("mfenced");
+            bodyToMathML(e2);
+            e1.appendChild(e2);
+            e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+
+    void bodyToMathML(MathML element) {
+        Variable v=parameter[1].variableValue();
+        MathML e1=element.element("mrow");
+        MathML e2=element.element("mo");
+        e2.appendChild(element.text("\u222B"));
+        e1.appendChild(e2);
+        parameter[0].toMathML(e1,null);
+        e2=element.element("mo");
+        e2.appendChild(element.text(/*"\u2146"*/"d"));
+        e1.appendChild(e2);
+        v.toMathML(e1,null);
+        element.appendChild(e1);
+    }
+
+    protected Variable newinstance() {
+        return new IndefiniteIntegral(null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/Integral.java b/src/misc/src/jscl/math/operator/Integral.java
new file mode 100644
index 00000000..64275c31
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/Integral.java
@@ -0,0 +1,58 @@
+package jscl.math.operator;
+
+import jscl.math.Generic;
+import jscl.math.NotIntegrableException;
+import jscl.math.Variable;
+import jscl.mathml.MathML;
+
+public class Integral extends Operator {
+    public Integral(Generic expression, Generic variable, Generic n1, Generic n2) {
+        super("integral",new Generic[] {expression,variable,n1,n2});
+    }
+
+    public Generic compute() {
+        Variable variable=parameter[1].variableValue();
+        try {
+            Generic a=parameter[0].antiderivative(variable);
+            return a.substitute(variable,parameter[3]).subtract(a.substitute(variable,parameter[2]));
+        } catch (NotIntegrableException e) {}
+        return expressionValue();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) bodyToMathML(element);
+        else {
+            MathML e1=element.element("msup");
+            MathML e2=element.element("mfenced");
+            bodyToMathML(e2);
+            e1.appendChild(e2);
+            e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+
+    void bodyToMathML(MathML element) {
+        Variable v=parameter[1].variableValue();
+        MathML e1=element.element("mrow");
+        MathML e2=element.element("msubsup");
+        MathML e3=element.element("mo");
+        e3.appendChild(element.text("\u222B"));
+        e2.appendChild(e3);
+        parameter[2].toMathML(e2,null);
+        parameter[3].toMathML(e2,null);
+        e1.appendChild(e2);
+        parameter[0].toMathML(e1,null);
+        e2=element.element("mo");
+        e2.appendChild(element.text(/*"\u2146"*/"d"));
+        e1.appendChild(e2);
+        v.toMathML(e1,null);
+        element.appendChild(e1);
+    }
+
+    protected Variable newinstance() {
+        return new Integral(null,null,null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/Limit.java b/src/misc/src/jscl/math/operator/Limit.java
new file mode 100644
index 00000000..c73c20f7
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/Limit.java
@@ -0,0 +1,75 @@
+package jscl.math.operator;
+
+import jscl.math.Generic;
+import jscl.math.Variable;
+import jscl.mathml.MathML;
+
+public class Limit extends Operator {
+    public Limit(Generic expression, Generic variable, Generic limit, Generic direction) {
+        super("lim",new Generic[] {expression,variable,limit,direction});
+    }
+
+    public Generic compute() {
+        return expressionValue();
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        int n=4;
+        if(parameter[3].signum()==0) n=3;
+        buffer.append(name);
+        buffer.append("(");
+        for(int i=0;i<n;i++) {
+            buffer.append(parameter[i]).append(i<n-1?", ":"");
+        }
+        buffer.append(")");
+        return buffer.toString();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) bodyToMathML(element);
+        else {
+            MathML e1=element.element("msup");
+            MathML e2=element.element("mfenced");
+            bodyToMathML(e2);
+            e1.appendChild(e2);
+            e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+
+    void bodyToMathML(MathML element) {
+        int c=parameter[3].signum();
+        MathML e1=element.element("mrow");
+        MathML e2=element.element("munder");
+        MathML e3=element.element("mo");
+        e3.appendChild(element.text("lim"));
+        e2.appendChild(e3);
+        e3=element.element("mrow");
+        parameter[1].toMathML(e3,null);
+        MathML e4=element.element("mo");
+        e4.appendChild(element.text("\u2192"));
+        e3.appendChild(e4);
+        if(c==0) parameter[2].toMathML(e3,null);
+        else {
+            e4=element.element("msup");
+            parameter[2].toMathML(e4,null);
+            MathML e5=element.element("mo");
+            if(c<0) e5.appendChild(element.text("-"));
+            else if(c>0) e5.appendChild(element.text("+"));
+            e4.appendChild(e5);
+            e3.appendChild(e4);
+        }
+        e2.appendChild(e3);
+        e1.appendChild(e2);
+        parameter[0].toMathML(e1,null);
+        element.appendChild(e1);
+    }
+
+    protected Variable newinstance() {
+        return new Limit(null,null,null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/Modulo.java b/src/misc/src/jscl/math/operator/Modulo.java
new file mode 100644
index 00000000..2325f649
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/Modulo.java
@@ -0,0 +1,25 @@
+package jscl.math.operator;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegerException;
+import jscl.math.Variable;
+
+public class Modulo extends Operator {
+    public Modulo(Generic expression1, Generic expression2) {
+        super("mod",new Generic[] {expression1,expression2});
+    }
+
+    public Generic compute() {
+        try {
+            JSCLInteger en=parameter[0].integerValue();
+            JSCLInteger en2=parameter[1].integerValue();
+            return en.mod(en2);
+        } catch (NotIntegerException e) {}
+        return parameter[0].remainder(parameter[1]);
+    }
+
+    protected Variable newinstance() {
+        return new Modulo(null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/Operator.java b/src/misc/src/jscl/math/operator/Operator.java
new file mode 100644
index 00000000..b36d2e75
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/Operator.java
@@ -0,0 +1,140 @@
+package jscl.math.operator;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.JSCLVector;
+import jscl.math.NotIntegrableException;
+import jscl.math.NotVariableException;
+import jscl.math.Variable;
+import jscl.mathml.MathML;
+import jscl.util.ArrayComparator;
+
+public abstract class Operator extends Variable {
+    protected Generic parameter[];
+
+    public Operator(String name, Generic parameter[]) {
+        super(name);
+        this.parameter=parameter;
+    }
+
+    public Generic[] parameters() {
+        return parameter;
+    }
+
+    public abstract Generic compute();
+
+    public Generic antiderivative(Variable variable) throws NotIntegrableException {
+        return null;
+    }
+
+    public Generic derivative(Variable variable) {
+        if(isIdentity(variable)) return JSCLInteger.valueOf(1);
+        else return JSCLInteger.valueOf(0);
+    }
+
+    public Generic substitute(Variable variable, Generic generic) {
+        Operator v=(Operator)newinstance();
+        for(int i=0;i<parameter.length;i++) {
+            v.parameter[i]=parameter[i].substitute(variable,generic);
+        }
+        if(v.isIdentity(variable)) return generic;
+        else return v.compute();
+    }
+
+    public Generic expand() {
+        Operator v=(Operator)newinstance();
+        for(int i=0;i<parameter.length;i++) {
+            v.parameter[i]=parameter[i].expand();
+        }
+        return v.compute();
+    }
+
+    public Generic factorize() {
+        Operator v=(Operator)newinstance();
+        for(int i=0;i<parameter.length;i++) {
+            v.parameter[i]=parameter[i].factorize();
+        }
+        return v.expressionValue();
+    }
+
+    public Generic elementary() {
+        Operator v=(Operator)newinstance();
+        for(int i=0;i<parameter.length;i++) {
+            v.parameter[i]=parameter[i].elementary();
+        }
+        return v.expressionValue();
+    }
+
+    public Generic simplify() {
+        Operator v=(Operator)newinstance();
+        for(int i=0;i<parameter.length;i++) {
+            v.parameter[i]=parameter[i].simplify();
+        }
+        return v.expressionValue();
+    }
+
+    public Generic numeric() {
+        throw new ArithmeticException();
+    }
+
+    public boolean isConstant(Variable variable) {
+        return !isIdentity(variable);
+    }
+
+    public int compareTo(Variable variable) {
+        if(this==variable) return 0;
+        int c=comparator.compare(this,variable);
+        if(c<0) return -1;
+        else if(c>0) return 1;
+        else {
+            Operator v=(Operator)variable;
+            c=name.compareTo(v.name);
+            if(c<0) return -1;
+            else if(c>0) return 1;
+            else return ArrayComparator.comparator.compare(parameter,v.parameter);
+        }
+    }
+
+    protected static Variable[] variables(Generic generic) throws NotVariableException {
+        Generic element[]=((JSCLVector)generic).elements();
+        Variable variable[]=new Variable[element.length];
+        for(int i=0;i<element.length;i++) {
+            variable[i]=element[i].variableValue();
+        }
+        return variable;
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append(name);
+        buffer.append("(");
+        for(int i=0;i<parameter.length;i++) {
+            buffer.append(parameter[i]).append(i<parameter.length-1?", ":"");
+        }
+        buffer.append(")");
+        return buffer.toString();
+    }
+
+    public String toJava() {
+        throw new ArithmeticException();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        MathML e1;
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) nameToMathML(element);
+        else {
+            e1=element.element("msup");
+            nameToMathML(e1);
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+        e1=element.element("mfenced");
+        for(int i=0;i<parameter.length;i++) {
+            parameter[i].toMathML(e1,null);
+        }
+        element.appendChild(e1);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/Product.java b/src/misc/src/jscl/math/operator/Product.java
new file mode 100644
index 00000000..2520743c
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/Product.java
@@ -0,0 +1,65 @@
+package jscl.math.operator;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegerException;
+import jscl.math.Variable;
+import jscl.mathml.MathML;
+
+public class Product extends Operator {
+    public Product(Generic expression, Generic variable, Generic n1, Generic n2) {
+        super("prod",new Generic[] {expression,variable,n1,n2});
+    }
+
+    public Generic compute() {
+        Variable variable=parameter[1].variableValue();
+        try {
+            int n1=parameter[2].integerValue().intValue();
+            int n2=parameter[3].integerValue().intValue();
+            Generic a=JSCLInteger.valueOf(1);
+            for(int i=n1;i<=n2;i++) {
+                a=a.multiply(parameter[0].substitute(variable,JSCLInteger.valueOf(i)));
+            }
+            return a;
+        } catch (NotIntegerException e) {}
+        return expressionValue();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) bodyToMathML(element);
+        else {
+            MathML e1=element.element("msup");
+            MathML e2=element.element("mfenced");
+            bodyToMathML(e2);
+            e1.appendChild(e2);
+            e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+
+    void bodyToMathML(MathML element) {
+        MathML e1=element.element("mrow");
+        MathML e2=element.element("munderover");
+        MathML e3=element.element("mo");
+        e3.appendChild(element.text("\u220F"));
+        e2.appendChild(e3);
+        e3=element.element("mrow");
+        parameter[1].toMathML(e3,null);
+        MathML e4=element.element("mo");
+        e4.appendChild(element.text("="));
+        e3.appendChild(e4);
+        parameter[2].toMathML(e3,null);
+        e2.appendChild(e3);
+        parameter[3].toMathML(e2,null);
+        e1.appendChild(e2);
+        parameter[0].toMathML(e1,null);
+        element.appendChild(e1);
+    }
+
+    protected Variable newinstance() {
+        return new Product(null,null,null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/Solve.java b/src/misc/src/jscl/math/operator/Solve.java
new file mode 100644
index 00000000..7931169d
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/Solve.java
@@ -0,0 +1,61 @@
+package jscl.math.operator;
+
+import jscl.math.Generic;
+import jscl.math.Variable;
+import jscl.math.function.Root;
+import jscl.math.polynomial.Polynomial;
+import jscl.math.polynomial.UnivariatePolynomial;
+import jscl.mathml.MathML;
+
+public class Solve extends Operator {
+    public Solve(Generic expression, Generic variable, Generic subscript) {
+        super("solve",new Generic[] {expression,variable,subscript});
+    }
+
+    public Generic compute() {
+        Variable variable=parameter[1].variableValue();
+        int subscript=parameter[2].integerValue().intValue();
+        if(parameter[0].isPolynomial(variable)) {
+            return new Root((UnivariatePolynomial)Polynomial.factory(variable).valueof(parameter[0]),subscript).evaluate();
+        }
+        return expressionValue();
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        int n=3;
+        if(parameter[2].signum()==0) n=2;
+        buffer.append(name);
+        buffer.append("(");
+        for(int i=0;i<n;i++) {
+            buffer.append(parameter[i]).append(i<n-1?", ":"");
+        }
+        buffer.append(")");
+        return buffer.toString();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        MathML e1;
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        int n=3;
+        if(parameter[2].signum()==0) n=2;
+        if(exponent==1) nameToMathML(element);
+        else {
+            e1=element.element("msup");
+            nameToMathML(e1);
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+        e1=element.element("mfenced");
+        for(int i=0;i<n;i++) {
+            parameter[i].toMathML(e1,null);
+        }
+        element.appendChild(e1);
+    }
+
+    protected Variable newinstance() {
+        return new Solve(null,null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/Substitute.java b/src/misc/src/jscl/math/operator/Substitute.java
new file mode 100644
index 00000000..ae05e1ea
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/Substitute.java
@@ -0,0 +1,41 @@
+package jscl.math.operator;
+
+import jscl.math.Generic;
+import jscl.math.GenericVariable;
+import jscl.math.JSCLVector;
+import jscl.math.Variable;
+
+public class Substitute extends Operator {
+    public Substitute(Generic expression, Generic variable, Generic value) {
+        super("subst",new Generic[] {expression,variable,value});
+    }
+
+    public Generic compute() {
+        if(parameter[1] instanceof JSCLVector && parameter[2] instanceof JSCLVector) {
+            Generic a=parameter[0];
+            Variable variable[]=variables(parameter[1]);
+            Generic s[]=((JSCLVector)parameter[2]).elements();
+            for(int i=0;i<variable.length;i++) a=a.substitute(variable[i],s[i]);
+            return a;
+        } else {
+            Variable variable=parameter[1].variableValue();
+            return parameter[0].substitute(variable,parameter[2]);
+        }
+    }
+
+    public Operator transmute() {
+        Generic p[]=new Generic[] {null,GenericVariable.content(parameter[1]),GenericVariable.content(parameter[2])};
+        if(p[1] instanceof JSCLVector && p[2] instanceof JSCLVector) {
+            return new Substitute(parameter[0],p[1],p[2]);
+        }
+        return this;
+    }
+
+    public Generic expand() {
+        return compute();
+    }
+
+    protected Variable newinstance() {
+        return new Substitute(null,null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/Sum.java b/src/misc/src/jscl/math/operator/Sum.java
new file mode 100644
index 00000000..924db256
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/Sum.java
@@ -0,0 +1,65 @@
+package jscl.math.operator;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegerException;
+import jscl.math.Variable;
+import jscl.mathml.MathML;
+
+public class Sum extends Operator {
+    public Sum(Generic expression, Generic variable, Generic n1, Generic n2) {
+        super("sum",new Generic[] {expression,variable,n1,n2});
+    }
+
+    public Generic compute() {
+        Variable variable=parameter[1].variableValue();
+        try {
+            int n1=parameter[2].integerValue().intValue();
+            int n2=parameter[3].integerValue().intValue();
+            Generic a=JSCLInteger.valueOf(0);
+            for(int i=n1;i<=n2;i++) {
+                a=a.add(parameter[0].substitute(variable,JSCLInteger.valueOf(i)));
+            }
+            return a;
+        } catch (NotIntegerException e) {}
+        return expressionValue();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) bodyToMathML(element);
+        else {
+            MathML e1=element.element("msup");
+            MathML e2=element.element("mfenced");
+            bodyToMathML(e2);
+            e1.appendChild(e2);
+            e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+
+    void bodyToMathML(MathML element) {
+        MathML e1=element.element("mrow");
+        MathML e2=element.element("munderover");
+        MathML e3=element.element("mo");
+        e3.appendChild(element.text("\u2211"));
+        e2.appendChild(e3);
+        e3=element.element("mrow");
+        parameter[1].toMathML(e3,null);
+        MathML e4=element.element("mo");
+        e4.appendChild(element.text("="));
+        e3.appendChild(e4);
+        parameter[2].toMathML(e3,null);
+        e2.appendChild(e3);
+        parameter[3].toMathML(e2,null);
+        e1.appendChild(e2);
+        parameter[0].toMathML(e1,null);
+        element.appendChild(e1);
+    }
+
+    protected Variable newinstance() {
+        return new Sum(null,null,null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/VectorOperator.java b/src/misc/src/jscl/math/operator/VectorOperator.java
new file mode 100644
index 00000000..649cd853
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/VectorOperator.java
@@ -0,0 +1,40 @@
+package jscl.math.operator;
+
+import jscl.math.Generic;
+import jscl.math.GenericVariable;
+import jscl.math.Variable;
+import jscl.math.function.Constant;
+import jscl.mathml.MathML;
+
+public abstract class VectorOperator extends Operator {
+    public VectorOperator(String name, Generic parameter[]) {
+        super(name,parameter);
+    }
+
+    public void toMathML(MathML element, Object data) {
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) bodyToMathML(element);
+        else {
+            MathML e1=element.element("msup");
+            MathML e2=element.element("mfenced");
+            bodyToMathML(e2);
+            e1.appendChild(e2);
+            e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+
+    protected abstract void bodyToMathML(MathML element);
+
+    protected void operator(MathML element, String name) {
+        Variable variable[]=variables(GenericVariable.content(parameter[1]));
+        MathML e1=element.element("msub");
+        new Constant(name).toMathML(e1,null);
+        MathML e2=element.element("mrow");
+        for(int i=0;i<variable.length;i++) variable[i].expressionValue().toMathML(e2,null);
+        e1.appendChild(e2);
+        element.appendChild(e1);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/matrix/Determinant.java b/src/misc/src/jscl/math/operator/matrix/Determinant.java
new file mode 100644
index 00000000..fe98b2e3
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/matrix/Determinant.java
@@ -0,0 +1,61 @@
+package jscl.math.operator.matrix;
+
+import jscl.math.Generic;
+import jscl.math.GenericVariable;
+import jscl.math.Matrix;
+import jscl.math.Variable;
+import jscl.math.operator.Operator;
+import jscl.mathml.MathML;
+
+public class Determinant extends Operator {
+    public Determinant(Generic matrix) {
+        super("det",new Generic[] {matrix});
+    }
+
+    public Generic compute() {
+        if(parameter[0] instanceof Matrix) {
+            Matrix matrix=(Matrix)parameter[0];
+            return matrix.determinant();
+        }
+        return expressionValue();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) bodyToMathML(element);
+        else {
+            MathML e1=element.element("msup");
+            bodyToMathML(e1);
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+
+    void bodyToMathML(MathML e0) {
+        Generic m=GenericVariable.content(parameter[0]);
+        MathML e1=e0.element("mfenced");
+        e1.setAttribute("open","|");
+        e1.setAttribute("close","|");
+        if(m instanceof Matrix) {
+            Generic element[][]=((Matrix)m).elements();
+            MathML e2=e0.element("mtable");
+            for(int i=0;i<element.length;i++) {
+                MathML e3=e0.element("mtr");
+                for(int j=0;j<element.length;j++) {
+                    MathML e4=e0.element("mtd");
+                    element[i][j].toMathML(e4,null);
+                    e3.appendChild(e4);
+                }
+                e2.appendChild(e3);
+            }
+            e1.appendChild(e2);
+        } else m.toMathML(e1,null);
+        e0.appendChild(e1);
+    }
+
+    protected Variable newinstance() {
+        return new Determinant(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/matrix/Trace.java b/src/misc/src/jscl/math/operator/matrix/Trace.java
new file mode 100644
index 00000000..3ba2906d
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/matrix/Trace.java
@@ -0,0 +1,45 @@
+package jscl.math.operator.matrix;
+
+import jscl.math.Generic;
+import jscl.math.Matrix;
+import jscl.math.Variable;
+import jscl.math.operator.Operator;
+import jscl.mathml.MathML;
+
+public class Trace extends Operator {
+    public Trace(Generic matrix) {
+        super("trace",new Generic[] {matrix});
+    }
+
+    public Generic compute() {
+        if(parameter[0] instanceof Matrix) {
+            Matrix matrix=(Matrix)parameter[0];
+            return matrix.trace();
+        }
+        return expressionValue();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) {
+            MathML e1=element.element("mo");
+            e1.appendChild(element.text("tr"));
+            element.appendChild(e1);
+        }
+        else {
+            MathML e1=element.element("msup");
+            MathML e2=element.element("mo");
+            e2.appendChild(element.text("tr"));
+            e1.appendChild(e2);
+            e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+        parameter[0].toMathML(element,null);
+    }
+
+    protected Variable newinstance() {
+        return new Trace(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/matrix/Transpose.java b/src/misc/src/jscl/math/operator/matrix/Transpose.java
new file mode 100644
index 00000000..03fa91f1
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/matrix/Transpose.java
@@ -0,0 +1,47 @@
+package jscl.math.operator.matrix;
+
+import jscl.math.Generic;
+import jscl.math.Matrix;
+import jscl.math.Variable;
+import jscl.math.operator.Operator;
+import jscl.mathml.MathML;
+
+public class Transpose extends Operator {
+    public Transpose(Generic matrix) {
+        super("tran",new Generic[] {matrix});
+    }
+
+    public Generic compute() {
+        if(parameter[0] instanceof Matrix) {
+            Matrix matrix=(Matrix)parameter[0];
+            return matrix.transpose();
+        }
+        return expressionValue();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        int exponent=data instanceof Integer?((Integer)data).intValue():1;
+        if(exponent==1) bodyToMathML(element);
+        else {
+            MathML e1=element.element("msup");
+            bodyToMathML(e1);
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text(String.valueOf(exponent)));
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+
+    void bodyToMathML(MathML element) {
+        MathML e1=element.element("msup");
+        parameter[0].toMathML(e1,null);
+        MathML e2=element.element("mo");
+        e2.appendChild(element.text("T"));
+        e1.appendChild(e2);
+        element.appendChild(e1);
+    }
+
+    protected Variable newinstance() {
+        return new Transpose(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/number/EulerPhi.java b/src/misc/src/jscl/math/operator/number/EulerPhi.java
new file mode 100644
index 00000000..74162eb5
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/number/EulerPhi.java
@@ -0,0 +1,32 @@
+package jscl.math.operator.number;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegerException;
+import jscl.math.Variable;
+import jscl.math.operator.Operator;
+import jscl.mathml.MathML;
+
+public class EulerPhi extends Operator {
+    public EulerPhi(Generic integer) {
+        super("eulerphi",new Generic[] {integer});
+    }
+
+    public Generic compute() {
+        try {
+            JSCLInteger en=parameter[0].integerValue();
+            return en.phi();
+        } catch (NotIntegerException e) {}
+        return expressionValue();
+    }
+
+    protected void nameToMathML(MathML element) {
+        MathML e1=element.element("mi");
+        e1.appendChild(element.text("\u03C6"));
+        element.appendChild(e1);
+    }
+
+    protected Variable newinstance() {
+        return new EulerPhi(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/number/ModInverse.java b/src/misc/src/jscl/math/operator/number/ModInverse.java
new file mode 100644
index 00000000..8124dbcd
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/number/ModInverse.java
@@ -0,0 +1,26 @@
+package jscl.math.operator.number;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegerException;
+import jscl.math.Variable;
+import jscl.math.operator.Operator;
+
+public class ModInverse extends Operator {
+    public ModInverse(Generic integer, Generic modulo) {
+        super("modinv",new Generic[] {integer,modulo});
+    }
+
+    public Generic compute() {
+        try {
+            JSCLInteger en=parameter[0].integerValue();
+            JSCLInteger modulo=parameter[1].integerValue();
+            return en.modInverse(modulo);
+        } catch (NotIntegerException e) {}
+        return expressionValue();
+    }
+
+    protected Variable newinstance() {
+        return new ModInverse(null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/number/ModPow.java b/src/misc/src/jscl/math/operator/number/ModPow.java
new file mode 100644
index 00000000..7c464987
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/number/ModPow.java
@@ -0,0 +1,27 @@
+package jscl.math.operator.number;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegerException;
+import jscl.math.Variable;
+import jscl.math.operator.Operator;
+
+public class ModPow extends Operator {
+    public ModPow(Generic integer, Generic exponent, Generic modulo) {
+        super("modpow",new Generic[] {integer,exponent,modulo});
+    }
+
+    public Generic compute() {
+        try {
+            JSCLInteger en=parameter[0].integerValue();
+            JSCLInteger exponent=parameter[1].integerValue();
+            JSCLInteger modulo=parameter[2].integerValue();
+            return en.modPow(exponent,modulo);
+        } catch (NotIntegerException e) {}
+        return expressionValue();
+    }
+
+    protected Variable newinstance() {
+        return new ModPow(null,null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/number/PrimitiveRoots.java b/src/misc/src/jscl/math/operator/number/PrimitiveRoots.java
new file mode 100644
index 00000000..024d634a
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/number/PrimitiveRoots.java
@@ -0,0 +1,27 @@
+package jscl.math.operator.number;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.JSCLVector;
+import jscl.math.NotIntegerException;
+import jscl.math.Variable;
+import jscl.math.operator.Operator;
+
+public class PrimitiveRoots extends Operator {
+    public PrimitiveRoots(Generic integer) {
+        super("primitiveroots",new Generic[] {integer});
+    }
+
+    public Generic compute() {
+        try {
+            JSCLInteger en=parameter[0].integerValue();
+            Generic a[]=en.primitiveRoots();
+            return new JSCLVector(a.length>0?a:new Generic[] {JSCLInteger.valueOf(0)});
+        } catch (NotIntegerException e) {}
+        return expressionValue();
+    }
+
+    protected Variable newinstance() {
+        return new PrimitiveRoots(null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/product/ComplexProduct.java b/src/misc/src/jscl/math/operator/product/ComplexProduct.java
new file mode 100644
index 00000000..ed0a47ec
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/product/ComplexProduct.java
@@ -0,0 +1,31 @@
+package jscl.math.operator.product;
+
+import jscl.math.Generic;
+import jscl.math.JSCLVector;
+import jscl.math.Variable;
+import jscl.math.operator.VectorOperator;
+import jscl.mathml.MathML;
+
+public class ComplexProduct extends VectorOperator {
+    public ComplexProduct(Generic vector1, Generic vector2) {
+        super("complex",new Generic[] {vector1,vector2});
+    }
+
+    public Generic compute() {
+        if(parameter[0] instanceof JSCLVector && parameter[1] instanceof JSCLVector) {
+            JSCLVector v1=(JSCLVector)parameter[0];
+            JSCLVector v2=(JSCLVector)parameter[1];
+            return v1.complexProduct(v2);
+        }
+        return expressionValue();
+    }
+
+    protected void bodyToMathML(MathML element) {
+        parameter[0].toMathML(element,null);
+        parameter[1].toMathML(element,null);
+    }
+
+    protected Variable newinstance() {
+        return new ComplexProduct(null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/product/GeometricProduct.java b/src/misc/src/jscl/math/operator/product/GeometricProduct.java
new file mode 100644
index 00000000..f5acaea6
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/product/GeometricProduct.java
@@ -0,0 +1,59 @@
+package jscl.math.operator.product;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.JSCLVector;
+import jscl.math.Variable;
+import jscl.math.function.ImplicitFunction;
+import jscl.math.operator.VectorOperator;
+import jscl.mathml.MathML;
+
+public class GeometricProduct extends VectorOperator {
+    public GeometricProduct(Generic vector1, Generic vector2, Generic algebra) {
+        super("geometric",new Generic[] {vector1,vector2,algebra});
+    }
+
+    public Generic compute() {
+        int algebra[]=algebra(parameter[2]);
+        if(parameter[0] instanceof JSCLVector && parameter[1] instanceof JSCLVector) {
+            JSCLVector v1=(JSCLVector)parameter[0];
+            JSCLVector v2=(JSCLVector)parameter[1];
+            return v1.geometricProduct(v2,algebra);
+        }
+        return expressionValue();
+    }
+
+    public static int[] algebra(Generic generic) {
+        if(generic.signum()==0) return null;
+        Variable v=generic.variableValue();
+        if(v instanceof ImplicitFunction) {
+            Generic g[]=((ImplicitFunction)v).parameters();
+            int p=g[0].integerValue().intValue();
+            int q=g[1].integerValue().intValue();
+            if(v.compareTo(new ImplicitFunction("cl",new Generic[] {JSCLInteger.valueOf(p),JSCLInteger.valueOf(q)},new int[] {0,0},new Generic[] {}))==0) return new int[] {p,q};
+        }
+        throw new ArithmeticException();
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        int n=3;
+        if(parameter[2].signum()==0) n=2;
+        buffer.append(name);
+        buffer.append("(");
+        for(int i=0;i<n;i++) {
+            buffer.append(parameter[i]).append(i<n-1?", ":"");
+        }
+        buffer.append(")");
+        return buffer.toString();
+    }
+
+    protected void bodyToMathML(MathML element) {
+        parameter[0].toMathML(element,null);
+        parameter[1].toMathML(element,null);
+    }
+
+    protected Variable newinstance() {
+        return new GeometricProduct(null,null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/product/MatrixProduct.java b/src/misc/src/jscl/math/operator/product/MatrixProduct.java
new file mode 100644
index 00000000..c1b7bc7a
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/product/MatrixProduct.java
@@ -0,0 +1,38 @@
+package jscl.math.operator.product;
+
+import jscl.math.Generic;
+import jscl.math.Matrix;
+import jscl.math.Variable;
+import jscl.math.operator.VectorOperator;
+import jscl.mathml.MathML;
+
+public class MatrixProduct extends VectorOperator {
+    public MatrixProduct(Generic matrix1, Generic matrix2) {
+        super("matrix",new Generic[] {matrix1,matrix2});
+    }
+
+    public Generic compute() {
+        if(Matrix.product(parameter[0],parameter[1])) {
+            return parameter[0].multiply(parameter[1]);
+        }
+        return expressionValue();
+    }
+
+    public String toJava() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append(parameter[0].toJava());
+        buffer.append(".multiply(");
+        buffer.append(parameter[1].toJava());
+        buffer.append(")");
+        return buffer.toString();
+    }
+
+    protected void bodyToMathML(MathML element) {
+        parameter[0].toMathML(element,null);
+        parameter[1].toMathML(element,null);
+    }
+
+    protected Variable newinstance() {
+        return new MatrixProduct(null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/product/QuaternionProduct.java b/src/misc/src/jscl/math/operator/product/QuaternionProduct.java
new file mode 100644
index 00000000..1c8409c7
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/product/QuaternionProduct.java
@@ -0,0 +1,31 @@
+package jscl.math.operator.product;
+
+import jscl.math.Generic;
+import jscl.math.JSCLVector;
+import jscl.math.Variable;
+import jscl.math.operator.VectorOperator;
+import jscl.mathml.MathML;
+
+public class QuaternionProduct extends VectorOperator {
+    public QuaternionProduct(Generic vector1, Generic vector2) {
+        super("quaternion",new Generic[] {vector1,vector2});
+    }
+
+    public Generic compute() {
+        if(parameter[0] instanceof JSCLVector && parameter[1] instanceof JSCLVector) {
+            JSCLVector v1=(JSCLVector)parameter[0];
+            JSCLVector v2=(JSCLVector)parameter[1];
+            return v1.quaternionProduct(v2);
+        }
+        return expressionValue();
+    }
+
+    protected void bodyToMathML(MathML element) {
+        parameter[0].toMathML(element,null);
+        parameter[1].toMathML(element,null);
+    }
+
+    protected Variable newinstance() {
+        return new QuaternionProduct(null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/product/TensorProduct.java b/src/misc/src/jscl/math/operator/product/TensorProduct.java
new file mode 100644
index 00000000..033bf28c
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/product/TensorProduct.java
@@ -0,0 +1,34 @@
+package jscl.math.operator.product;
+
+import jscl.math.Generic;
+import jscl.math.Matrix;
+import jscl.math.Variable;
+import jscl.math.operator.VectorOperator;
+import jscl.mathml.MathML;
+
+public class TensorProduct extends VectorOperator {
+    public TensorProduct(Generic matrix1, Generic matrix2) {
+        super("tensor",new Generic[] {matrix1,matrix2});
+    }
+
+    public Generic compute() {
+        if(parameter[0] instanceof Matrix && parameter[1] instanceof Matrix) {
+            Matrix m1=(Matrix)parameter[0];
+            Matrix m2=(Matrix)parameter[1];
+            return m1.tensorProduct(m2);
+        }
+        return expressionValue();
+    }
+
+    protected void bodyToMathML(MathML element) {
+        parameter[0].toMathML(element,null);
+        MathML e1=element.element("mo");
+        e1.appendChild(element.text(/*"\u2A2F"*/"*"));
+        element.appendChild(e1);
+        parameter[1].toMathML(element,null);
+    }
+
+    protected Variable newinstance() {
+        return new TensorProduct(null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/product/VectorProduct.java b/src/misc/src/jscl/math/operator/product/VectorProduct.java
new file mode 100644
index 00000000..d2da27aa
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/product/VectorProduct.java
@@ -0,0 +1,34 @@
+package jscl.math.operator.product;
+
+import jscl.math.Generic;
+import jscl.math.JSCLVector;
+import jscl.math.Variable;
+import jscl.math.operator.VectorOperator;
+import jscl.mathml.MathML;
+
+public class VectorProduct extends VectorOperator {
+    public VectorProduct(Generic vector1, Generic vector2) {
+        super("vector",new Generic[] {vector1,vector2});
+    }
+
+    public Generic compute() {
+        if(parameter[0] instanceof JSCLVector && parameter[1] instanceof JSCLVector) {
+            JSCLVector v1=(JSCLVector)parameter[0];
+            JSCLVector v2=(JSCLVector)parameter[1];
+            return v1.vectorProduct(v2);
+        }
+        return expressionValue();
+    }
+
+    protected void bodyToMathML(MathML element) {
+        parameter[0].toMathML(element,null);
+        MathML e1=element.element("mo");
+        e1.appendChild(element.text("\u2227"));
+        element.appendChild(e1);
+        parameter[1].toMathML(element,null);
+    }
+
+    protected Variable newinstance() {
+        return new VectorProduct(null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/vector/Curl.java b/src/misc/src/jscl/math/operator/vector/Curl.java
new file mode 100644
index 00000000..bfe1f0a7
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/vector/Curl.java
@@ -0,0 +1,34 @@
+package jscl.math.operator.vector;
+
+import jscl.math.Generic;
+import jscl.math.JSCLVector;
+import jscl.math.Variable;
+import jscl.math.operator.VectorOperator;
+import jscl.mathml.MathML;
+
+public class Curl extends VectorOperator {
+    public Curl(Generic vector, Generic variable) {
+        super("curl",new Generic[] {vector,variable});
+    }
+
+    public Generic compute() {
+        Variable variable[]=variables(parameter[1]);
+        if(parameter[0] instanceof JSCLVector) {
+            JSCLVector vector=(JSCLVector)parameter[0];
+            return vector.curl(variable);
+        }
+        return expressionValue();
+    }
+
+    protected void bodyToMathML(MathML element) {
+        operator(element,"nabla");
+        MathML e1=element.element("mo");
+        e1.appendChild(element.text("\u2227"));
+        element.appendChild(e1);
+        parameter[0].toMathML(element,null);
+    }
+
+    protected Variable newinstance() {
+        return new Curl(null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/vector/Dalembertian.java b/src/misc/src/jscl/math/operator/vector/Dalembertian.java
new file mode 100644
index 00000000..b68f7ead
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/vector/Dalembertian.java
@@ -0,0 +1,28 @@
+package jscl.math.operator.vector;
+
+import jscl.math.Expression;
+import jscl.math.Generic;
+import jscl.math.Variable;
+import jscl.math.operator.VectorOperator;
+import jscl.mathml.MathML;
+
+public class Dalembertian extends VectorOperator {
+    public Dalembertian(Generic vector, Generic variable) {
+        super("dalembertian",new Generic[] {vector,variable});
+    }
+
+    public Generic compute() {
+        Variable variable[]=variables(parameter[1]);
+        Expression expression=parameter[0].expressionValue();
+        return expression.dalembertian(variable);
+    }
+
+    protected void bodyToMathML(MathML element) {
+        operator(element,"square");
+        parameter[0].toMathML(element,null);
+    }
+
+    protected Variable newinstance() {
+        return new Dalembertian(null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/vector/Del.java b/src/misc/src/jscl/math/operator/vector/Del.java
new file mode 100644
index 00000000..8d423ef3
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/vector/Del.java
@@ -0,0 +1,46 @@
+package jscl.math.operator.vector;
+
+import jscl.math.Generic;
+import jscl.math.JSCLVector;
+import jscl.math.Variable;
+import jscl.math.operator.VectorOperator;
+import jscl.math.operator.product.GeometricProduct;
+import jscl.mathml.MathML;
+
+public class Del extends VectorOperator {
+    public Del(Generic vector, Generic variable, Generic algebra) {
+        super("del",new Generic[] {vector,variable,algebra});
+    }
+
+    public Generic compute() {
+        Variable variable[]=variables(parameter[1]);
+        int algebra[]=GeometricProduct.algebra(parameter[2]);
+        if(parameter[0] instanceof JSCLVector) {
+            JSCLVector vector=(JSCLVector)parameter[0];
+            return vector.del(variable,algebra);
+        }
+        return expressionValue();
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        int n=3;
+        if(parameter[2].signum()==0) n=2;
+        buffer.append(name);
+        buffer.append("(");
+        for(int i=0;i<n;i++) {
+            buffer.append(parameter[i]).append(i<n-1?", ":"");
+        }
+        buffer.append(")");
+        return buffer.toString();
+    }
+
+    protected void bodyToMathML(MathML element) {
+        operator(element,"nabla");
+        parameter[0].toMathML(element,null);
+    }
+
+    protected Variable newinstance() {
+        return new Del(null,null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/vector/Divergence.java b/src/misc/src/jscl/math/operator/vector/Divergence.java
new file mode 100644
index 00000000..9c40a2f4
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/vector/Divergence.java
@@ -0,0 +1,31 @@
+package jscl.math.operator.vector;
+
+import jscl.math.Generic;
+import jscl.math.JSCLVector;
+import jscl.math.Variable;
+import jscl.math.operator.VectorOperator;
+import jscl.mathml.MathML;
+
+public class Divergence extends VectorOperator {
+    public Divergence(Generic vector, Generic variable) {
+        super("diverg",new Generic[] {vector,variable});
+    }
+
+    public Generic compute() {
+        Variable variable[]=variables(parameter[1]);
+        if(parameter[0] instanceof JSCLVector) {
+            JSCLVector vector=(JSCLVector)parameter[0];
+            return vector.divergence(variable);
+        }
+        return expressionValue();
+    }
+
+    protected void bodyToMathML(MathML element) {
+        operator(element,"nabla");
+        parameter[0].toMathML(element,null);
+    }
+
+    protected Variable newinstance() {
+        return new Divergence(null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/vector/Grad.java b/src/misc/src/jscl/math/operator/vector/Grad.java
new file mode 100644
index 00000000..2d8bcf04
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/vector/Grad.java
@@ -0,0 +1,28 @@
+package jscl.math.operator.vector;
+
+import jscl.math.Expression;
+import jscl.math.Generic;
+import jscl.math.Variable;
+import jscl.math.operator.VectorOperator;
+import jscl.mathml.MathML;
+
+public class Grad extends VectorOperator {
+    public Grad(Generic expression, Generic variable) {
+        super("grad",new Generic[] {expression,variable});
+    }
+
+    public Generic compute() {
+        Variable variable[]=variables(parameter[1]);
+        Expression expression=parameter[0].expressionValue();
+        return expression.grad(variable);
+    }
+
+    protected void bodyToMathML(MathML element) {
+        operator(element,"nabla");
+        parameter[0].toMathML(element,null);
+    }
+
+    protected Variable newinstance() {
+        return new Grad(null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/vector/Jacobian.java b/src/misc/src/jscl/math/operator/vector/Jacobian.java
new file mode 100644
index 00000000..0673aa0c
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/vector/Jacobian.java
@@ -0,0 +1,51 @@
+package jscl.math.operator.vector;
+
+import jscl.math.Generic;
+import jscl.math.GenericVariable;
+import jscl.math.JSCLVector;
+import jscl.math.Variable;
+import jscl.math.function.Constant;
+import jscl.math.operator.VectorOperator;
+import jscl.mathml.MathML;
+
+public class Jacobian extends VectorOperator {
+    public Jacobian(Generic vector, Generic variable) {
+        super("jacobian",new Generic[] {vector,variable});
+    }
+
+    public Generic compute() {
+        Variable variable[]=variables(parameter[1]);
+        if(parameter[0] instanceof JSCLVector) {
+            JSCLVector vector=(JSCLVector)parameter[0];
+            return vector.jacobian(variable);
+        }
+        return expressionValue();
+    }
+
+    protected void bodyToMathML(MathML element) {
+        operator(element,"nabla");
+        MathML e1=element.element("msup");
+        parameter[0].toMathML(e1,null);
+        MathML e2=element.element("mo");
+        e2.appendChild(element.text("T"));
+        e1.appendChild(e2);
+        element.appendChild(e1);
+    }
+
+    protected void operator(MathML element, String name) {
+        Variable variable[]=variables(GenericVariable.content(parameter[1]));
+        MathML e1=element.element("msubsup");
+        new Constant(name).toMathML(e1,null);
+        MathML e2=element.element("mrow");
+        for(int i=0;i<variable.length;i++) variable[i].expressionValue().toMathML(e2,null);
+        e1.appendChild(e2);
+        e2=element.element("mo");
+        e2.appendChild(element.text("T"));
+        e1.appendChild(e2);
+        element.appendChild(e1);
+    }
+
+    protected Variable newinstance() {
+        return new Jacobian(null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/operator/vector/Laplacian.java b/src/misc/src/jscl/math/operator/vector/Laplacian.java
new file mode 100644
index 00000000..6607aeb9
--- /dev/null
+++ b/src/misc/src/jscl/math/operator/vector/Laplacian.java
@@ -0,0 +1,28 @@
+package jscl.math.operator.vector;
+
+import jscl.math.Expression;
+import jscl.math.Generic;
+import jscl.math.Variable;
+import jscl.math.operator.VectorOperator;
+import jscl.mathml.MathML;
+
+public class Laplacian extends VectorOperator {
+    public Laplacian(Generic vector, Generic variable) {
+        super("laplacian",new Generic[] {vector,variable});
+    }
+
+    public Generic compute() {
+        Variable variable[]=variables(parameter[1]);
+        Expression expression=parameter[0].expressionValue();
+        return expression.laplacian(variable);
+    }
+
+    protected void bodyToMathML(MathML element) {
+        operator(element,"Delta");
+        parameter[0].toMathML(element,null);
+    }
+
+    protected Variable newinstance() {
+        return new Laplacian(null,null);
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/ArrayPolynomial.java b/src/misc/src/jscl/math/polynomial/ArrayPolynomial.java
new file mode 100644
index 00000000..fa04e407
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/ArrayPolynomial.java
@@ -0,0 +1,328 @@
+package jscl.math.polynomial;
+
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.TreeMap;
+import jscl.math.Expression;
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.Literal;
+
+final class ArrayPolynomial extends Polynomial {
+    Term content[];
+    int size;
+    int degree;
+
+    ArrayPolynomial(Monomial monomialFactory, Generic coefFactory) {
+        super(monomialFactory,coefFactory);
+    }
+
+    ArrayPolynomial(int size, Monomial monomialFactory, Generic coefFactory) {
+        this(monomialFactory,coefFactory);
+        init(size);
+    }
+
+    public int size() {
+        return size;
+    }
+
+    void init(int size) {
+        content=new Term[size];
+        this.size=size;
+    }
+
+    void resize(int size) {
+        int length=content.length;
+        if(size<length) {
+            Term content[]=new Term[size];
+            System.arraycopy(this.content,length-size,content,0,size);
+            this.content=content;
+            this.size=size;
+        }
+    }
+
+    public Iterator iterator(boolean direction, Monomial current) {
+        return new ContentIterator(direction,current);
+    }
+
+    class ContentIterator implements Iterator {
+        final boolean direction;
+        int index;
+
+        ContentIterator(boolean direction, Monomial current) {
+            this.direction=direction;
+            index=indexOf(current,direction);
+        }
+        
+        public boolean hasNext() {
+            return direction?index>0:index<size;
+        }
+        
+        public Object next() {
+            return direction?content[--index]:content[index++];
+        }
+        
+        public void remove() {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    int indexOf(Monomial monomial, boolean direction) {
+        if(monomial==null) return direction?size:0;
+        int n=Arrays.binarySearch(content,new Term(monomial,null));
+        return n<0?-n-1:direction?n:n+1;
+    }
+
+    public Polynomial subtract(Polynomial polynomial) {
+        if(polynomial.signum()==0) return this;
+        ArrayPolynomial q=(ArrayPolynomial)polynomial;
+        ArrayPolynomial p=newinstance(size+q.size);
+        int i=p.size;
+        int i1=size;
+        int i2=q.size;
+        Term t1=i1>0?content[--i1]:null;
+        Term t2=i2>0?q.content[--i2]:null;
+        while(t1!=null || t2!=null) {
+            int c=t1==null?1:(t2==null?-1:-ordering.compare(t1.monomial(),t2.monomial()));
+            if(c<0) {
+                p.content[--i]=t1;
+                t1=i1>0?content[--i1]:null;
+            } else if(c>0) {
+                p.content[--i]=t2.negate();
+                t2=i2>0?q.content[--i2]:null;
+            } else {
+                Term t=t1.subtract(t2);
+                if(t.signum()!=0) p.content[--i]=t;
+                t1=i1>0?content[--i1]:null;
+                t2=i2>0?q.content[--i2]:null;
+            }
+        }
+        p.resize(p.size-i);
+        p.degree=degree(p);
+        p.sugar=Math.max(sugar,q.sugar);
+        return p;
+    }
+
+    public Polynomial multiplyAndSubtract(Generic generic, Polynomial polynomial) {
+        if(generic.signum()==0) return this;
+        if(generic.compareTo(JSCLInteger.valueOf(1))==0) return subtract(polynomial);
+        ArrayPolynomial q=(ArrayPolynomial)polynomial;
+        ArrayPolynomial p=newinstance(size+q.size);
+        int i=p.size;
+        int i1=size;
+        int i2=q.size;
+        Term t1=i1>0?content[--i1]:null;
+        Term t2=i2>0?q.content[--i2].multiply(generic):null;
+        while(t1!=null || t2!=null) {
+            int c=t1==null?1:(t2==null?-1:-ordering.compare(t1.monomial(),t2.monomial()));
+            if(c<0) {
+                p.content[--i]=t1;
+                t1=i1>0?content[--i1]:null;
+            } else if(c>0) {
+                p.content[--i]=t2.negate();
+                t2=i2>0?q.content[--i2].multiply(generic):null;
+            } else {
+                Term t=t1.subtract(t2);
+                if(t.signum()!=0) p.content[--i]=t;
+                t1=i1>0?content[--i1]:null;
+                t2=i2>0?q.content[--i2].multiply(generic):null;
+            }
+        }
+        p.resize(p.size-i);
+        p.degree=degree(p);
+        p.sugar=Math.max(sugar,q.sugar);
+        return p;
+    }
+
+    public Polynomial multiplyAndSubtract(Monomial monomial, Generic generic, Polynomial polynomial) {
+        if(defined) throw new UnsupportedOperationException();
+        if(generic.signum()==0) return this;
+        if(monomial.degree()==0) return multiplyAndSubtract(generic,polynomial);
+        ArrayPolynomial q=(ArrayPolynomial)polynomial;
+        ArrayPolynomial p=newinstance(size+q.size);
+        int i=p.size;
+        int i1=size;
+        int i2=q.size;
+        Term t1=i1>0?content[--i1]:null;
+        Term t2=i2>0?q.content[--i2].multiply(monomial,generic):null;
+        while(t1!=null || t2!=null) {
+            int c=t1==null?1:(t2==null?-1:-ordering.compare(t1.monomial(),t2.monomial()));
+            if(c<0) {
+                p.content[--i]=t1;
+                t1=i1>0?content[--i1]:null;
+            } else if(c>0) {
+                p.content[--i]=t2.negate();
+                t2=i2>0?q.content[--i2].multiply(monomial,generic):null;
+            } else {
+                Term t=t1.subtract(t2);
+                if(t.signum()!=0) p.content[--i]=t;
+                t1=i1>0?content[--i1]:null;
+                t2=i2>0?q.content[--i2].multiply(monomial,generic):null;
+            }
+        }
+        p.resize(p.size-i);
+        p.degree=degree(p);
+        p.sugar=Math.max(sugar,q.sugar+monomial.degree());
+        return p;
+    }
+
+    public Polynomial multiply(Polynomial polynomial) {
+        Polynomial p=valueof(JSCLInteger.valueOf(0));
+        for(int i=0;i<size;i++) {
+            Term t=content[i];
+            p=p.multiplyAndSubtract(t.monomial(),t.coef().negate(),polynomial);
+        }
+        return p;
+    }
+
+    public Polynomial multiply(Generic generic) {
+        if(generic.signum()==0) return valueof(JSCLInteger.valueOf(0));
+        if(generic.compareTo(JSCLInteger.valueOf(1))==0) return this;
+        ArrayPolynomial p=newinstance(size);
+        for(int i=0;i<size;i++) p.content[i]=content[i].multiply(generic);
+        p.degree=degree;
+        p.sugar=sugar;
+        return p;
+    }
+
+    public Polynomial multiply(Monomial monomial) {
+        if(defined) throw new UnsupportedOperationException();
+        if(monomial.degree()==0) return this;
+        ArrayPolynomial p=newinstance(size);
+        for(int i=0;i<size;i++) p.content[i]=content[i].multiply(monomial);
+        p.degree=degree+monomial.degree();
+        p.sugar=sugar+monomial.degree();
+        return p;
+    }
+
+    public Polynomial divide(Generic generic) throws ArithmeticException {
+        if(generic.compareTo(JSCLInteger.valueOf(1))==0) return this;
+        ArrayPolynomial p=newinstance(size);
+        for(int i=0;i<size;i++) p.content[i]=content[i].divide(generic);
+        p.degree=degree;
+        p.sugar=sugar;
+        return p;
+    }
+
+    public Polynomial divide(Monomial monomial) throws ArithmeticException {
+        if(monomial.degree()==0) return this;
+        ArrayPolynomial p=newinstance(size);
+        for(int i=0;i<size;i++) p.content[i]=content[i].divide(monomial);
+        p.degree=degree-monomial.degree();
+        p.sugar=sugar-monomial.degree();
+        return p;
+    }
+
+    public Polynomial gcd(Polynomial polynomial) {
+        throw new UnsupportedOperationException();
+    }
+
+    public Generic gcd() {
+        if(field) return coefficient(tail());
+        Generic a=coefficient(JSCLInteger.valueOf(0));
+        for(int i=size-1;i>=0;i--) a=a.gcd(content[i].coef());
+        return a.signum()==signum()?a:a.negate();
+    }
+
+    public Monomial monomialGcd() {
+        Monomial m=monomial(tail());
+        for(int i=0;i<size;i++) m=m.gcd(content[i].monomial());
+        return m;
+    }
+
+    public int degree() {
+        return degree;
+    }
+
+    public Polynomial valueof(Polynomial polynomial) {
+        ArrayPolynomial p=newinstance(0);
+        p.init(polynomial);
+        return p;
+    }
+
+    public Polynomial valueof(Generic generic) {
+        ArrayPolynomial p=newinstance(0);
+        p.init(generic);
+        return p;
+    }
+
+    public Polynomial valueof(Monomial monomial) {
+        ArrayPolynomial p=newinstance(0);
+        p.init(monomial);
+        return p;
+    }
+
+    public Polynomial freeze() {
+        return this;
+    }
+
+    public Term head() {
+        return size>0?content[size-1]:null;
+    }
+
+    public Term tail() {
+        return size>0?content[0]:null;
+    }
+
+    void init(Polynomial polynomial) {
+        ArrayPolynomial q=(ArrayPolynomial)polynomial;
+        init(q.size);
+        System.arraycopy(q.content,0,content,0,size);
+        degree=q.degree;
+        sugar=q.sugar;
+    }
+
+    void init(Expression expression) {
+        Map map=new TreeMap(ordering);
+        int n=expression.size();
+        for(int i=0;i<n;i++) {
+            Literal l=expression.literal(i);
+            JSCLInteger en=expression.coef(i);
+            Monomial m=monomial(l);
+            l=l.divide(m.literalValue());
+            Generic a2=coefficient(l.degree()>0?en.multiply(Expression.valueOf(l)):en);
+            Generic a1=(Generic)map.get(m);
+            Generic a=a1==null?a2:a1.add(a2);
+            if(a.signum()==0) map.remove(m);
+            else map.put(m,a);
+        }
+        init(map.size());
+        int sugar=0;
+        Iterator it=map.entrySet().iterator();
+        for(int i=0;i<size;i++) {
+            Map.Entry e=(Map.Entry)it.next();
+            Monomial m=(Monomial)e.getKey();
+            Generic a=(Generic)e.getValue();
+            content[i]=new Term(m,a);
+            sugar=Math.max(sugar,m.degree());
+        }
+        degree=degree(this);
+        this.sugar=sugar;
+    }
+
+    void init(Generic generic) {
+        if(generic instanceof Expression) {
+            init((Expression)generic);
+        } else {
+            Generic a=coefficient(generic);
+            if(a.signum()!=0) {
+                init(1);
+                content[0]=new Term(monomial(Literal.valueOf()),a);
+            } else init(0);
+            degree=0;
+            sugar=0;
+        }
+    }
+
+    void init(Monomial monomial) {
+        init(1);
+        content[0]=new Term(monomial,coefficient(JSCLInteger.valueOf(1)));
+        degree=monomial.degree();
+        sugar=monomial.degree();
+    }
+
+    protected ArrayPolynomial newinstance(int n) {
+        return new ArrayPolynomial(n,monomialFactory,coefFactory);
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/ArrayPolynomialBoolean.java b/src/misc/src/jscl/math/polynomial/ArrayPolynomialBoolean.java
new file mode 100644
index 00000000..fed0bb5c
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/ArrayPolynomialBoolean.java
@@ -0,0 +1,111 @@
+package jscl.math.polynomial;
+
+import java.util.Iterator;
+import java.util.Map;
+import java.util.TreeMap;
+import jscl.math.Generic;
+import jscl.math.JSCLBoolean;
+import jscl.math.JSCLInteger;
+
+class ArrayPolynomialBoolean extends ArrayPolynomialModular {
+    ArrayPolynomialBoolean(Monomial monomialFactory) {
+        super(monomialFactory,JSCLBoolean.factory);
+    }
+
+    ArrayPolynomialBoolean(int size, Monomial monomialFactory) {
+        this(monomialFactory);
+        init(size);
+    }
+
+    void init(int size) {
+        monomial=new Monomial[size];
+        this.size=size;
+    }
+
+    void resize(int size) {
+        int length=monomial.length;
+        if(size<length) {
+            Monomial monomial[]=new Monomial[size];
+            System.arraycopy(this.monomial,length-size,monomial,0,size);
+            this.monomial=monomial;
+            this.size=size;
+        }
+    }
+
+    public Polynomial subtract(Polynomial polynomial) {
+        if(polynomial.signum()==0) return this;
+        ArrayPolynomialBoolean q=(ArrayPolynomialBoolean)polynomial;
+        ArrayPolynomialBoolean p=(ArrayPolynomialBoolean)newinstance(size+q.size);
+        int i=p.size;
+        int i1=size;
+        int i2=q.size;
+        Monomial m1=i1>0?monomial[--i1]:null;
+        Monomial m2=i2>0?q.monomial[--i2]:null;
+        while(m1!=null || m2!=null) {
+            int c=m1==null?1:(m2==null?-1:-ordering.compare(m1,m2));
+            if(c<0) {
+                p.monomial[--i]=m1;
+                m1=i1>0?monomial[--i1]:null;
+            } else if(c>0) {
+                p.monomial[--i]=m2;
+                m2=i2>0?q.monomial[--i2]:null;
+            } else {
+                m1=i1>0?monomial[--i1]:null;
+                m2=i2>0?q.monomial[--i2]:null;
+            }
+        }
+        p.resize(p.size-i);
+        p.degree=degree(p);
+        p.sugar=Math.max(sugar,q.sugar);
+        return p;
+    }
+
+    public Polynomial multiplyAndSubtract(Generic generic, Polynomial polynomial) {
+        if(generic.signum()==0) return this;
+        return subtract(polynomial);
+    }
+
+    public Polynomial multiplyAndSubtract(Monomial monomial, Generic generic, Polynomial polynomial) {
+        if(generic.signum()==0) return this;
+        return multiplyAndSubtract(generic,polynomial.multiply(monomial));
+    }
+
+    public Polynomial multiply(Generic generic) {
+        if(generic.signum()==0) return valueof(JSCLInteger.valueOf(0));
+        return this;
+    }
+
+    public Polynomial multiply(Monomial monomial) {
+        if(defined) {
+            Map map=new TreeMap(ordering);
+            for(int i=0;i<size;i++) {
+                Monomial m=this.monomial[i].multiply(monomial);
+                if(map.containsKey(m)) map.remove(m);
+                else map.put(m,null);
+            }
+            ArrayPolynomialBoolean p=(ArrayPolynomialBoolean)newinstance(map.size());
+            Iterator it=map.keySet().iterator();
+            for(int i=0;i<p.size;i++) p.monomial[i]=(Monomial)it.next();
+            p.degree=degree(p);
+            p.sugar=sugar+monomial.degree();
+            return p;
+        } else {
+            if(monomial.degree()==0) return this;
+            ArrayPolynomialBoolean p=(ArrayPolynomialBoolean)newinstance(size);
+            for(int i=0;i<size;i++) p.monomial[i]=this.monomial[i].multiply(monomial);
+            p.degree=degree+monomial.degree();
+            p.sugar=sugar+monomial.degree();
+            return p;
+        }
+    }
+
+    protected Generic getCoef(int n) {
+        return new JSCLBoolean(1);
+    }
+
+    protected void setCoef(int n, Generic generic) {}
+
+    protected ArrayPolynomialGeneric newinstance(int n) {
+        return new ArrayPolynomialBoolean(n,monomialFactory);
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/ArrayPolynomialGeneric.java b/src/misc/src/jscl/math/polynomial/ArrayPolynomialGeneric.java
new file mode 100644
index 00000000..353b269f
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/ArrayPolynomialGeneric.java
@@ -0,0 +1,425 @@
+package jscl.math.polynomial;
+
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.TreeMap;
+import jscl.math.Expression;
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.Literal;
+
+class ArrayPolynomialGeneric extends Polynomial {
+    Generic coef[];
+    Monomial monomial[];
+    int size;
+    int degree;
+
+    ArrayPolynomialGeneric(Monomial monomialFactory, Generic coefFactory) {
+        super(monomialFactory,coefFactory);
+    }
+
+    ArrayPolynomialGeneric(int size, Monomial monomialFactory, Generic coefFactory) {
+        this(monomialFactory,coefFactory);
+        init(size);
+    }
+
+    public int size() {
+        return size;
+    }
+
+    void init(int size) {
+        monomial=new Monomial[size];
+        coef=new Generic[size];
+        this.size=size;
+    }
+
+    void resize(int size) {
+        int length=monomial.length;
+        if(size<length) {
+            Monomial monomial[]=new Monomial[size];
+            Generic coef[]=new Generic[size];
+            System.arraycopy(this.monomial,length-size,monomial,0,size);
+            System.arraycopy(this.coef,length-size,coef,0,size);
+            this.monomial=monomial;
+            this.coef=coef;
+            this.size=size;
+        }
+    }
+
+    public Iterator iterator(boolean direction, Monomial current) {
+        return new ContentIterator(direction,current);
+    }
+
+    class ContentIterator implements Iterator {
+        final boolean direction;
+        int index;
+
+        ContentIterator(boolean direction, Monomial current) {
+            this.direction=direction;
+            index=indexOf(current,direction);
+        }
+        
+        public boolean hasNext() {
+            return direction?index>0:index<size;
+        }
+        
+        public Object next() {
+            return direction?term(--index):term(index++);
+        }
+        
+        public void remove() {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    Term term(final int index) {
+        return new Term(monomial[index],null) {
+            public Generic coef() {
+                return coef==null?getCoef(index):coef;
+            }
+        };
+    }
+
+    int indexOf(Monomial monomial, boolean direction) {
+        if(monomial==null) return direction?size:0;
+        int n=Arrays.binarySearch(this.monomial,monomial,ordering);
+        return n<0?-n-1:direction?n:n+1;
+    }
+
+    public Polynomial subtract(Polynomial polynomial) {
+        if(polynomial.signum()==0) return this;
+        ArrayPolynomialGeneric q=(ArrayPolynomialGeneric)polynomial;
+        ArrayPolynomialGeneric p=newinstance(size+q.size);
+        int i=p.size;
+        int i1=size;
+        int i2=q.size;
+        Monomial m1=i1>0?monomial[--i1]:null;
+        Monomial m2=i2>0?q.monomial[--i2]:null;
+        while(m1!=null || m2!=null) {
+            int c=m1==null?1:(m2==null?-1:-ordering.compare(m1,m2));
+            if(c<0) {
+                Generic a=getCoef(i1);
+                --i;
+                p.monomial[i]=m1;
+                p.setCoef(i,a);
+                m1=i1>0?monomial[--i1]:null;
+            } else if(c>0) {
+                Generic a=q.getCoef(i2).negate();
+                --i;
+                p.monomial[i]=m2;
+                p.setCoef(i,a);
+                m2=i2>0?q.monomial[--i2]:null;
+            } else {
+                Generic a=getCoef(i1).subtract(q.getCoef(i2));
+                if(a.signum()!=0) {
+                    --i;
+                    p.monomial[i]=m1;
+                    p.setCoef(i,a);
+                }
+                m1=i1>0?monomial[--i1]:null;
+                m2=i2>0?q.monomial[--i2]:null;
+            }
+        }
+        p.resize(p.size-i);
+        p.degree=degree(p);
+        p.sugar=Math.max(sugar,q.sugar);
+        return p;
+    }
+
+    public Polynomial multiplyAndSubtract(Generic generic, Polynomial polynomial) {
+        if(generic.signum()==0) return this;
+        if(generic.compareTo(JSCLInteger.valueOf(1))==0) return subtract(polynomial);
+        ArrayPolynomialGeneric q=(ArrayPolynomialGeneric)polynomial;
+        ArrayPolynomialGeneric p=newinstance(size+q.size);
+        int i=p.size;
+        int i1=size;
+        int i2=q.size;
+        Monomial m1=i1>0?monomial[--i1]:null;
+        Monomial m2=i2>0?q.monomial[--i2]:null;
+        while(m1!=null || m2!=null) {
+            int c=m1==null?1:(m2==null?-1:-ordering.compare(m1,m2));
+            if(c<0) {
+                Generic a=getCoef(i1);
+                --i;
+                p.monomial[i]=m1;
+                p.setCoef(i,a);
+                m1=i1>0?monomial[--i1]:null;
+            } else if(c>0) {
+                Generic a=q.getCoef(i2).multiply(generic).negate();
+                --i;
+                p.monomial[i]=m2;
+                p.setCoef(i,a);
+                m2=i2>0?q.monomial[--i2]:null;
+            } else {
+                Generic a=getCoef(i1).subtract(q.getCoef(i2).multiply(generic));
+                if(a.signum()!=0) {
+                    --i;
+                    p.monomial[i]=m1;
+                    p.setCoef(i,a);
+                }
+                m1=i1>0?monomial[--i1]:null;
+                m2=i2>0?q.monomial[--i2]:null;
+            }
+        }
+        p.resize(p.size-i);
+        p.degree=degree(p);
+        p.sugar=Math.max(sugar,q.sugar);
+        return p;
+    }
+
+    public Polynomial multiplyAndSubtract(Monomial monomial, Generic generic, Polynomial polynomial) {
+        if(defined) throw new UnsupportedOperationException();
+        if(generic.signum()==0) return this;
+        if(monomial.degree()==0) return multiplyAndSubtract(generic,polynomial);
+        ArrayPolynomialGeneric q=(ArrayPolynomialGeneric)polynomial;
+        ArrayPolynomialGeneric p=newinstance(size+q.size);
+        int i=p.size;
+        int i1=size;
+        int i2=q.size;
+        Monomial m1=i1>0?this.monomial[--i1]:null;
+        Monomial m2=i2>0?q.monomial[--i2].multiply(monomial):null;
+        while(m1!=null || m2!=null) {
+            int c=m1==null?1:(m2==null?-1:-ordering.compare(m1,m2));
+            if(c<0) {
+                Generic a=getCoef(i1);
+                --i;
+                p.monomial[i]=m1;
+                p.setCoef(i,a);
+                m1=i1>0?this.monomial[--i1]:null;
+            } else if(c>0) {
+                Generic a=q.getCoef(i2).multiply(generic).negate();
+                --i;
+                p.monomial[i]=m2;
+                p.setCoef(i,a);
+                m2=i2>0?q.monomial[--i2].multiply(monomial):null;
+            } else {
+                Generic a=getCoef(i1).subtract(q.getCoef(i2).multiply(generic));
+                if(a.signum()!=0) {
+                    --i;
+                    p.monomial[i]=m1;
+                    p.setCoef(i,a);
+                }
+                m1=i1>0?this.monomial[--i1]:null;
+                m2=i2>0?q.monomial[--i2].multiply(monomial):null;
+            }
+        }
+        p.resize(p.size-i);
+        p.degree=degree(p);
+        p.sugar=Math.max(sugar,q.sugar+monomial.degree());
+        return p;
+    }
+
+    public Polynomial multiply(Polynomial polynomial) {
+        Polynomial p=newinstance(0);
+        for(int i=0;i<size;i++) p=p.multiplyAndSubtract(monomial[i],getCoef(i).negate(),polynomial);
+        return p;
+    }
+
+    public Polynomial multiply(Generic generic) {
+        if(generic.signum()==0) return valueof(JSCLInteger.valueOf(0));
+        if(generic.compareTo(JSCLInteger.valueOf(1))==0) return this;
+        ArrayPolynomialGeneric p=newinstance(size);
+        System.arraycopy(monomial,0,p.monomial,0,size);
+        for(int i=0;i<size;i++) p.setCoef(i,getCoef(i).multiply(generic));
+        p.degree=degree;
+        p.sugar=sugar;
+        return p;
+    }
+
+    public Polynomial multiply(Monomial monomial) {
+        if(defined) throw new UnsupportedOperationException();
+        if(monomial.degree()==0) return this;
+        ArrayPolynomialGeneric p=newinstance(size);
+        for(int i=0;i<size;i++) {
+            p.monomial[i]=this.monomial[i].multiply(monomial);
+            p.setCoef(i,getCoef(i));
+        }
+        p.degree=degree+monomial.degree();
+        p.sugar=sugar+monomial.degree();
+        return p;
+    }
+
+    public Polynomial divide(Generic generic) throws ArithmeticException {
+        if(generic.compareTo(JSCLInteger.valueOf(1))==0) return this;
+        ArrayPolynomialGeneric p=newinstance(size);
+        System.arraycopy(monomial,0,p.monomial,0,size);
+        for(int i=0;i<size;i++) p.setCoef(i,getCoef(i).divide(generic));
+        p.degree=degree;
+        p.sugar=sugar;
+        return p;
+    }
+
+    public Polynomial divide(Monomial monomial) throws ArithmeticException {
+        if(monomial.degree()==0) return this;
+        ArrayPolynomialGeneric p=newinstance(size);
+        for(int i=0;i<size;i++) {
+            p.monomial[i]=this.monomial[i].divide(monomial);
+            p.setCoef(i,getCoef(i));
+        }
+        p.degree=degree-monomial.degree();
+        p.sugar=sugar-monomial.degree();
+        return p;
+    }
+
+    public Polynomial gcd(Polynomial polynomial) {
+        throw new UnsupportedOperationException();
+    }
+
+    public Generic gcd() {
+        if(field) return coefficient(tail());
+        Generic a=coefficient(JSCLInteger.valueOf(0));
+        for(int i=size-1;i>=0;i--) a=a.gcd(getCoef(i));
+        return a.signum()==signum()?a:a.negate();
+    }
+
+    public Monomial monomialGcd() {
+        Monomial m=monomial(tail());
+        for(int i=0;i<size;i++) m=m.gcd(monomial[i]);
+        return m;
+    }
+
+    public int degree() {
+        return degree;
+    }
+
+    public Polynomial valueof(Polynomial polynomial) {
+        ArrayPolynomialGeneric p=newinstance(0);
+        p.init(polynomial);
+        return p;
+    }
+
+    public Polynomial valueof(Generic generic) {
+        ArrayPolynomialGeneric p=newinstance(0);
+        p.init(generic);
+        return p;
+    }
+
+    public Polynomial valueof(Monomial monomial) {
+        ArrayPolynomialGeneric p=newinstance(0);
+        p.init(monomial);
+        return p;
+    }
+
+    public Polynomial freeze() {
+        return this;
+    }
+
+    public Term head() {
+        return size>0?term(size-1):null;
+    }
+
+    public Term tail() {
+        return size>0?term(0):null;
+    }
+
+    protected Generic getCoef(int n) {
+        return coef[n];
+    }
+
+    protected void setCoef(int n, Generic generic) {
+        coef[n]=generic;
+    }
+
+    public Generic genericValue() {
+        Generic s=JSCLInteger.valueOf(0);
+        for(int i=0;i<size;i++) {
+            Monomial m=monomial[i];
+            Generic a=getCoef(i).expressionValue();
+            s=s.add(m.degree()>0?a.multiply(Expression.valueOf(m.literalValue())):a);
+        }
+        return s;
+    }
+
+    public Generic[] elements() {
+        Generic a[]=new Generic[size];
+        for(int i=0;i<size;i++) a[i]=getCoef(i);
+        return a;
+    }
+
+    public int compareTo(Polynomial polynomial) {
+        ArrayPolynomialGeneric q=(ArrayPolynomialGeneric)polynomial;
+        int i1=size;
+        int i2=q.size;
+        Monomial m1=i1==0?null:monomial[--i1];
+        Monomial m2=i2==0?null:q.monomial[--i2];
+        while(m1!=null || m2!=null) {
+            int c=m1==null?-1:(m2==null?1:ordering.compare(m1,m2));
+            if(c<0) return -1;
+            else if(c>0) return 1;
+            else {
+                c=getCoef(i1).compareTo(q.getCoef(i2));
+                if(c<0) return -1;
+                else if(c>0) return 1;
+                m1=i1==0?null:monomial[--i1];
+                m2=i2==0?null:q.monomial[--i2];
+            }
+        }
+        return 0;
+    }
+
+    void init(Polynomial polynomial) {
+        ArrayPolynomialGeneric q=(ArrayPolynomialGeneric)polynomial;
+        init(q.size);
+        System.arraycopy(q.monomial,0,monomial,0,size);
+        for(int i=0;i<size;i++) setCoef(i,q.getCoef(i));
+        degree=q.degree;
+        sugar=q.sugar;
+    }
+
+    void init(Expression expression) {
+        Map map=new TreeMap(ordering);
+        int n=expression.size();
+        for(int i=0;i<n;i++) {
+            Literal l=expression.literal(i);
+            JSCLInteger en=expression.coef(i);
+            Monomial m=monomial(l);
+            l=l.divide(m.literalValue());
+            Generic a2=coefficient(l.degree()>0?en.multiply(Expression.valueOf(l)):en);
+            Generic a1=(Generic)map.get(m);
+            Generic a=a1==null?a2:a1.add(a2);
+            if(a.signum()==0) map.remove(m);
+            else map.put(m,a);
+        }
+        init(map.size());
+        int sugar=0;
+        Iterator it=map.entrySet().iterator();
+        for(int i=0;i<size;i++) {
+            Map.Entry e=(Map.Entry)it.next();
+            Monomial m=(Monomial)e.getKey();
+            Generic a=(Generic)e.getValue();
+            monomial[i]=m;
+            setCoef(i,a);
+            sugar=Math.max(sugar,m.degree());
+        }
+        degree=degree(this);
+        this.sugar=sugar;
+    }
+
+    void init(Generic generic) {
+        if(generic instanceof Expression) {
+            init((Expression)generic);
+        } else {
+            Generic a=coefficient(generic);
+            if(a.signum()!=0) {
+                init(1);
+                monomial[0]=monomial(Literal.valueOf());
+                setCoef(0,a);
+            } else init(0);
+            degree=0;
+            sugar=0;
+        }
+    }
+
+    void init(Monomial monomial) {
+        init(1);
+        this.monomial[0]=monomial;
+        setCoef(0,coefficient(JSCLInteger.valueOf(1)));
+        degree=monomial.degree();
+        sugar=monomial.degree();
+    }
+
+    protected ArrayPolynomialGeneric newinstance(int n) {
+        return new ArrayPolynomialGeneric(n,monomialFactory,coefFactory);
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/ArrayPolynomialInteger.java b/src/misc/src/jscl/math/polynomial/ArrayPolynomialInteger.java
new file mode 100644
index 00000000..61b7f665
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/ArrayPolynomialInteger.java
@@ -0,0 +1,228 @@
+package jscl.math.polynomial;
+
+import java.math.BigInteger;
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+
+class ArrayPolynomialInteger extends ArrayPolynomialGeneric {
+    BigInteger coef[];
+
+    ArrayPolynomialInteger(Monomial monomialFactory) {
+        super(monomialFactory,JSCLInteger.factory);
+    }
+
+    ArrayPolynomialInteger(int size, Monomial monomialFactory) {
+        this(monomialFactory);
+        init(size);
+    }
+
+    void init(int size) {
+        monomial=new Monomial[size];
+        coef=new BigInteger[size];
+        this.size=size;
+    }
+
+    void resize(int size) {
+        int length=monomial.length;
+        if(size<length) {
+            Monomial monomial[]=new Monomial[size];
+            BigInteger coef[]=new BigInteger[size];
+            System.arraycopy(this.monomial,length-size,monomial,0,size);
+            System.arraycopy(this.coef,length-size,coef,0,size);
+            this.monomial=monomial;
+            this.coef=coef;
+            this.size=size;
+        }
+    }
+
+    public Polynomial subtract(Polynomial polynomial) {
+        if(polynomial.signum()==0) return this;
+        ArrayPolynomialInteger q=(ArrayPolynomialInteger)polynomial;
+        ArrayPolynomialInteger p=(ArrayPolynomialInteger)newinstance(size+q.size);
+        int i=p.size;
+        int i1=size;
+        int i2=q.size;
+        Monomial m1=i1>0?monomial[--i1]:null;
+        Monomial m2=i2>0?q.monomial[--i2]:null;
+        while(m1!=null || m2!=null) {
+            int c=m1==null?1:(m2==null?-1:-ordering.compare(m1,m2));
+            if(c<0) {
+                BigInteger a=coef[i1];
+                --i;
+                p.monomial[i]=m1;
+                p.coef[i]=a;
+                m1=i1>0?monomial[--i1]:null;
+            } else if(c>0) {
+                BigInteger a=q.coef[i2].negate();
+                --i;
+                p.monomial[i]=m2;
+                p.coef[i]=a;
+                m2=i2>0?q.monomial[--i2]:null;
+            } else {
+                BigInteger a=coef[i1].subtract(q.coef[i2]);
+                if(a.signum()!=0) {
+                    --i;
+                    p.monomial[i]=m1;
+                    p.coef[i]=a;
+                }
+                m1=i1>0?monomial[--i1]:null;
+                m2=i2>0?q.monomial[--i2]:null;
+            }
+        }
+        p.resize(p.size-i);
+        p.degree=degree(p);
+        p.sugar=Math.max(sugar,q.sugar);
+        return p;
+    }
+
+    public Polynomial multiplyAndSubtract(Generic generic, Polynomial polynomial) {
+        if(generic.signum()==0) return this;
+        BigInteger g=generic.integerValue().content();
+        if(g.compareTo(BigInteger.valueOf(1))==0) return subtract(polynomial);
+        ArrayPolynomialInteger q=(ArrayPolynomialInteger)polynomial;
+        ArrayPolynomialInteger p=(ArrayPolynomialInteger)newinstance(size+q.size);
+        int i=p.size;
+        int i1=size;
+        int i2=q.size;
+        Monomial m1=i1>0?monomial[--i1]:null;
+        Monomial m2=i2>0?q.monomial[--i2]:null;
+        while(m1!=null || m2!=null) {
+            int c=m1==null?1:(m2==null?-1:-ordering.compare(m1,m2));
+            if(c<0) {
+                BigInteger a=coef[i1];
+                --i;
+                p.monomial[i]=m1;
+                p.coef[i]=a;
+                m1=i1>0?monomial[--i1]:null;
+            } else if(c>0) {
+                BigInteger a=q.coef[i2].multiply(g).negate();
+                --i;
+                p.monomial[i]=m2;
+                p.coef[i]=a;
+                m2=i2>0?q.monomial[--i2]:null;
+            } else {
+                BigInteger a=coef[i1].subtract(q.coef[i2].multiply(g));
+                if(a.signum()!=0) {
+                    --i;
+                    p.monomial[i]=m1;
+                    p.coef[i]=a;
+                }
+                m1=i1>0?monomial[--i1]:null;
+                m2=i2>0?q.monomial[--i2]:null;
+            }
+        }
+        p.resize(p.size-i);
+        p.degree=degree(p);
+        p.sugar=Math.max(sugar,q.sugar);
+        return p;
+    }
+
+    public Polynomial multiplyAndSubtract(Monomial monomial, Generic generic, Polynomial polynomial) {
+        if(defined) throw new UnsupportedOperationException();
+        if(generic.signum()==0) return this;
+        if(monomial.degree()==0) return multiplyAndSubtract(generic,polynomial);
+        BigInteger g=generic.integerValue().content();
+        ArrayPolynomialInteger q=(ArrayPolynomialInteger)polynomial;
+        ArrayPolynomialInteger p=(ArrayPolynomialInteger)newinstance(size+q.size);
+        int i=p.size;
+        int i1=size;
+        int i2=q.size;
+        Monomial m1=i1>0?this.monomial[--i1]:null;
+        Monomial m2=i2>0?q.monomial[--i2].multiply(monomial):null;
+        while(m1!=null || m2!=null) {
+            int c=m1==null?1:(m2==null?-1:-ordering.compare(m1,m2));
+            if(c<0) {
+                BigInteger a=coef[i1];
+                --i;
+                p.monomial[i]=m1;
+                p.coef[i]=a;
+                m1=i1>0?this.monomial[--i1]:null;
+            } else if(c>0) {
+                BigInteger a=q.coef[i2].multiply(g).negate();
+                --i;
+                p.monomial[i]=m2;
+                p.coef[i]=a;
+                m2=i2>0?q.monomial[--i2].multiply(monomial):null;
+            } else {
+                BigInteger a=coef[i1].subtract(q.coef[i2].multiply(g));
+                if(a.signum()!=0) {
+                    --i;
+                    p.monomial[i]=m1;
+                    p.coef[i]=a;
+                }
+                m1=i1>0?this.monomial[--i1]:null;
+                m2=i2>0?q.monomial[--i2].multiply(monomial):null;
+            }
+        }
+        p.resize(p.size-i);
+        p.degree=degree(p);
+        p.sugar=Math.max(sugar,q.sugar+monomial.degree());
+        return p;
+    }
+
+    public Polynomial multiply(Generic generic) {
+        if(generic.signum()==0) return valueof(JSCLInteger.valueOf(0));
+        BigInteger g=generic.integerValue().content();
+        if(g.compareTo(BigInteger.valueOf(1))==0) return this;
+        ArrayPolynomialInteger p=(ArrayPolynomialInteger)newinstance(size);
+        for(int i=0;i<size;i++) {
+            p.monomial[i]=monomial[i];
+            p.coef[i]=coef[i].multiply(g);
+        }
+        p.degree=degree;
+        p.sugar=sugar;
+        return p;
+    }
+
+    public Polynomial multiply(Monomial monomial) {
+        if(defined) throw new UnsupportedOperationException();
+        if(monomial.degree()==0) return this;
+        ArrayPolynomialInteger p=(ArrayPolynomialInteger)newinstance(size);
+        for(int i=0;i<size;i++) {
+            p.monomial[i]=this.monomial[i].multiply(monomial);
+            p.coef[i]=coef[i];
+        }
+        p.degree=degree+monomial.degree();
+        p.sugar=sugar+monomial.degree();
+        return p;
+    }
+
+    public Polynomial divide(Generic generic) throws ArithmeticException {
+        BigInteger g=generic.integerValue().content();
+        if(g.compareTo(BigInteger.valueOf(1))==0) return this;
+        ArrayPolynomialInteger p=(ArrayPolynomialInteger)newinstance(size);
+        for(int i=0;i<size;i++) {
+            p.monomial[i]=monomial[i];
+            p.coef[i]=coef[i].divide(g);
+        }
+        p.degree=degree;
+        p.sugar=sugar;
+        return p;
+    }
+
+    public Polynomial gcd(Polynomial polynomial) {
+        return valueof(genericValue().gcd(polynomial.genericValue()));
+    }
+
+    public Generic gcd() {
+        BigInteger a=BigInteger.valueOf(0);
+        for(int i=size-1;i>=0;i--) if((a=a.gcd(coef[i])).compareTo(BigInteger.valueOf(1))==0) break;
+        return new JSCLInteger(a.signum()==signum()?a:a.negate());
+    }
+
+    protected Generic coefficient(Generic generic) {
+        return coefFactory.valueof(generic);
+    }
+
+    protected Generic getCoef(int n) {
+        return new JSCLInteger(coef[n]);
+    }
+
+    protected void setCoef(int n, Generic generic) {
+        coef[n]=generic.integerValue().content();
+    }
+
+    protected ArrayPolynomialGeneric newinstance(int n) {
+        return new ArrayPolynomialInteger(n,monomialFactory);
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/ArrayPolynomialModular.java b/src/misc/src/jscl/math/polynomial/ArrayPolynomialModular.java
new file mode 100644
index 00000000..e4ee5d62
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/ArrayPolynomialModular.java
@@ -0,0 +1,207 @@
+package jscl.math.polynomial;
+
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.ModularInteger;
+
+class ArrayPolynomialModular extends ArrayPolynomialGeneric {
+    final int modulo;
+    int coef[];
+
+    ArrayPolynomialModular(Monomial monomialFactory, Generic coefFactory) {
+        super(monomialFactory,coefFactory);
+        modulo=((ModularInteger)coefFactory).modulo();
+    }
+
+    ArrayPolynomialModular(int size, Monomial monomialFactory, Generic coefFactory) {
+        this(monomialFactory,coefFactory);
+        init(size);
+    }
+
+    void init(int size) {
+        monomial=new Monomial[size];
+        coef=new int[size];
+        this.size=size;
+    }
+
+    void resize(int size) {
+        int length=monomial.length;
+        if(size<length) {
+            Monomial monomial[]=new Monomial[size];
+            int coef[]=new int[size];
+            System.arraycopy(this.monomial,length-size,monomial,0,size);
+            System.arraycopy(this.coef,length-size,coef,0,size);
+            this.monomial=monomial;
+            this.coef=coef;
+            this.size=size;
+        }
+    }
+
+    public Polynomial subtract(Polynomial polynomial) {
+        if(polynomial.signum()==0) return this;
+        ArrayPolynomialModular q=(ArrayPolynomialModular)polynomial;
+        ArrayPolynomialModular p=(ArrayPolynomialModular)newinstance(size+q.size);
+        int i=p.size;
+        int i1=size;
+        int i2=q.size;
+        Monomial m1=i1>0?monomial[--i1]:null;
+        Monomial m2=i2>0?q.monomial[--i2]:null;
+        while(m1!=null || m2!=null) {
+            int c=m1==null?1:(m2==null?-1:-ordering.compare(m1,m2));
+            if(c<0) {
+                int a=coef[i1];
+                --i;
+                p.monomial[i]=m1;
+                p.coef[i]=a;
+                m1=i1>0?monomial[--i1]:null;
+            } else if(c>0) {
+                int a=(int)(((long)modulo-(long)q.coef[i2])%modulo);
+                --i;
+                p.monomial[i]=m2;
+                p.coef[i]=a;
+                m2=i2>0?q.monomial[--i2]:null;
+            } else {
+                int a=(int)(((long)coef[i1]+(long)modulo-(long)q.coef[i2])%modulo);
+                if(a!=0) {
+                    --i;
+                    p.monomial[i]=m1;
+                    p.coef[i]=a;
+                }
+                m1=i1>0?monomial[--i1]:null;
+                m2=i2>0?q.monomial[--i2]:null;
+            }
+        }
+        p.resize(p.size-i);
+        p.degree=degree(p);
+        p.sugar=Math.max(sugar,q.sugar);
+        return p;
+    }
+
+    public Polynomial multiplyAndSubtract(Generic generic, Polynomial polynomial) {
+        if(generic.signum()==0) return this;
+        int g=generic.integerValue().intValue();
+        if(g==1) return subtract(polynomial);
+        ArrayPolynomialModular q=(ArrayPolynomialModular)polynomial;
+        ArrayPolynomialModular p=(ArrayPolynomialModular)newinstance(size+q.size);
+        int i=p.size;
+        int i1=size;
+        int i2=q.size;
+        Monomial m1=i1>0?monomial[--i1]:null;
+        Monomial m2=i2>0?q.monomial[--i2]:null;
+        while(m1!=null || m2!=null) {
+            int c=m1==null?1:(m2==null?-1:-ordering.compare(m1,m2));
+            if(c<0) {
+                int a=coef[i1];
+                --i;
+                p.monomial[i]=m1;
+                p.coef[i]=a;
+                m1=i1>0?monomial[--i1]:null;
+            } else if(c>0) {
+                int a=(int)(((long)modulo-((long)q.coef[i2]*(long)g)%modulo)%modulo);
+                --i;
+                p.monomial[i]=m2;
+                p.coef[i]=a;
+                m2=i2>0?q.monomial[--i2]:null;
+            } else {
+                int a=(int)(((long)coef[i1]+(long)modulo-((long)q.coef[i2]*(long)g)%modulo)%modulo);
+                if(a!=0) {
+                    --i;
+                    p.monomial[i]=m1;
+                    p.coef[i]=a;
+                }
+                m1=i1>0?monomial[--i1]:null;
+                m2=i2>0?q.monomial[--i2]:null;
+            }
+        }
+        p.resize(p.size-i);
+        p.degree=degree(p);
+        p.sugar=Math.max(sugar,q.sugar);
+        return p;
+    }
+
+    public Polynomial multiplyAndSubtract(Monomial monomial, Generic generic, Polynomial polynomial) {
+        if(defined) throw new UnsupportedOperationException();
+        if(generic.signum()==0) return this;
+        if(monomial.degree()==0) return multiplyAndSubtract(generic,polynomial);
+        int g=generic.integerValue().intValue();
+        ArrayPolynomialModular q=(ArrayPolynomialModular)polynomial;
+        ArrayPolynomialModular p=(ArrayPolynomialModular)newinstance(size+q.size);
+        int i=p.size;
+        int i1=size;
+        int i2=q.size;
+        Monomial m1=i1>0?this.monomial[--i1]:null;
+        Monomial m2=i2>0?q.monomial[--i2].multiply(monomial):null;
+        while(m1!=null || m2!=null) {
+            int c=m1==null?1:(m2==null?-1:-ordering.compare(m1,m2));
+            if(c<0) {
+                int a=coef[i1];
+                --i;
+                p.monomial[i]=m1;
+                p.coef[i]=a;
+                m1=i1>0?this.monomial[--i1]:null;
+            } else if(c>0) {
+                int a=(int)(((long)modulo-((long)q.coef[i2]*(long)g)%modulo)%modulo);
+                --i;
+                p.monomial[i]=m2;
+                p.coef[i]=a;
+                m2=i2>0?q.monomial[--i2].multiply(monomial):null;
+            } else {
+                int a=(int)(((long)coef[i1]+(long)modulo-((long)q.coef[i2]*(long)g)%modulo)%modulo);
+                if(a!=0) {
+                    --i;
+                    p.monomial[i]=m1;
+                    p.coef[i]=a;
+                }
+                m1=i1>0?this.monomial[--i1]:null;
+                m2=i2>0?q.monomial[--i2].multiply(monomial):null;
+            }
+        }
+        p.resize(p.size-i);
+        p.degree=degree(p);
+        p.sugar=Math.max(sugar,q.sugar+monomial.degree());
+        return p;
+    }
+
+    public Polynomial multiply(Generic generic) {
+        if(generic.signum()==0) return valueof(JSCLInteger.valueOf(0));
+        int g=generic.integerValue().intValue();
+        if(g==1) return this;
+        ArrayPolynomialModular p=(ArrayPolynomialModular)newinstance(size);
+        for(int i=0;i<size;i++) {
+            p.monomial[i]=monomial[i];
+            p.coef[i]=(int)(((long)coef[i]*(long)g)%modulo);
+        }
+        p.degree=degree;
+        p.sugar=sugar;
+        return p;
+    }
+
+    public Polynomial multiply(Monomial monomial) {
+        if(defined) throw new UnsupportedOperationException();
+        if(monomial.degree()==0) return this;
+        ArrayPolynomialModular p=(ArrayPolynomialModular)newinstance(size);
+        for(int i=0;i<size;i++) {
+            p.monomial[i]=this.monomial[i].multiply(monomial);
+            p.coef[i]=coef[i];
+        }
+        p.degree=degree+monomial.degree();
+        p.sugar=sugar+monomial.degree();
+        return p;
+    }
+
+    protected Generic coefficient(Generic generic) {
+        return coefFactory.valueof(generic);
+    }
+
+    protected Generic getCoef(int n) {
+        return new ModularInteger(coef[n],modulo);
+    }
+
+    protected void setCoef(int n, Generic generic) {
+        coef[n]=generic.integerValue().intValue();
+    }
+
+    protected ArrayPolynomialGeneric newinstance(int n) {
+        return new ArrayPolynomialModular(n,monomialFactory,coefFactory);
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/ArrayPolynomialRational.java b/src/misc/src/jscl/math/polynomial/ArrayPolynomialRational.java
new file mode 100644
index 00000000..7b12422f
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/ArrayPolynomialRational.java
@@ -0,0 +1,52 @@
+package jscl.math.polynomial;
+
+import jscl.math.Generic;
+import jscl.math.Rational;
+
+class ArrayPolynomialRational extends ArrayPolynomialGeneric {
+    Rational coef[];
+
+    ArrayPolynomialRational(Monomial monomialFactory) {
+        super(monomialFactory,Rational.factory);
+    }
+
+    ArrayPolynomialRational(int size, Monomial monomialFactory) {
+        this(monomialFactory);
+        init(size);
+    }
+
+    void init(int size) {
+        monomial=new Monomial[size];
+        coef=new Rational[size];
+        this.size=size;
+    }
+
+    void resize(int size) {
+        int length=monomial.length;
+        if(size<length) {
+            Monomial monomial[]=new Monomial[size];
+            Rational coef[]=new Rational[size];
+            System.arraycopy(this.monomial,length-size,monomial,0,size);
+            System.arraycopy(this.coef,length-size,coef,0,size);
+            this.monomial=monomial;
+            this.coef=coef;
+            this.size=size;
+        }
+    }
+
+    protected Generic coefficient(Generic generic) {
+        return coefFactory.valueof(generic);
+    }
+
+    protected Generic getCoef(int n) {
+        return coef[n];
+    }
+
+    protected void setCoef(int n, Generic generic) {
+        coef[n]=(Rational)generic;
+    }
+
+    protected ArrayPolynomialGeneric newinstance(int n) {
+        return new ArrayPolynomialRational(n,monomialFactory);
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/Basis.java b/src/misc/src/jscl/math/polynomial/Basis.java
new file mode 100644
index 00000000..ea43f336
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/Basis.java
@@ -0,0 +1,126 @@
+package jscl.math.polynomial;
+
+import java.util.ArrayList;
+import java.util.List;
+import jscl.math.Expression;
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.Variable;
+import jscl.math.polynomial.groebner.Standard;
+import jscl.util.ArrayUtils;
+
+public class Basis {
+    public static final int DATA_STRUCT=0x3;
+    public static final int ARRAY_DECLINED=0x0;
+    public static final int ARRAY=0x1;
+    public static final int TREE=0x2;
+    public static final int LIST=0x3;
+    public static final int DEGREE=0x4;
+    public static final int DEFINING_EQS=0x8;
+    public static final int POWER_SIZE=0x30;
+    public static final int POWER_32=0x00;
+    public static final int POWER_8=0x10;
+    public static final int POWER_2=0x20;
+    public static final int POWER_2_DEFINED=0x30;
+    public static final int GEO_BUCKETS=0x40;
+    public static final int ALGORITHM=0x180;
+    public static final int BUCHBERGER=0x000;
+    public static final int F4=0x080;
+    public static final int BLOCK=0x100;
+    public static final int INSTRUMENTED=0x200;
+    public static final int GM_SETTING=0x400;
+    public static final int SUGAR=0x800;
+    public static final int FUSSY=0x1000;
+    public static final int F4_SIMPLIFY=0x2000;
+    static final int DEFAULT=GM_SETTING|SUGAR;
+    final Polynomial factory;
+    final Generic element[];
+
+    public Basis(Generic element[], Polynomial factory) {
+        this.element=element;
+        this.factory=factory;
+    }
+
+    public static Basis compute(Generic generic[], Variable unknown[]) {
+        return compute(generic,unknown,Monomial.lexicographic);
+    }
+
+    public static Basis compute(Generic generic[], Variable unknown[], Ordering ordering) {
+        return compute(generic,unknown,ordering,0);
+    }
+
+    public static Basis compute(Generic generic[], Variable unknown[], Ordering ordering, int modulo) {
+        return compute(generic,unknown,ordering,modulo,0);
+    }
+
+    public static Basis compute(Generic generic[], Variable unknown[], Ordering ordering, int modulo, int flags) {
+        flags^=DEFAULT;
+        return compute(generic,unknown,ordering,modulo,flags,(flags&Basis.DEGREE)>0,(flags&DEFINING_EQS)>0);
+    }
+
+    static Basis compute(Generic generic[], Variable unknown[], Ordering ordering, int modulo, int flags, boolean degree, boolean defining) {
+        if(degree) return compute(compute(generic,unknown,Monomial.degreeReverseLexicographic,modulo,flags,false,defining).elements(),unknown,ordering,modulo,flags,false,defining);
+        return Standard.compute(new Basis(defining?augment(defining(unknown,modulo),generic):generic,Polynomial.factory(unknown,ordering,modulo,flags)),flags);
+    }
+
+    public Basis valueof(Generic generic[]) {
+        return new Basis(generic,factory);
+    }
+
+    public Basis modulo(int modulo) {
+        return new Basis(element,Polynomial.factory(factory,modulo));
+    }
+
+    public static Generic[] defining(Variable unknown[], int modulo) {
+        Generic a[]=new Generic[unknown.length];
+        for(int i=0;i<unknown.length;i++) {
+            Generic s=unknown[i].expressionValue();
+            a[i]=s.subtract(s.pow(modulo));
+        }
+        return a;
+    }
+
+    public static boolean compatible(Generic generic[]) {
+        return !(generic.length>0 && generic[0].compareTo(JSCLInteger.valueOf(1))==0);
+    }
+
+    public static Generic[] augment(Generic element[], Generic generic[]) {
+        return (Generic[])ArrayUtils.concat(element,generic,new Generic[element.length+generic.length]);
+    }
+
+    public static Variable[] augmentUnknown(Variable unknown[], Generic generic[]) {
+        Variable va[]=Expression.variables(generic);
+        List l=new ArrayList();
+        for(int i=0;i<unknown.length;i++) l.add(unknown[i]);
+        int n=0;
+        for(int i=0;i<va.length;i++) {
+            Variable v=va[i];
+            if(l.contains(v));
+            else l.add(n++,v);
+        }
+        return (Variable[])ArrayUtils.toArray(l,new Variable[l.size()]);
+    }
+
+    public Generic[] elements() {
+        return element;
+    }
+
+    public Ordering ordering() {
+        return factory.ordering();
+    }
+
+    public Polynomial polynomial(Generic generic) {
+        return factory.valueof(generic).normalize().freeze();
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append("{");
+        for(int i=0;i<element.length;i++) {
+            buffer.append(polynomial(element[i])).append(i<element.length-1?", ":"");
+        }
+        buffer.append("}");
+        buffer.append(", "+ArrayUtils.toString(factory.monomialFactory.unknown()));
+        return buffer.toString();
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/BooleanMonomial.java b/src/misc/src/jscl/math/polynomial/BooleanMonomial.java
new file mode 100644
index 00000000..56b3f312
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/BooleanMonomial.java
@@ -0,0 +1,112 @@
+package jscl.math.polynomial;
+
+import jscl.math.NotDivisibleException;
+import jscl.math.Variable;
+
+class BooleanMonomial extends SmallMonomial {
+    static final int log2n=1;
+    static final int log2p=5-log2n;
+    static final int nmask=(1<<(1<<log2n))-1;
+    static final int pmask=(1<<log2p)-1;
+
+    BooleanMonomial(Variable unknown[], Ordering ordering) {
+        this(((unknown.length-1)>>log2p)+1,unknown,ordering);
+    }
+
+    BooleanMonomial(int length, Variable unknown[], Ordering ordering) {
+        super(length,unknown,ordering);
+    }
+
+    public Monomial multiply(Monomial monomial) {
+        Monomial m=newinstance();
+        for(int i=0;i<unknown.length;i++) {
+            int q=i>>log2p;
+            int r=(i&pmask)<<log2n;
+            int a=(element[q]>>r)&nmask;
+            int b=(monomial.element[q]>>r)&nmask;
+            int c=a+b;
+            if(c>nmask) throw new ArithmeticException();
+            m.element[q]|=c<<r;
+            m.degree+=c;
+        }
+        return m;
+    }
+
+    public boolean multiple(Monomial monomial, boolean strict) {
+        boolean equal=true;
+        for(int i=0;i<unknown.length;i++) {
+            int q=i>>log2p;
+            int r=(i&pmask)<<log2n;
+            int a=(element[q]>>r)&nmask;
+            int b=(monomial.element[q]>>r)&nmask;
+            if(a<b) return false;
+            equal&=a==b;
+        }
+        return strict?!equal:true;
+    }
+
+    public Monomial divide(Monomial monomial) throws ArithmeticException {
+        Monomial m=newinstance();
+        for(int i=0;i<unknown.length;i++) {
+            int q=i>>log2p;
+            int r=(i&pmask)<<log2n;
+            int a=(element[q]>>r)&nmask;
+            int b=(monomial.element[q]>>r)&nmask;
+            int c=a-b;
+            if(c<0) throw new NotDivisibleException();
+            m.element[q]|=c<<r;
+        }
+        m.degree=degree-monomial.degree;
+        return m;
+    }
+
+    public Monomial gcd(Monomial monomial) {
+        Monomial m=newinstance();
+        for(int i=0;i<unknown.length;i++) {
+            int q=i>>log2p;
+            int r=(i&pmask)<<log2n;
+            int a=(element[q]>>r)&nmask;
+            int b=(monomial.element[q]>>r)&nmask;
+            int c=Math.min(a,b);
+            m.element[q]|=c<<r;
+            m.degree+=c;
+        }
+        return m;
+    }
+
+    public Monomial scm(Monomial monomial) {
+        Monomial m=newinstance();
+        for(int i=0;i<unknown.length;i++) {
+            int q=i>>log2p;
+            int r=(i&pmask)<<log2n;
+            int a=(element[q]>>r)&nmask;
+            int b=(monomial.element[q]>>r)&nmask;
+            int c=Math.max(a,b);
+            m.element[q]|=c<<r;
+            m.degree+=c;
+        }
+        return m;
+    }
+
+    public int element(int n) {
+        if(reverse()) n=unknown.length-1-n;
+        int q=n>>log2p;
+        int r=(n&pmask)<<log2n;
+        return (element[q]>>r)&nmask;
+    }
+
+    void put(int n, int integer) {
+        if(reverse()) n=unknown.length-1-n;
+        int q=n>>log2p;
+        int r=(n&pmask)<<log2n;
+        int a=(element[q]>>r)&nmask;
+        int c=a+integer;
+        if(c>nmask) throw new ArithmeticException();
+        element[q]|=c<<r;
+        degree+=c-a;
+    }
+
+    protected Monomial newinstance() {
+        return new BooleanMonomial(element.length,unknown,ordering);
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/DefinedBooleanMonomial.java b/src/misc/src/jscl/math/polynomial/DefinedBooleanMonomial.java
new file mode 100644
index 00000000..0b7c6615
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/DefinedBooleanMonomial.java
@@ -0,0 +1,32 @@
+package jscl.math.polynomial;
+
+import jscl.math.Variable;
+
+class DefinedBooleanMonomial extends BooleanMonomial {
+    DefinedBooleanMonomial(Variable unknown[], Ordering ordering) {
+        super(unknown,ordering);
+    }
+
+    DefinedBooleanMonomial(int length, Variable unknown[], Ordering ordering) {
+        super(length,unknown,ordering);
+    }
+
+    public Monomial multiply(Monomial monomial) {
+        Monomial m=newinstance();
+        for(int i=0;i<unknown.length;i++) {
+            int q=i>>log2p;
+            int r=(i&pmask)<<log2n;
+            int a=(element[q]>>r)&nmask;
+            int b=(monomial.element[q]>>r)&nmask;
+            int c=a+b;
+            if(c>1) c=1;
+            m.element[q]|=c<<r;
+            m.degree+=c;
+        }
+        return m;
+    }
+
+    protected Monomial newinstance() {
+        return new DefinedBooleanMonomial(element.length,unknown,ordering);
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/DegreeOrdering.java b/src/misc/src/jscl/math/polynomial/DegreeOrdering.java
new file mode 100644
index 00000000..7f95cfbb
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/DegreeOrdering.java
@@ -0,0 +1,3 @@
+package jscl.math.polynomial;
+
+public interface DegreeOrdering {}
diff --git a/src/misc/src/jscl/math/polynomial/GeoBucket.java b/src/misc/src/jscl/math/polynomial/GeoBucket.java
new file mode 100644
index 00000000..0d879424
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/GeoBucket.java
@@ -0,0 +1,354 @@
+package jscl.math.polynomial;
+
+import java.util.Iterator;
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.mathml.MathML;
+
+final class GeoBucket extends Polynomial {
+    final Polynomial factory;
+    Polynomial content[];
+    int size;
+    boolean mutable=true;
+    boolean canonicalized=true;
+
+    GeoBucket(Polynomial factory) {
+        super(factory.monomialFactory,factory.coefFactory);
+        this.factory=factory;
+    }
+
+    GeoBucket(int size, Polynomial factory) {
+        this(factory);
+        init(size);
+    }
+
+    public int size() {
+        return size;
+    }
+
+    void init(int size) {
+        content=new Polynomial[size];
+        this.size=size;
+    }
+
+    void resize(int size) {
+        Polynomial content[]=new Polynomial[size];
+        System.arraycopy(this.content,0,content,0,Math.min(this.size,size));
+        this.content=content;
+        this.size=size;
+    }
+
+    public Iterator iterator(boolean direction, Monomial current) {
+        return new ContentIterator(direction,current);
+    }
+
+    class ContentIterator implements Iterator {
+        final boolean direction;
+        Term term;
+
+        ContentIterator(boolean direction, Monomial current) {
+            this.direction=direction;
+            term=new Term(current,coefficient(JSCLInteger.valueOf(0)));
+            seek();
+        }
+
+        void seek() {
+            while(true) {
+                int n=0;
+                Term t=null;
+                for(int i=0;i<size;i++) {
+                    Polynomial p=content[i];
+                    if(p==null) continue;
+                    Iterator it=p.iterator(direction,term.monomial());
+                    Term u=it.hasNext()?(Term)it.next():null;
+                    if(u==null) continue;
+                    if(t==null || (direction?-1:1)*ordering.compare(t.monomial(),u.monomial())>0) {
+                        t=u;
+                        n=i;
+                    } else if(ordering.compare(t.monomial(),u.monomial())==0) {
+                        t=behead(t,n,i);
+                        n=i;
+                    }
+                }
+                if(t==null || t.coef().signum()!=0) {
+                    term=t;
+                    return;
+                }
+            }
+        }
+        
+        public boolean hasNext() {
+            return term!=null;
+        }
+        
+        public Object next() {
+            Term t=term;
+            seek();
+            return t;
+        }
+        
+        public void remove() {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    Term behead(Term t, int n, int i) {
+        Monomial m=t.monomial();
+        Polynomial p=factory.valueof(m).multiply(t.coef());
+        content[n]=content[n].subtract(p);
+        content[i]=content[i].add(p);
+        return new Term(m,content[i].coefficient(m));
+    }
+
+    void canonicalize() {
+        Polynomial s=factory.valueof(JSCLInteger.valueOf(0));
+        int sugar=0;
+        for(int i=0;i<size;i++) {
+            Polynomial p=content[i];
+            if(p==null) continue;
+            s=s.add(p);
+            sugar=Math.max(sugar,p.sugar());
+            content[i]=null;
+        }
+        resize(log(s.size())+1);
+        set(s.normalize());
+        canonicalized=true;
+        setSugar(sugar);
+        mutable=false;
+    }
+
+    static int log(int n) {
+        int i;
+        for(i=0;n>3;n>>=2) i++;
+        return i;
+    }
+
+    Polynomial polynomial() {
+        if(canonicalized) return content[size-1];
+        else throw new UnsupportedOperationException();
+    }
+
+    void set(Polynomial polynomial) {
+        content[size-1]=polynomial;
+    }
+
+    public Polynomial subtract(Polynomial polynomial) {
+        if(mutable) {
+            Polynomial q=((GeoBucket)polynomial).polynomial();
+            int n=log(q.size());
+            if(n>=size) resize(n+1);
+            Polynomial p=content[n];
+            Polynomial s=(p==null?factory.valueof(JSCLInteger.valueOf(0)):p).subtract(q);
+            content[n]=null;
+            while(n<log(s.size())) {
+                n++;
+                if(n>=size) resize(n+1);
+                p=content[n];
+                if(p!=null) s=p.add(s);
+                content[n]=null;
+            }
+            content[n]=s;
+            canonicalized=false;
+            normalized=false;
+            return this;
+        } else return copy().subtract(polynomial);
+    }
+
+    public Polynomial multiplyAndSubtract(Generic generic, Polynomial polynomial) {
+        if(mutable) {
+            Polynomial q=((GeoBucket)polynomial).polynomial();
+            int n=log(q.size());
+            if(n>=size) resize(n+1);
+            Polynomial p=content[n];
+            Polynomial s=(p==null?factory.valueof(JSCLInteger.valueOf(0)):p).multiplyAndSubtract(generic,q);
+            content[n]=null;
+            while(n<log(s.size())) {
+                n++;
+                if(n>=size) resize(n+1);
+                p=content[n];
+                if(p!=null) s=p.add(s);
+                content[n]=null;
+            }
+            content[n]=s;
+            canonicalized=false;
+            normalized=false;
+            return this;
+        } else return copy().multiplyAndSubtract(generic,polynomial);
+    }
+
+    public Polynomial multiplyAndSubtract(Monomial monomial, Generic generic, Polynomial polynomial) {
+        if(mutable) {
+            Polynomial q=((GeoBucket)polynomial).polynomial();
+            int n=log(q.size());
+            if(n>=size) resize(n+1);
+            Polynomial p=content[n];
+            Polynomial s=(p==null?factory.valueof(JSCLInteger.valueOf(0)):p).multiplyAndSubtract(monomial,generic,q);
+            content[n]=null;
+            while(n<log(s.size())) {
+                n++;
+                if(n>=size) resize(n+1);
+                p=content[n];
+                if(p!=null) s=p.add(s);
+                content[n]=null;
+            }
+            content[n]=s;
+            canonicalized=false;
+            normalized=false;
+            return this;
+        } else return copy().multiplyAndSubtract(monomial,generic,polynomial);
+    }
+
+    public Polynomial multiply(Generic generic) {
+        if(mutable) {
+            if(canonicalized) set(polynomial().multiply(generic));
+            else for(int i=0;i<size;i++) {
+                Polynomial p=content[i];
+                if(p!=null) content[i]=p.multiply(generic);
+            }
+            normalized=false;
+            return this;
+        } else return copy().multiply(generic);
+    }
+
+    public Polynomial multiply(Monomial monomial) {
+        if(mutable) {
+            set(polynomial().multiply(monomial));
+            return this;
+        } else return copy().multiply(monomial);
+    }
+
+    public Polynomial divide(Generic generic) throws ArithmeticException {
+        if(mutable) {
+            if(canonicalized) set(polynomial().divide(generic));
+            else for(int i=0;i<size;i++) {
+                Polynomial p=content[i];
+                if(p!=null) content[i]=p.divide(generic);
+            }
+            normalized=false;
+            return this;
+        } else return copy().divide(generic);
+    }
+
+    public Polynomial divide(Monomial monomial) throws ArithmeticException {
+        if(mutable) {
+            set(polynomial().divide(monomial));
+            return this;
+        } else return copy().divide(monomial);
+    }
+
+    public Polynomial gcd(Polynomial polynomial) {
+        throw new UnsupportedOperationException();
+    }
+
+    public Generic gcd() {
+        if(field) return coefficient(tail());
+        return canonicalized?polynomial().gcd():coefficient(JSCLInteger.valueOf(0));
+    }
+
+    public int degree() {
+        return polynomial().degree();
+    }
+
+    public Polynomial valueof(GeoBucket bucket) {
+        return valueof(bucket.polynomial().copy());
+    }
+
+    public Polynomial valueof(Polynomial polynomial) {
+        if(polynomial instanceof GeoBucket) {
+            return valueof((GeoBucket)polynomial);
+        } else {
+            GeoBucket b=new GeoBucket(log(polynomial.size())+1,factory);
+            b.set(polynomial);
+            return b;
+        }
+    }
+
+    public Polynomial valueof(Generic generic) {
+        return valueof(factory.valueof(generic));
+    }
+
+    public Polynomial valueof(Monomial monomial) {
+        return valueof(factory.valueof(monomial));
+    }
+
+    public Polynomial freeze() {
+        canonicalize();
+        return this;
+    }
+
+    public Term head() {
+        return canonicalized?polynomial().head():super.head();
+    }
+
+    public Term tail() {
+        return canonicalized?polynomial().tail():super.tail();
+    }
+
+    public Generic coefficient(Monomial monomial) {
+        return canonicalized?polynomial().coefficient(monomial):super.coefficient(monomial);
+    }
+
+    public int sugar() {
+        return polynomial().sugar();
+    }
+
+    public int index() {
+        return polynomial().index();
+    }
+
+    public void setSugar(int n) {
+        polynomial().setSugar(n);
+    }
+
+    public void setIndex(int n) {
+        polynomial().setIndex(n);
+    }
+
+    public Generic genericValue() {
+        return polynomial().genericValue();
+    }
+
+    public Generic[] elements() {
+        return polynomial().elements();
+    }
+
+    public int compareTo(GeoBucket bucket) {
+        return polynomial().compareTo(bucket.polynomial());
+    }
+
+    public int compareTo(Polynomial polynomial) {
+        return compareTo((GeoBucket)polynomial);
+    }
+
+    public String toString() {
+        if(canonicalized) return polynomial().toString();
+        else {
+            StringBuffer buffer=new StringBuffer();
+            buffer.append("{");
+            for(int i=0;i<size;i++) {
+                Polynomial p=content[i];
+                buffer.append(p==null?factory.valueof(JSCLInteger.valueOf(0)):p).append(i<size-1?", ":"");
+            }
+            buffer.append("}");
+            return buffer.toString();
+        }
+    }
+
+    public void toMathML(MathML element, Object data) {
+        if(canonicalized) polynomial().toMathML(element,data);
+        else {
+            MathML e1=element.element("mfenced");
+            MathML e2=element.element("mtable");
+            for(int i=0;i<size;i++) {
+                MathML e3=element.element("mtr");
+                MathML e4=element.element("mtd");
+                Polynomial p=content[i];
+                (p==null?factory.valueof(JSCLInteger.valueOf(0)):p).toMathML(e4,null);
+                e3.appendChild(e4);
+                e2.appendChild(e3);
+            }
+            e1.appendChild(e2);
+            element.appendChild(e1);
+        }
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/ListPolynomial.java b/src/misc/src/jscl/math/polynomial/ListPolynomial.java
new file mode 100644
index 00000000..b357945b
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/ListPolynomial.java
@@ -0,0 +1,324 @@
+package jscl.math.polynomial;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Map;
+import java.util.TreeMap;
+import jscl.math.Expression;
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.Literal;
+import jscl.util.ArrayUtils;
+
+final class ListPolynomial extends Polynomial {
+    final List content=new LinkedList();
+    int degree;
+    boolean mutable=true;
+
+    ListPolynomial(Monomial monomialFactory, Generic coefFactory) {
+        super(monomialFactory,coefFactory);
+    }
+
+    public int size() {
+        return content.size();
+    }
+
+    public final Iterator iterator(boolean direction, Monomial current) {
+        return new ContentIterator(direction,current);
+    }
+
+    class ContentIterator implements ListIterator {
+        final ListIterator iterator;
+        final boolean direction;
+
+        ContentIterator(boolean direction, Monomial current) {
+            this.direction=direction;
+            iterator=content.listIterator(indexOf(current,direction));
+        }
+        
+        public boolean hasNext() {
+            return direction?iterator.hasPrevious():iterator.hasNext();
+        }
+        
+        public Object next() {
+            return direction?iterator.previous():iterator.next();
+        }
+
+        public boolean hasPrevious() {
+            return direction?iterator.hasNext():iterator.hasPrevious();
+        }
+
+        public Object previous() {
+            return direction?iterator.next():iterator.previous();
+        }
+
+        public int nextIndex() {
+            return direction?iterator.previousIndex():iterator.nextIndex();
+        }
+
+        public int previousIndex() {
+            return direction?iterator.nextIndex():iterator.previousIndex();
+        }
+        
+        public void remove() {
+            iterator.remove();
+        }
+
+        public void set(Object o) {
+            iterator.set(o);
+        }
+
+        public void add(Object o) {
+            iterator.add(o);
+        }
+    }
+
+    int indexOf(Monomial monomial, boolean direction) {
+        if(monomial==null) return direction?content.size():0;
+        int n=ArrayUtils.binarySearch(content,new Term(monomial,null));
+        return n<0?-n-1:direction?n:n+1;
+    }
+
+    public Polynomial subtract(Polynomial polynomial) {
+        if(polynomial.signum()==0) return this;
+        if(mutable) {
+            ListPolynomial q=(ListPolynomial)polynomial;
+            ListIterator it1=content.listIterator(content.size());
+            ListIterator it2=q.content.listIterator(q.content.size());
+            Term t1=it1.hasPrevious()?(Term)it1.previous():null;
+            Term t2=it2.hasPrevious()?(Term)it2.previous():null;
+            while(t2!=null) {
+                int c=t1==null?1:(t2==null?-1:-ordering.compare(t1.monomial(),t2.monomial()));
+                if(c<0) {
+                    t1=it1.hasPrevious()?(Term)it1.previous():null;
+                } else {
+                    if(c>0) {
+                        if(t1!=null) it1.next();
+                        it1.add(t2.negate());
+                    } else {
+                        Term t=t1.subtract(t2);
+                        if(t.signum()==0) it1.remove();
+                        else it1.set(t);
+                    }
+                    t1=it1.hasPrevious()?(Term)it1.previous():null;
+                    t2=it2.hasPrevious()?(Term)it2.previous():null;
+                }
+            }
+            degree=degree(this);
+            sugar=Math.max(sugar,q.sugar);
+            normalized=false;
+            return this;
+        } else return copy().subtract(polynomial);
+    }
+
+    public Polynomial multiplyAndSubtract(Generic generic, Polynomial polynomial) {
+        if(generic.signum()==0) return this;
+        if(generic.compareTo(JSCLInteger.valueOf(1))==0) return subtract(polynomial);
+        if(mutable) {
+            ListPolynomial q=(ListPolynomial)polynomial;
+            ListIterator it1=content.listIterator(content.size());
+            ListIterator it2=q.content.listIterator(q.content.size());
+            Term t1=it1.hasPrevious()?(Term)it1.previous():null;
+            Term t2=it2.hasPrevious()?((Term)it2.previous()).multiply(generic):null;
+            while(t2!=null) {
+                int c=t1==null?1:(t2==null?-1:-ordering.compare(t1.monomial(),t2.monomial()));
+                if(c<0) {
+                    t1=it1.hasPrevious()?(Term)it1.previous():null;
+                } else {
+                    if(c>0) {
+                        if(t1!=null) it1.next();
+                        it1.add(t2.negate());
+                    } else {
+                        Term t=t1.subtract(t2);
+                        if(t.signum()==0) it1.remove();
+                        else it1.set(t);
+                    }
+                    t1=it1.hasPrevious()?(Term)it1.previous():null;
+                    t2=it2.hasPrevious()?((Term)it2.previous()).multiply(generic):null;
+                }
+            }
+            degree=degree(this);
+            sugar=Math.max(sugar,q.sugar);
+            normalized=false;
+            return this;
+        } else return copy().multiplyAndSubtract(generic,polynomial);
+    }
+
+    public Polynomial multiplyAndSubtract(Monomial monomial, Generic generic, Polynomial polynomial) {
+        if(defined) throw new UnsupportedOperationException();
+        if(generic.signum()==0) return this;
+        if(monomial.degree()==0) return multiplyAndSubtract(generic,polynomial);
+        if(mutable) {
+            ListPolynomial q=(ListPolynomial)polynomial;
+            ListIterator it1=content.listIterator(content.size());
+            ListIterator it2=q.content.listIterator(q.content.size());
+            Term t1=it1.hasPrevious()?(Term)it1.previous():null;
+            Term t2=it2.hasPrevious()?((Term)it2.previous()).multiply(monomial,generic):null;
+            while(t2!=null) {
+                int c=t1==null?1:(t2==null?-1:-ordering.compare(t1.monomial(),t2.monomial()));
+                if(c<0) {
+                    t1=it1.hasPrevious()?(Term)it1.previous():null;
+                } else {
+                    if(c>0) {
+                        if(t1!=null) it1.next();
+                        it1.add(t2.negate());
+                    } else {
+                        Term t=t1.subtract(t2);
+                        if(t.signum()==0) it1.remove();
+                        else it1.set(t);
+                    }
+                    t1=it1.hasPrevious()?(Term)it1.previous():null;
+                    t2=it2.hasPrevious()?((Term)it2.previous()).multiply(monomial,generic):null;
+                }
+            }
+            degree=degree(this);
+            sugar=Math.max(sugar,q.sugar+monomial.degree());
+            normalized=false;
+            return this;
+        } else return copy().multiplyAndSubtract(monomial,generic,polynomial);
+    }
+
+    public Polynomial multiply(Generic generic) {
+        if(generic.signum()==0) return valueof(JSCLInteger.valueOf(0));
+        if(generic.compareTo(JSCLInteger.valueOf(1))==0) return this;
+        if(mutable) {
+            ListIterator it=content.listIterator();
+            while(it.hasNext()) it.set(((Term)it.next()).multiply(generic));
+            normalized=false;
+            return this;
+        } else return copy().multiply(generic);
+    }
+
+    public Polynomial multiply(Monomial monomial) {
+        if(defined) throw new UnsupportedOperationException();
+        if(monomial.degree()==0) return this;
+        if(mutable) {
+            ListIterator it=content.listIterator();
+            while(it.hasNext()) it.set(((Term)it.next()).multiply(monomial));
+            degree+=monomial.degree();
+            sugar+=monomial.degree();
+            return this;
+        } else return copy().multiply(monomial);
+    }
+
+    public Polynomial divide(Generic generic) throws ArithmeticException {
+        if(generic.compareTo(JSCLInteger.valueOf(1))==0) return this;
+        if(mutable) {
+            ListIterator it=content.listIterator();
+            while(it.hasNext()) it.set(((Term)it.next()).divide(generic));
+            normalized=false;
+            return this;
+        } else return copy().divide(generic);
+    }
+
+    public Polynomial divide(Monomial monomial) throws ArithmeticException {
+        if(monomial.degree()==0) return this;
+        if(mutable) {
+            ListIterator it=content.listIterator();
+            while(it.hasNext()) it.set(((Term)it.next()).divide(monomial));
+            degree-=monomial.degree();
+            sugar-=monomial.degree();
+            return this;
+        } else return copy().divide(monomial);
+    }
+
+    public Polynomial gcd(Polynomial polynomial) {
+        throw new UnsupportedOperationException();
+    }
+
+    public int degree() {
+        return degree;
+    }
+
+    public Polynomial valueof(Polynomial polynomial) {
+        ListPolynomial p=newinstance(0);
+        p.init(polynomial);
+        return p;
+    }
+
+    public Polynomial valueof(Generic generic) {
+        ListPolynomial p=newinstance(0);
+        p.init(generic);
+        return p;
+    }
+
+    public Polynomial valueof(Monomial monomial) {
+        ListPolynomial p=newinstance(0);
+        p.init(monomial);
+        return p;
+    }
+
+    public Polynomial freeze() {
+        mutable=false;
+        return this;
+    }
+
+    public Term head() {
+        int size=content.size();
+        return size>0?(Term)content.get(size-1):null;
+    }
+
+    public Term tail() {
+        int size=content.size();
+        return size>0?(Term)content.get(0):null;
+    }
+
+    void init(Polynomial polynomial) {
+        ListPolynomial q=(ListPolynomial)polynomial;
+        content.addAll(q.content);
+        degree=q.degree;
+        sugar=q.sugar;
+    }
+
+    void init(Expression expression) {
+        Map map=new TreeMap(ordering);
+        int n=expression.size();
+        for(int i=0;i<n;i++) {
+            Literal l=expression.literal(i);
+            JSCLInteger en=expression.coef(i);
+            Monomial m=monomial(l);
+            l=l.divide(m.literalValue());
+            Generic a2=coefficient(l.degree()>0?en.multiply(Expression.valueOf(l)):en);
+            Generic a1=(Generic)map.get(m);
+            Generic a=a1==null?a2:a1.add(a2);
+            if(a.signum()==0) map.remove(m);
+            else map.put(m,a);
+        }
+        int sugar=0;
+        Iterator it=map.entrySet().iterator();
+        while(it.hasNext()) {
+            Map.Entry e=(Map.Entry)it.next();
+            Monomial m=(Monomial)e.getKey();
+            Generic a=(Generic)e.getValue();
+            content.add(new Term(m,a));
+            sugar=Math.max(sugar,m.degree());
+        }
+        degree=degree(this);
+        this.sugar=sugar;
+    }
+
+    void init(Generic generic) {
+        if(generic instanceof Expression) {
+            init((Expression)generic);
+        } else {
+            Generic a=coefficient(generic);
+            if(a.signum()!=0) {
+                content.add(new Term(monomial(Literal.valueOf()),a));
+            }
+            degree=0;
+            sugar=0;
+        }
+    }
+
+    void init(Monomial monomial) {
+        content.add(new Term(monomial,coefficient(JSCLInteger.valueOf(1))));
+        degree=monomial.degree();
+        sugar=monomial.degree();
+    }
+
+    protected ListPolynomial newinstance(int n) {
+        return new ListPolynomial(monomialFactory,coefFactory);
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/Monomial.java b/src/misc/src/jscl/math/polynomial/Monomial.java
new file mode 100644
index 00000000..6658ab59
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/Monomial.java
@@ -0,0 +1,406 @@
+package jscl.math.polynomial;
+
+import java.util.Iterator;
+import jscl.math.Literal;
+import jscl.math.NotDivisibleException;
+import jscl.math.Variable;
+import jscl.math.function.Frac;
+import jscl.math.function.Pow;
+import jscl.mathml.MathML;
+
+public class Monomial implements Comparable {
+    public static final Ordering lexicographic=Lexicographic.ordering;
+    public static final Ordering totalDegreeLexicographic=TotalDegreeLexicographic.ordering;
+    public static final Ordering degreeReverseLexicographic=DegreeReverseLexicographic.ordering;
+    public static final Ordering iteratorOrdering=totalDegreeLexicographic;
+    final Variable unknown[];
+    final Ordering ordering;
+    final int element[];
+    int degree;
+
+    Monomial(Variable unknown[], Ordering ordering) {
+        this(unknown.length,unknown,ordering);
+    }
+
+    Monomial(int length, Variable unknown[], Ordering ordering) {
+        this.unknown=unknown;
+        this.ordering=ordering;
+        element=new int[length];
+    }
+
+    public static Ordering kthElimination(int k) {
+        return new KthElimination(k,1);
+    }
+
+    public Variable[] unknown() {
+        return unknown;
+    }
+
+    public Ordering ordering() {
+        return ordering;
+    }
+
+    public Monomial multiply(Monomial monomial) {
+        Monomial m=newinstance();
+        for(int i=0;i<unknown.length;i++) {
+            m.element[i]=element[i]+monomial.element[i];
+        }
+        m.degree=degree+monomial.degree;
+        return m;
+    }
+
+    public boolean multiple(Monomial monomial) {
+        return multiple(monomial,false);
+    }
+
+    public boolean multiple(Monomial monomial, boolean strict) {
+        boolean equal=true;
+        for(int i=0;i<unknown.length;i++) {
+            if(element[i]<monomial.element[i]) return false;
+            equal&=element[i]==monomial.element[i];
+        }
+        return strict?!equal:true;
+    }
+
+    public Monomial divide(Monomial monomial) throws ArithmeticException {
+        Monomial m=newinstance();
+        for(int i=0;i<unknown.length;i++) {
+            int n=element[i]-monomial.element[i];
+            if(n<0) throw new NotDivisibleException();
+            m.element[i]=n;
+        }
+        m.degree=degree-monomial.degree;
+        return m;
+    }
+
+    public Monomial gcd(Monomial monomial) {
+        Monomial m=newinstance();
+        for(int i=0;i<unknown.length;i++) {
+            int n=Math.min(element[i],monomial.element[i]);
+            m.element[i]=n;
+            m.degree+=n;
+        }
+        return m;
+    }
+
+    public Monomial scm(Monomial monomial) {
+        Monomial m=newinstance();
+        for(int i=0;i<unknown.length;i++) {
+            int n=Math.max(element[i],monomial.element[i]);
+            m.element[i]=n;
+            m.degree+=n;
+        }
+        return m;
+    }
+
+    public int degree() {
+        return degree;
+    }
+
+    public Monomial valueof(Monomial monomial) {
+        Monomial m=newinstance();
+        System.arraycopy(monomial.element, 0, m.element, 0, m.element.length);
+        m.degree=monomial.degree;
+        return m;
+    }
+
+    public Monomial valueof(Literal literal) {
+        Monomial m=newinstance();
+        m.init(literal);
+        return m;
+    }
+
+    public Literal literalValue() {
+        return Literal.valueOf(this);
+    }
+
+    public int element(int n) {
+        return element[n];
+    }
+
+    public Iterator iterator() {
+        return iterator(newinstance());
+    }
+
+    public Iterator iterator(Monomial beginning) {
+        return new MonomialIterator(beginning,this);
+    }
+
+    public Iterator divisor() {
+        return divisor(newinstance());
+    }
+
+    public Iterator divisor(Monomial beginning) {
+        return new MonomialDivisor(beginning,this);
+    }
+
+    static Monomial factory(Variable unknown[]) {
+        return factory(unknown,lexicographic);
+    }
+
+    static Monomial factory(Variable unknown[], Ordering ordering) {
+        return factory(unknown,ordering,0);
+    }
+
+    static Monomial factory(Variable unknown[], Ordering ordering, int power_size) {
+        switch(power_size) {
+        case Basis.POWER_8:
+            return new SmallMonomial(unknown,small(ordering));
+        case Basis.POWER_2:
+            return new BooleanMonomial(unknown,small(ordering));
+        case Basis.POWER_2_DEFINED:
+            return new DefinedBooleanMonomial(unknown,small(ordering));
+        default:
+            return new Monomial(unknown,ordering);
+        }
+    }
+
+    static Ordering small(Ordering ordering) {
+        if(ordering==lexicographic) return SmallMonomial.lexicographic;
+        else if(ordering==totalDegreeLexicographic) return SmallMonomial.totalDegreeLexicographic;
+        else if(ordering==degreeReverseLexicographic) return SmallMonomial.degreeReverseLexicographic;
+        else throw new UnsupportedOperationException();
+    }
+
+    public int compareTo(Monomial monomial) {
+        return ordering.compare(this,monomial);
+    }
+
+    public int compareTo(Object o) {
+        return compareTo((Monomial)o);
+    }
+
+    void init(Literal literal) {
+        int s=literal.size();
+        for(int i=0;i<s;i++) {
+            Variable v=literal.variable(i);
+            int c=literal.power(i);
+            int n=variable(v,unknown);
+            if(n<unknown.length) put(n,c);
+        }
+    }
+
+    static int variable(Variable v, Variable unknown[]) {
+        int i=0;
+        for(;i<unknown.length;i++) if(unknown[i].equals(v)) break;
+        return i;
+    }
+
+    void put(int n, int integer) {
+        element[n]+=integer;
+        degree+=integer;
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        if(degree==0) buffer.append("1");
+        boolean b=false;
+        for(int i=0;i<unknown.length;i++) {
+            int c=element(i);
+            if(c>0) {
+                if(b) buffer.append("*");
+                else b=true;
+                Variable v=unknown[i];
+                if(c==1) buffer.append(v);
+                else {
+                    if(v instanceof Frac || v instanceof Pow) {
+                        buffer.append("(").append(v).append(")");
+                    } else buffer.append(v);
+                    buffer.append("^").append(c);
+                }
+            }
+        }
+        return buffer.toString();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        if(degree==0) {
+            MathML e1=element.element("mn");
+            e1.appendChild(element.text("1"));
+            element.appendChild(e1);
+        }
+        for(int i=0;i<unknown.length;i++) {
+            int c=element(i);
+            if(c>0) {
+                unknown[i].toMathML(element,new Integer(c));
+            }
+        }
+    }
+
+    protected Monomial newinstance() {
+        return new Monomial(element.length,unknown,ordering);
+    }
+}
+
+class MonomialIterator implements Iterator {
+    static final Ordering ordering=Monomial.iteratorOrdering;
+    Monomial monomial;
+    Monomial current;
+    boolean carry;
+
+    MonomialIterator(Monomial beginning, Monomial monomial) {
+        this.monomial=monomial;
+        current=monomial.valueof(beginning);
+        if(ordering.compare(current,monomial)>0) carry=true;
+    }
+
+    public boolean hasNext() {
+        return !carry;
+    }
+
+    public Object next() {
+        Monomial m=monomial.valueof(current);
+        if(ordering.compare(current,monomial)<0) increment();
+        else carry=true;
+        return m;
+    }
+
+    void increment() {
+        int s=0;
+        int n=0;
+        while(n<current.element.length && current.element[n]==0) n++;
+        if(n<current.element.length) {
+            s=current.element[n];
+            current.element[n]=0;
+            n++;
+        }
+        if(n<current.element.length) {
+            current.element[n]++;
+            fill(s-1);
+        } else {
+            current.degree++;
+            fill(s+1);
+        }
+    }
+
+    private void fill(int s) {
+        current.element[0]=s;
+    }
+
+    public void remove() {
+        throw new UnsupportedOperationException();
+    }
+}
+
+class MonomialDivisor extends MonomialIterator {
+    MonomialDivisor(Monomial beginning, Monomial monomial) {
+        super(beginning,monomial);
+        if(hasNext()) seek();
+    }
+
+    void seek() {
+        int n=current.element.length;
+        while(n>0) {
+            n--;
+            if(current.element[n]>monomial.element[n]) break;
+        }
+        int p=n;
+        while(n>0) {
+            n--;
+            current.element[p]+=current.element[n];
+            current.element[n]=0;
+        }
+        if(p<current.element.length && current.element[p]>monomial.element[p]) increment();
+    }
+
+    void increment() {
+        int s=0;
+        int n=0;
+        while(n<current.element.length && current.element[n]==0) n++;
+        if(n<current.element.length) {
+            s=current.element[n];
+            current.element[n]=0;
+            n++;
+        }
+        while(n<current.element.length && current.element[n]==monomial.element[n]) {
+            s+=current.element[n];
+            current.element[n]=0;
+            n++;
+        }
+        if(n<current.element.length) {
+            current.element[n]++;
+            fill(s-1);
+        } else {
+            current.degree++;
+            fill(s+1);
+        }
+    }
+
+    private void fill(int s) {
+        for(int i=0;i<current.element.length;i++) {
+            int d=Math.min(monomial.element[i]-current.element[i],s);
+            current.element[i]+=d;
+            s-=d;
+        }
+    }
+}
+
+class Lexicographic extends Ordering {
+    public static final Ordering ordering=new Lexicographic();
+
+    Lexicographic() {}
+
+    public int compare(Monomial m1, Monomial m2) {
+        int c1[]=m1.element;
+        int c2[]=m2.element;
+        int n=c1.length;
+        for(int i=n-1;i>=0;i--) {
+            if(c1[i]<c2[i]) return -1;
+            else if(c1[i]>c2[i]) return 1;
+        }
+        return 0;
+    }
+}
+
+class TotalDegreeLexicographic extends Lexicographic implements DegreeOrdering {
+    public static final Ordering ordering=new TotalDegreeLexicographic();
+
+    TotalDegreeLexicographic() {}
+
+    public int compare(Monomial m1, Monomial m2) {
+        if(m1.degree<m2.degree) return -1;
+        else if(m1.degree>m2.degree) return 1;
+        else return super.compare(m1,m2);
+    }
+}
+
+class DegreeReverseLexicographic extends Ordering implements DegreeOrdering {
+    public static final Ordering ordering=new DegreeReverseLexicographic();
+
+    DegreeReverseLexicographic() {}
+
+    public int compare(Monomial m1, Monomial m2) {
+        if(m1.degree<m2.degree) return -1;
+        else if(m1.degree>m2.degree) return 1;
+        else {
+            int c1[]=m1.element;
+            int c2[]=m2.element;
+            int n=c1.length;
+            for(int i=0;i<n;i++) {
+                if(c1[i]>c2[i]) return -1;
+                else if(c1[i]<c2[i]) return 1;
+            }
+            return 0;
+        }
+    }
+}
+
+class KthElimination extends Ordering {
+    final int k;
+
+    KthElimination(int k, int direction) {
+        this.k=k;
+    }
+
+    public int compare(Monomial m1, Monomial m2) {
+        int c1[]=m1.element;
+        int c2[]=m2.element;
+        int n=c1.length;
+        int k=n-this.k;
+        for(int i=n-1;i>=k;i--) {
+            if(c1[i]<c2[i]) return -1;
+            else if(c1[i]>c2[i]) return 1;
+        }
+        return DegreeReverseLexicographic.ordering.compare(m1,m2);
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/NestedPolynomial.java b/src/misc/src/jscl/math/polynomial/NestedPolynomial.java
new file mode 100644
index 00000000..8ac7df8f
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/NestedPolynomial.java
@@ -0,0 +1,225 @@
+package jscl.math.polynomial;
+
+import jscl.math.Expression;
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.NotExpressionException;
+import jscl.math.NotIntegerException;
+import jscl.math.NotIntegrableException;
+import jscl.math.NotPowerException;
+import jscl.math.NotProductException;
+import jscl.math.NotVariableException;
+import jscl.math.Power;
+import jscl.math.Variable;
+import jscl.mathml.MathML;
+
+class NestedPolynomial extends UnivariatePolynomial {
+    NestedPolynomial(Variable variable[]) {
+        this(variable[0],PolynomialWrapper.factory(variable));
+    }
+
+    NestedPolynomial(Variable variable, Generic coefFactory) {
+        super(variable,coefFactory);
+    }
+
+    protected UnivariatePolynomial newinstance() {
+        return new NestedPolynomial(variable,coefFactory);
+    }
+}
+
+final class PolynomialWrapper extends Generic {
+    final Polynomial content;
+
+    PolynomialWrapper(Polynomial polynomial) {
+        content=polynomial;
+    }
+
+    Polynomial content() {
+        return content;
+    }
+
+    public PolynomialWrapper add(PolynomialWrapper wrapper) {
+        return new PolynomialWrapper(content.add(wrapper.content));
+    }
+
+    public Generic add(Generic generic) {
+        if(generic instanceof PolynomialWrapper) {
+            return add((PolynomialWrapper)generic);
+        } else {
+            return add(valueof(generic));
+        }
+    }
+
+    public PolynomialWrapper subtract(PolynomialWrapper wrapper) {
+        return new PolynomialWrapper(content.subtract(wrapper.content));
+    }
+
+    public Generic subtract(Generic generic) {
+        if(generic instanceof PolynomialWrapper) {
+            return subtract((PolynomialWrapper)generic);
+        } else {
+            return subtract(valueof(generic));
+        }
+    }
+
+    public PolynomialWrapper multiply(PolynomialWrapper wrapper) {
+        return new PolynomialWrapper(content.multiply(wrapper.content));
+    }
+
+    public Generic multiply(Generic generic) {
+        if(generic instanceof PolynomialWrapper) {
+            return multiply((PolynomialWrapper)generic);
+        } else {
+            return multiply(valueof(generic));
+        }
+    }
+
+    public PolynomialWrapper divide(PolynomialWrapper wrapper) throws ArithmeticException {
+        return new PolynomialWrapper(content.divide(wrapper.content));
+    }
+
+    public Generic divide(Generic generic) throws ArithmeticException {
+        if(generic instanceof PolynomialWrapper) {
+            return divide((PolynomialWrapper)generic);
+        } else {
+            return divide(valueof(generic));
+        }
+    }
+
+    public PolynomialWrapper gcd(PolynomialWrapper wrapper) {
+        return new PolynomialWrapper(content.gcd(wrapper.content));
+    }
+
+    public Generic gcd(Generic generic) {
+        if(generic instanceof PolynomialWrapper) {
+            return gcd((PolynomialWrapper)generic);
+        } else {
+            return gcd(valueof(generic));
+        }
+    }
+
+    public Generic gcd() {
+        return content.gcd();
+    }
+
+    public Generic negate() {
+        return new PolynomialWrapper(content.negate());
+    }
+
+    public int signum() {
+        return content.signum();
+    }
+
+    public int degree() {
+        return content.degree();
+    }
+
+    public Generic antiderivative(Variable variable) throws NotIntegrableException {
+        return null;
+    }
+
+    public Generic derivative(Variable variable) {
+        return null;
+    }
+
+    public Generic substitute(Variable variable, Generic generic) {
+        return null;
+    }
+
+    public Generic expand() {
+        return null;
+    }
+
+    public Generic factorize() {
+        return null;
+    }
+
+    public Generic elementary() {
+        return null;
+    }
+
+    public Generic simplify() {
+        return null;
+    }
+
+    public Generic numeric() {
+        return null;
+    }
+
+    public Generic valueof(Generic generic) {
+        if(generic instanceof PolynomialWrapper) {
+            return new PolynomialWrapper(content.valueof(((PolynomialWrapper)generic).content));
+        } else {
+            return new PolynomialWrapper(content.valueof(generic));
+        }
+    }
+
+    public Generic[] sumValue() {
+        return null;
+    }
+
+    public Generic[] productValue() throws NotProductException {
+        return null;
+    }
+
+    public Power powerValue() throws NotPowerException {
+        return null;
+    }
+
+    public Expression expressionValue() throws NotExpressionException {
+        return content.genericValue().expressionValue();
+    }
+
+    public JSCLInteger integerValue() throws NotIntegerException {
+        throw new NotIntegerException();
+    }
+
+    public Variable variableValue() throws NotVariableException {
+        throw new NotVariableException();
+    }
+
+    public Variable[] variables() {
+        return new Variable[0];
+    }
+
+    public boolean isPolynomial(Variable variable) {
+        return false;
+    }
+
+    public boolean isConstant(Variable variable) {
+        return false;
+    }
+
+    public int compareTo(PolynomialWrapper wrapper) {
+        return content.compareTo(wrapper.content);
+    }
+
+    public int compareTo(Generic generic) {
+        if(generic instanceof PolynomialWrapper) {
+            return compareTo((PolynomialWrapper)generic);
+        } else {
+            return compareTo(valueof(generic));
+        }
+    }
+
+    public static Generic factory(Variable variable[]) {
+        if(variable.length>1) {
+            Variable var[]=new Variable[variable.length-1];
+            for(int i=0;i<var.length;i++) var[i]=variable[i+1];
+            return new PolynomialWrapper(NestedPolynomial.factory(var));
+        } else return null;
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        if(signum()<0) buffer.append("-").append(negate());
+        else buffer.append("(").append(content).append(")");
+        return buffer.toString();
+    }
+
+    public String toJava() {
+        return null;
+    }
+
+    public void toMathML(MathML element, Object data) {}
+}
diff --git a/src/misc/src/jscl/math/polynomial/Ordering.java b/src/misc/src/jscl/math/polynomial/Ordering.java
new file mode 100644
index 00000000..7a283d60
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/Ordering.java
@@ -0,0 +1,11 @@
+package jscl.math.polynomial;
+
+import java.util.Comparator;
+
+public abstract class Ordering implements Comparator {
+    public abstract int compare(Monomial m1, Monomial m2);
+
+    public int compare(Object o1, Object o2) {
+        return compare((Monomial)o1,(Monomial)o2);
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/Polynomial.java b/src/misc/src/jscl/math/polynomial/Polynomial.java
new file mode 100644
index 00000000..e0a50aa9
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/Polynomial.java
@@ -0,0 +1,481 @@
+package jscl.math.polynomial;
+
+import java.util.Collection;
+import java.util.Iterator;
+import jscl.math.Arithmetic;
+import jscl.math.Expression;
+import jscl.math.Field;
+import jscl.math.Generic;
+import jscl.math.GenericVariable;
+import jscl.math.JSCLBoolean;
+import jscl.math.JSCLInteger;
+import jscl.math.Literal;
+import jscl.math.ModularInteger;
+import jscl.math.NotDivisibleException;
+import jscl.math.Rational;
+import jscl.math.Variable;
+import jscl.mathml.MathML;
+
+public abstract class Polynomial implements Arithmetic, Comparable {
+    final Monomial monomialFactory;
+    final Generic coefFactory;
+    final Ordering ordering;
+    final boolean defined;
+    final boolean field;
+    boolean normalized;
+    int sugar;
+    int index=-1;
+
+    Polynomial(Monomial monomialFactory, Generic coefFactory) {
+        this.monomialFactory=monomialFactory;
+        this.coefFactory=coefFactory;
+        ordering=monomialFactory.ordering();
+        defined=monomialFactory instanceof DefinedBooleanMonomial;
+        field=coefFactory instanceof Field;
+    }
+
+    public abstract int size();
+
+    public Ordering ordering() {
+        return ordering;
+    }
+
+    public final Iterator iterator() {
+        return iterator(false);
+    }
+
+    public final Iterator iterator(boolean direction) {
+        return iterator(direction,null);
+    }
+
+    public final Iterator iterator(Monomial current) {
+        return iterator(true,current);
+    }
+
+    public abstract Iterator iterator(boolean direction, Monomial current);
+
+    public Polynomial add(Polynomial polynomial) {
+        return multiplyAndSubtract(coefficient(JSCLInteger.valueOf(-1)),polynomial);
+    }
+
+    public abstract Polynomial subtract(Polynomial polynomial);
+
+    public Polynomial multiplyAndSubtract(Generic generic, Polynomial polynomial) {
+        return subtract(polynomial.multiply(generic));
+    }
+
+    public Polynomial multiplyAndSubtract(Monomial monomial, Generic generic, Polynomial polynomial) {
+        return subtract(polynomial.multiply(monomial).multiply(generic));
+    }
+
+    public Polynomial multiply(Polynomial polynomial) {
+        Polynomial p=valueof(JSCLInteger.valueOf(0));
+        Iterator it=iterator();
+        while(it.hasNext()) {
+            Term t=(Term)it.next();
+            p=p.multiplyAndSubtract(t.monomial(),t.coef().negate(),polynomial);
+        }
+        return p;
+    }
+
+    public abstract Polynomial multiply(Generic generic);
+    public abstract Polynomial multiply(Monomial monomial);
+
+    public boolean multiple(Polynomial polynomial) throws ArithmeticException {
+        return remainder(polynomial).signum()==0;
+    }
+
+    public Polynomial divide(Polynomial polynomial) throws ArithmeticException {
+        Polynomial p[]=divideAndRemainder(polynomial);
+        if(p[1].signum()==0) return p[0];
+        else throw new NotDivisibleException();
+    }
+
+    public abstract Polynomial divide(Generic generic) throws ArithmeticException;
+    public abstract Polynomial divide(Monomial monomial) throws ArithmeticException;
+
+    public Arithmetic add(Arithmetic arithmetic) {
+        return add((Polynomial)arithmetic);
+    }
+
+    public Arithmetic subtract(Arithmetic arithmetic) {
+        return subtract((Polynomial)arithmetic);
+    }
+
+    public Arithmetic multiply(Arithmetic arithmetic) {
+        return multiply((Polynomial)arithmetic);
+    }
+
+    public Arithmetic divide(Arithmetic arithmetic) throws ArithmeticException {
+        return divide((Polynomial)arithmetic);
+    }
+
+    public Polynomial[] divideAndRemainder(Polynomial polynomial) throws ArithmeticException {
+        Polynomial p[]={valueof(JSCLInteger.valueOf(0)),this};
+        Polynomial q=polynomial;
+        Iterator it=p[1].iterator(true);
+        while(it.hasNext()) {
+            Term t=(Term)it.next();
+            Monomial m1=t.monomial();
+            Monomial m2=q.head().monomial();
+            if(m1.multiple(m2)) {
+                Monomial m=m1.divide(m2);
+                Generic c1=t.coef();
+                Generic c2=q.head().coef();
+                Generic c=c1.divide(c2);
+                p[0]=p[0].multiplyAndSubtract(m,c,valueof(JSCLInteger.valueOf(-1)));
+                p[1]=p[1].multiplyAndSubtract(m,c,q);
+                it=p[1].iterator(true);
+            }
+        }
+        return p;
+    }
+
+    public Polynomial remainder(Polynomial polynomial) throws ArithmeticException {
+        return divideAndRemainder(polynomial)[1];
+    }
+
+    public Polynomial remainderUpToCoefficient(Polynomial polynomial) throws ArithmeticException {
+        Polynomial p=this;
+        Polynomial q=polynomial;
+        Iterator it=p.iterator(true);
+        while(it.hasNext()) {
+            Term t=(Term)it.next();
+            Monomial m1=t.monomial();
+            Monomial m2=q.head().monomial();
+            if(m1.multiple(m2)) {
+                Monomial m=m1.divide(m2);
+                Generic c1=t.coef();
+                Generic c2=q.head().coef();
+//              Generic c=c1.gcd(c2);
+//              c1=c1.divide(c);
+//              c2=c2.divide(c);
+                p=p.multiply(c2).multiplyAndSubtract(m,c1,q);
+                it=p.iterator(true);
+            }
+        }
+        return p;
+    }
+
+    public abstract Polynomial gcd(Polynomial polynomial);
+
+    public Polynomial scm(Polynomial polynomial) {
+        return divide(gcd(polynomial)).multiply(polynomial);
+    }
+
+    public Generic gcd() {
+        if(field) return coefficient(tail());
+        Generic a=coefficient(JSCLInteger.valueOf(0));
+        for(Iterator it=iterator();it.hasNext();) a=a.gcd(((Term)it.next()).coef());
+        return a.signum()==signum()?a:a.negate();
+    }
+
+    public final Polynomial[] gcdAndNormalize() {
+        Generic gcd=gcd();
+        return new Polynomial[] {valueof(gcd),gcd.signum()==0?this:divide(gcd)};
+    }
+
+    public final Polynomial normalize() {
+        if(normalized) return this;
+        else {
+            Polynomial p=gcdAndNormalize()[1];
+            p.normalized=true;
+            return p;
+        }
+    }
+
+    public Monomial monomialGcd() {
+        Monomial m=monomial(tail());
+        for(Iterator it=iterator();it.hasNext();) m=m.gcd(((Term)it.next()).monomial());
+        return m;
+    }
+
+    public Polynomial pow(int exponent) {
+        Polynomial a=valueof(JSCLInteger.valueOf(1));
+        for(int i=0;i<exponent;i++) a=a.multiply(this);
+        return a;
+    }
+
+    public Polynomial abs() {
+        return signum()<0?negate():this;
+    }
+
+    public Polynomial negate() {
+        return multiply(coefficient(JSCLInteger.valueOf(-1)));
+    }
+
+    public final int signum() {
+        return coefficient(tail()).signum();
+    }
+
+    static int degree(Polynomial polynomial) {
+        return polynomial.monomial(polynomial.head()).degree();
+    }
+
+    public abstract int degree();
+    public abstract Polynomial valueof(Polynomial polynomial);
+    public abstract Polynomial valueof(Generic generic);
+    public abstract Polynomial valueof(Monomial monomial);
+
+    public final Polynomial copy() {
+        return valueof(this);
+    }
+
+    public abstract Polynomial freeze();
+
+    public Term head() {
+        Iterator it=iterator(true);
+        return it.hasNext()?(Term)it.next():null;
+    }
+
+    public Term tail() {
+        Iterator it=iterator();
+        return it.hasNext()?(Term)it.next():null;
+    }
+
+    public Generic coefficient(Monomial monomial) {
+        Iterator it=iterator(false,monomial);
+        Term t=it.hasNext()?(Term)it.next():null;
+        return coefficient(t==null || ordering.compare(t.monomial(),monomial)==0?t:null);
+    }
+
+    Monomial monomial(Term term) {
+        return term==null?monomial(Literal.valueOf()):term.monomial();
+    }
+
+    Generic coefficient(Term term) {
+        return term==null?coefficient(JSCLInteger.valueOf(0)):term.coef();
+    }
+
+    protected Monomial monomial(Literal literal) {
+        return monomialFactory.valueof(literal);
+    }
+
+    protected Generic coefficient(Generic generic) {
+        return coefFactory==null?generic:coefFactory.valueof(generic);
+    }
+
+    public Polynomial reduce(Collection ideal, boolean tail) {
+        Polynomial p=this;
+        Iterator it=tail?p.iterator(p.head().monomial()):p.iterator(true);
+        loop: while(it.hasNext()) {
+            Term t=(Term)it.next();
+            Monomial m1=t.monomial();
+            Iterator iq=ideal.iterator();
+            while(iq.hasNext()) {
+                Polynomial q=(Polynomial)iq.next();
+                Monomial m2=q.head().monomial();
+                if(m1.multiple(m2)) {
+                    Monomial m=m1.divide(m2);
+                    p=p.reduce(t.coef(),m,q);
+                    it=tail?p.iterator(m1):p.iterator(true);
+                    continue loop;
+                }
+            }
+            tail=true;
+        }
+        return p;
+    }
+
+    public Polynomial reduce(Generic generic, Monomial monomial, Polynomial polynomial) {
+        if(field) return multiplyAndSubtract(monomial,generic.divide(polynomial.head().coef()),polynomial);
+        else {
+            Generic c1=generic;
+            Generic c2=polynomial.head().coef();
+            Generic c=c1.gcd(c2);
+            c1=c1.divide(c);
+            c2=c2.divide(c);
+            return multiply(c2).multiplyAndSubtract(monomial,c1,polynomial).normalize();
+        }
+    }
+
+    public Polynomial reduce(Generic generic, Polynomial polynomial) {
+        return reduce(generic,monomial(Literal.valueOf()),polynomial);
+    }
+
+    public int sugar() {
+        return sugar;
+    }
+
+    public int index() {
+        return index;
+    }
+
+    public void setSugar(int n) {
+        sugar=n;
+    }
+
+    public void setIndex(int n) {
+        if(index!=-1) throw new ArithmeticException();
+        index=n;
+    }
+
+    public Generic genericValue() {
+        Generic s=JSCLInteger.valueOf(0);
+        Iterator it=iterator();
+        while(it.hasNext()) {
+            Term t=(Term)it.next();
+            Monomial m=t.monomial();
+            Generic a=t.coef().expressionValue();
+            s=s.add(m.degree()>0?a.multiply(Expression.valueOf(m.literalValue())):a);
+        }
+        return s;
+    }
+
+    public Generic[] elements() {
+        int size=size();
+        Generic a[]=new Generic[size];
+        Iterator it=iterator();
+        for(int i=0;i<size;i++) a[i]=((Term)it.next()).coef();
+        return a;
+    }
+
+    public static Polynomial factory(Variable variable) {
+        return new UnivariatePolynomial(variable);
+    }
+
+    public static Polynomial factory(Variable variable[]) {
+        return new NestedPolynomial(variable);
+    }
+
+    public static Polynomial factory(Variable unknown[], Ordering ordering) {
+        return factory(unknown,ordering,0);
+    }
+
+    public static Polynomial factory(Variable unknown[], Ordering ordering, int modulo) {
+        return factory(unknown,ordering,modulo,0);
+    }
+
+    public static Polynomial factory(Variable unknown[], Ordering ordering, int modulo, int flags) {
+        return factory(Monomial.factory(unknown,ordering,flags&Basis.POWER_SIZE),modulo,flags&Basis.DATA_STRUCT,(flags&Basis.GEO_BUCKETS)>0);
+    }
+
+    static Polynomial factory(Monomial monomialFactory, int modulo, int data_struct, boolean buckets) {
+        if(buckets) return new GeoBucket(factory(monomialFactory,modulo,data_struct,false));
+        else switch(data_struct) {
+        case Basis.ARRAY:
+            return new ArrayPolynomial(monomialFactory,generic(modulo));
+        case Basis.TREE:
+            return new TreePolynomial(monomialFactory,generic(modulo));
+        case Basis.LIST:
+            return new ListPolynomial(monomialFactory,generic(modulo));
+        default:
+            switch(modulo) {
+            case -1:
+                return new ArrayPolynomialGeneric(monomialFactory,null);
+            case 0:
+                return new ArrayPolynomialInteger(monomialFactory);
+            case 1:
+                return new ArrayPolynomialRational(monomialFactory);
+            case 2:
+                return new ArrayPolynomialBoolean(monomialFactory);
+            default:
+                return new ArrayPolynomialModular(monomialFactory,ModularInteger.factory(modulo));
+            }
+        }
+    }
+
+    static Generic generic(int modulo) {
+        switch(modulo) {
+        case -1:
+            return null;
+        case 0:
+            return JSCLInteger.factory;
+        case 1:
+            return Rational.factory;
+        case 2:
+            return JSCLBoolean.factory;
+        default:
+            return ModularInteger.factory(modulo);
+        }
+    }
+
+    static Polynomial factory(Polynomial polynomial, int modulo) {
+        Monomial m=polynomial.monomialFactory;
+        return factory(m.unknown(),m.ordering(),modulo);
+    }
+
+    public int compareTo(Polynomial polynomial) {
+        Iterator it1=iterator(true);
+        Iterator it2=polynomial.iterator(true);
+        Term t1=it1.hasNext()?(Term)it1.next():null;
+        Term t2=it2.hasNext()?(Term)it2.next():null;
+        while(t1!=null || t2!=null) {
+            int c=t1==null?1:(t2==null?-1:ordering.compare(t1.monomial(),t2.monomial()));
+            if(c<0) return -1;
+            else if(c>0) return 1;
+            else {
+                c=t1.coef().compareTo(t2.coef());
+                if(c<0) return -1;
+                else if(c>0) return 1;
+                t1=it1.hasNext()?(Term)it1.next():null;
+                t2=it2.hasNext()?(Term)it2.next():null;
+            }
+        }
+        return 0;
+    }
+
+    public int compareTo(Object o) {
+        return compareTo((Polynomial)o);
+    }
+
+    public boolean equals(Object obj) {
+        if(obj instanceof Polynomial) {
+            return compareTo((Polynomial)obj)==0;
+        } else return false;
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        if(signum()==0) buffer.append("0");
+        int i=0;
+        for(Iterator it=iterator();it.hasNext();i++) {
+            Term t=(Term)it.next();
+            Monomial m=t.monomial();
+            Generic a=t.coef();
+            if(a instanceof Expression) a=a.signum()>0?GenericVariable.valueOf(a).expressionValue():GenericVariable.valueOf(a.negate()).expressionValue().negate();
+            if(a.signum()>0 && i>0) buffer.append("+");
+            if(m.degree()==0) buffer.append(a);
+            else {
+                if(a.abs().compareTo(JSCLInteger.valueOf(1))==0) {
+                    if(a.signum()<0) buffer.append("-");
+                } else buffer.append(a).append("*");
+                buffer.append(m);
+            }
+        }
+        return buffer.toString();
+    }
+
+    public void toMathML(MathML element, Object data) {
+        MathML e1=element.element("mrow");
+        if(signum()==0) {
+            MathML e2=element.element("mn");
+            e2.appendChild(element.text("0"));
+            e1.appendChild(e2);
+        }
+        int i=0;
+        for(Iterator it=iterator();it.hasNext();i++) {
+            Term t=(Term)it.next();
+            Monomial m=t.monomial();
+            Generic a=t.coef();
+            if(a instanceof Expression) a=a.signum()>0?GenericVariable.valueOf(a).expressionValue():GenericVariable.valueOf(a.negate()).expressionValue().negate();
+            if(a.signum()>0 && i>0) {
+                MathML e2=element.element("mo");
+                e2.appendChild(element.text("+"));
+                e1.appendChild(e2);
+            }
+            if(m.degree()==0) Expression.separateSign(e1,a);
+            else {
+                if(a.abs().compareTo(JSCLInteger.valueOf(1))==0) {
+                    if(a.signum()<0) {
+                        MathML e2=element.element("mo");
+                        e2.appendChild(element.text("-"));
+                        e1.appendChild(e2);
+                    }
+                } else Expression.separateSign(e1,a);
+                m.toMathML(e1,null);
+            }
+        }
+        element.appendChild(e1);
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/SmallMonomial.java b/src/misc/src/jscl/math/polynomial/SmallMonomial.java
new file mode 100644
index 00000000..00f1f329
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/SmallMonomial.java
@@ -0,0 +1,174 @@
+package jscl.math.polynomial;
+
+import jscl.math.NotDivisibleException;
+import jscl.math.Variable;
+
+class SmallMonomial extends Monomial {
+    static final Ordering lexicographic=SmallLexicographic.ordering;
+    static final Ordering totalDegreeLexicographic=SmallTotalDegreeLexicographic.ordering;
+    static final Ordering degreeReverseLexicographic=SmallDegreeReverseLexicographic.ordering;
+    static final int log2n=3;
+    static final int log2p=5-log2n;
+    static final int nmask=(1<<(1<<log2n))-1;
+    static final int pmask=(1<<log2p)-1;
+
+    SmallMonomial(Variable unknown[], Ordering ordering) {
+        this(((unknown.length-1)>>log2p)+1,unknown,ordering);
+    }
+
+    SmallMonomial(int length, Variable unknown[], Ordering ordering) {
+        super(length,unknown,ordering);
+    }
+
+    public Monomial multiply(Monomial monomial) {
+        Monomial m=newinstance();
+        for(int i=0;i<unknown.length;i++) {
+            int q=i>>log2p;
+            int r=(i&pmask)<<log2n;
+            int a=(element[q]>>r)&nmask;
+            int b=(monomial.element[q]>>r)&nmask;
+            int c=a+b;
+            if(c>nmask) throw new ArithmeticException();
+            m.element[q]|=c<<r;
+            m.degree+=c;
+        }
+        return m;
+    }
+
+    public boolean multiple(Monomial monomial, boolean strict) {
+        boolean equal=true;
+        for(int i=0;i<unknown.length;i++) {
+            int q=i>>log2p;
+            int r=(i&pmask)<<log2n;
+            int a=(element[q]>>r)&nmask;
+            int b=(monomial.element[q]>>r)&nmask;
+            if(a<b) return false;
+            equal&=a==b;
+        }
+        return strict?!equal:true;
+    }
+
+    public Monomial divide(Monomial monomial) throws ArithmeticException {
+        Monomial m=newinstance();
+        for(int i=0;i<unknown.length;i++) {
+            int q=i>>log2p;
+            int r=(i&pmask)<<log2n;
+            int a=(element[q]>>r)&nmask;
+            int b=(monomial.element[q]>>r)&nmask;
+            int c=a-b;
+            if(c<0) throw new NotDivisibleException();
+            m.element[q]|=c<<r;
+        }
+        m.degree=degree-monomial.degree;
+        return m;
+    }
+
+    public Monomial gcd(Monomial monomial) {
+        Monomial m=newinstance();
+        for(int i=0;i<unknown.length;i++) {
+            int q=i>>log2p;
+            int r=(i&pmask)<<log2n;
+            int a=(element[q]>>r)&nmask;
+            int b=(monomial.element[q]>>r)&nmask;
+            int c=Math.min(a,b);
+            m.element[q]|=c<<r;
+            m.degree+=c;
+        }
+        return m;
+    }
+
+    public Monomial scm(Monomial monomial) {
+        Monomial m=newinstance();
+        for(int i=0;i<unknown.length;i++) {
+            int q=i>>log2p;
+            int r=(i&pmask)<<log2n;
+            int a=(element[q]>>r)&nmask;
+            int b=(monomial.element[q]>>r)&nmask;
+            int c=Math.max(a,b);
+            m.element[q]|=c<<r;
+            m.degree+=c;
+        }
+        return m;
+    }
+
+    public int element(int n) {
+        if(reverse()) n=unknown.length-1-n;
+        int q=n>>log2p;
+        int r=(n&pmask)<<log2n;
+        return (element[q]>>r)&nmask;
+    }
+
+    void put(int n, int integer) {
+        if(reverse()) n=unknown.length-1-n;
+        int q=n>>log2p;
+        int r=(n&pmask)<<log2n;
+        int a=(element[q]>>r)&nmask;
+        int c=a+integer;
+        if(c>nmask) throw new ArithmeticException();
+        element[q]|=c<<r;
+        degree+=c-a;
+    }
+
+    boolean reverse() {
+        return ordering instanceof DegreeReverseLexicographic;
+    }
+
+    protected Monomial newinstance() {
+        return new SmallMonomial(element.length,unknown,ordering);
+    }
+}
+
+class SmallLexicographic extends Ordering {
+    public static final Ordering ordering=new SmallLexicographic();
+
+    SmallLexicographic() {}
+
+    public int compare(Monomial m1, Monomial m2) {
+        int c1[]=m1.element;
+        int c2[]=m2.element;
+        int n=c1.length;
+        for(int i=n-1;i>=0;i--) {
+            long l1=c1[i]&0xffffffffl;
+            long l2=c2[i]&0xffffffffl;
+            if(l1<l2) return -1;
+            else if(l1>l2) return 1;
+        }
+        return 0;
+    }
+}
+
+class SmallTotalDegreeLexicographic extends SmallLexicographic implements DegreeOrdering {
+    public static final Ordering ordering=new SmallTotalDegreeLexicographic();
+
+    SmallTotalDegreeLexicographic() {}
+
+
+    public int compare(Monomial m1, Monomial m2) {
+        if(m1.degree<m2.degree) return -1;
+        else if(m1.degree>m2.degree) return 1;
+        else return super.compare(m1,m2);
+    }
+}
+
+class SmallDegreeReverseLexicographic extends Ordering implements DegreeOrdering {
+    public static final Ordering ordering=new SmallDegreeReverseLexicographic();
+
+    SmallDegreeReverseLexicographic() {}
+
+    public int compare(Monomial m1, Monomial m2) {
+        if(m1.degree<m2.degree) return -1;
+        else if(m1.degree>m2.degree) return 1;
+        else {
+            int c1[]=m1.element;
+            int c2[]=m2.element;
+            int n=c1.length;
+            for(int i=n-1;i>=0;i--) {
+                long l1=c1[i]&0xffffffffl;
+                long l2=c2[i]&0xffffffffl;
+                if(l1>l2) return -1;
+                else if(l1<l2) return 1;
+            }
+            return 0;
+        }
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/Term.java b/src/misc/src/jscl/math/polynomial/Term.java
new file mode 100644
index 00000000..86e1383d
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/Term.java
@@ -0,0 +1,65 @@
+package jscl.math.polynomial;
+
+import jscl.math.Generic;
+
+public class Term implements Comparable {
+    final Monomial monomial;
+    final Generic coef;
+
+    public Term(Monomial monomial, Generic coef) {
+        this.monomial=monomial;
+        this.coef=coef;
+    }
+
+    public Term subtract(Term term) {
+        return new Term(monomial,coef.subtract(term.coef));
+    }
+
+    public Term multiply(Generic generic) {
+        return new Term(monomial,coef.multiply(generic));
+    }
+
+    public Term multiply(Monomial monomial, Generic generic) {
+        return new Term(this.monomial.multiply(monomial),coef.multiply(generic));
+    }
+
+    public Term multiply(Monomial monomial) {
+        return new Term(this.monomial.multiply(monomial),coef);
+    }
+
+    public Term divide(Generic generic) {
+        return new Term(monomial,coef.divide(generic));
+    }
+
+    public Term divide(Monomial monomial) {
+        return new Term(this.monomial.divide(monomial),coef);
+    }
+
+    public Term negate() {
+        return new Term(monomial,coef.negate());
+    }
+
+    public int signum() {
+        return coef.signum();
+    }
+
+    public Monomial monomial() {
+        return monomial;
+    }
+
+    public Generic coef() {
+        return coef;
+    }
+
+    public int compareTo(Term term) {
+        return monomial.compareTo(term.monomial);
+    }
+
+    public int compareTo(Object o) {
+        return compareTo((Term)o);
+    }
+
+    public String toString() {
+        return "("+coef+", "+monomial+")";
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/TreePolynomial.java b/src/misc/src/jscl/math/polynomial/TreePolynomial.java
new file mode 100644
index 00000000..f97b42de
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/TreePolynomial.java
@@ -0,0 +1,303 @@
+package jscl.math.polynomial;
+
+import java.util.Iterator;
+import java.util.Map;
+import java.util.SortedMap;
+import java.util.TreeMap;
+import jscl.math.Expression;
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.Literal;
+
+final class TreePolynomial extends Polynomial {
+    final SortedMap content;
+    int degree;
+    boolean mutable=true;
+
+    TreePolynomial(Monomial monomialFactory, Generic coefFactory) {
+        super(monomialFactory,coefFactory);
+        content=new TreeMap(ordering);
+    }
+
+    public int size() {
+        return content.size();
+    }
+
+    public Iterator iterator(boolean direction, Monomial current) {
+        return new ContentIterator(direction,current);
+    }
+
+    class ContentIterator implements Iterator {
+        final boolean direction;
+        final Iterator iterator;
+        SortedMap map;
+
+        ContentIterator(boolean direction, Monomial current) {
+            this.direction=direction;
+            if(direction) {
+                iterator=null;
+                map=subContent(current,true);
+            } else {
+                iterator=(subContent(current,false)).entrySet().iterator();
+                if(current!=null && content.containsKey(current)) iterator.next();
+            }
+        }
+
+        public boolean hasNext() {
+            return direction?map.size()>0:iterator.hasNext();
+        }
+
+        public Object next() {
+            if(direction) {
+                Monomial m=(Monomial)map.lastKey();
+                map=content.headMap(m);
+                return term(m);
+            } else {
+                return term((Map.Entry)iterator.next());
+            }
+        }
+
+        public void remove() {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    Term term(Map.Entry entry) {
+        return new Term((Monomial)entry.getKey(),(Generic)entry.getValue());
+    }
+
+    Term term(Monomial monomial) {
+        return new Term(monomial,null) {
+            public Generic coef() {
+                return coef==null?coefficient(monomial):coef;
+            }
+        };
+    }
+
+    SortedMap subContent(Monomial monomial, boolean direction) {
+        if(monomial==null) return content;
+        return direction?content.headMap(monomial):content.tailMap(monomial);
+    }
+
+    public Polynomial subtract(Polynomial polynomial) {
+        if(polynomial.signum()==0) return this;
+        if(mutable) {
+            TreePolynomial q=(TreePolynomial)polynomial;
+            Iterator it=q.content.entrySet().iterator();
+            while(it.hasNext()) {
+                Map.Entry e=(Map.Entry)it.next();
+                Monomial m=(Monomial)e.getKey();
+                Generic a=(Generic)e.getValue();
+                Generic s=coefficient(m).subtract(a);
+                if(s.signum()==0) content.remove(m);
+                else content.put(m,s);
+            }
+            degree=degree(this);
+            sugar=Math.max(sugar,q.sugar);
+            normalized=false;
+            return this;
+        } else return copy().subtract(polynomial);
+    }
+
+    public Polynomial multiplyAndSubtract(Generic generic, Polynomial polynomial) {
+        if(generic.signum()==0) return this;
+        if(generic.compareTo(JSCLInteger.valueOf(1))==0) return subtract(polynomial);
+        if(mutable) {
+            TreePolynomial q=(TreePolynomial)polynomial;
+            Iterator it=q.content.entrySet().iterator();
+            while(it.hasNext()) {
+                Map.Entry e=(Map.Entry)it.next();
+                Monomial m=(Monomial)e.getKey();
+                Generic a=((Generic)e.getValue()).multiply(generic);
+                Generic s=coefficient(m).subtract(a);
+                if(s.signum()==0) content.remove(m);
+                else content.put(m,s);
+            }
+            degree=degree(this);
+            sugar=Math.max(sugar,q.sugar);
+            normalized=false;
+            return this;
+        } else return copy().multiplyAndSubtract(generic,polynomial);
+    }
+
+    public Polynomial multiplyAndSubtract(Monomial monomial, Generic generic, Polynomial polynomial) {
+        if(generic.signum()==0) return this;
+        if(monomial.degree()==0) return multiplyAndSubtract(generic,polynomial);
+        if(mutable) {
+            TreePolynomial q=(TreePolynomial)polynomial;
+            Iterator it=q.content.entrySet().iterator();
+            while(it.hasNext()) {
+                Map.Entry e=(Map.Entry)it.next();
+                Monomial m=((Monomial)e.getKey()).multiply(monomial);
+                Generic a=((Generic)e.getValue()).multiply(generic);
+                Generic s=coefficient(m).subtract(a);
+                if(s.signum()==0) content.remove(m);
+                else content.put(m,s);
+            }
+            degree=degree(this);
+            sugar=Math.max(sugar,q.sugar+monomial.degree());
+            normalized=false;
+            return this;
+        } else return copy().multiplyAndSubtract(monomial,generic,polynomial);
+    }
+
+    public Polynomial multiply(Generic generic) {
+        if(generic.signum()==0) return valueof(JSCLInteger.valueOf(0));
+        if(generic.compareTo(JSCLInteger.valueOf(1))==0) return this;
+        if(mutable) {
+            Iterator it=content.entrySet().iterator();
+            while(it.hasNext()) {
+                Map.Entry e=(Map.Entry)it.next();
+                e.setValue(((Generic)e.getValue()).multiply(generic));
+            }
+            normalized=false;
+            return this;
+        } else return copy().multiply(generic);
+    }
+
+    public Polynomial multiply(Monomial monomial) {
+        if(defined) {
+            TreePolynomial p=newinstance();
+            Iterator it=content.entrySet().iterator();
+            while(it.hasNext()) {
+                Map.Entry e=(Map.Entry)it.next();
+                Monomial m=((Monomial)e.getKey()).multiply(monomial);
+                Generic a=(Generic)e.getValue();
+                Generic s=p.coefficient(m).add(a);
+                if(s.signum()==0) p.content.remove(m);
+                else p.content.put(m,s);
+            }
+            p.degree=degree(p);
+            p.sugar=sugar+monomial.degree();
+            return p;
+        } else {
+            if(monomial.degree()==0) return this;
+            TreePolynomial p=newinstance();
+            Iterator it=content.entrySet().iterator();
+            while(it.hasNext()) {
+                Map.Entry e=(Map.Entry)it.next();
+                p.content.put(((Monomial)e.getKey()).multiply(monomial),(Generic)e.getValue());
+            }
+            p.degree=degree+monomial.degree();
+            p.sugar=sugar+monomial.degree();
+            return p;
+        }
+    }
+
+    public Polynomial divide(Generic generic) throws ArithmeticException {
+        if(generic.compareTo(JSCLInteger.valueOf(1))==0) return this;
+        if(mutable) {
+            Iterator it=content.entrySet().iterator();
+            while(it.hasNext()) {
+                Map.Entry e=(Map.Entry)it.next();
+                e.setValue(((Generic)e.getValue()).divide(generic));
+            }
+            normalized=false;
+            return this;
+        } else return copy().divide(generic);
+    }
+
+    public Polynomial divide(Monomial monomial) throws ArithmeticException {
+        if(monomial.degree()==0) return this;
+        TreePolynomial p=newinstance();
+        Iterator it=content.entrySet().iterator();
+        while(it.hasNext()) {
+            Map.Entry e=(Map.Entry)it.next();
+            p.content.put(((Monomial)e.getKey()).divide(monomial),(Generic)e.getValue());
+        }
+        p.degree=degree+monomial.degree();
+        p.sugar=sugar+monomial.degree();
+        return p;
+    }
+
+    public Polynomial gcd(Polynomial polynomial) {
+        throw new UnsupportedOperationException();
+    }
+
+    public int degree() {
+        return degree;
+    }
+
+    public Polynomial valueof(Polynomial polynomial) {
+        TreePolynomial p=newinstance();
+        p.init(polynomial);
+        return p;
+    }
+
+    public Polynomial valueof(Generic generic) {
+        TreePolynomial p=newinstance();
+        p.init(generic);
+        return p;
+    }
+
+    public Polynomial valueof(Monomial monomial) {
+        TreePolynomial p=newinstance();
+        p.init(monomial);
+        return p;
+    }
+
+    public Polynomial freeze() {
+        mutable=false;
+        return this;
+    }
+
+    public Term head() {
+        return content.size()>0?term((Monomial)content.lastKey()):null;
+    }
+
+    public Term tail() {
+        return content.size()>0?term((Monomial)content.firstKey()):null;
+    }
+
+    public Generic coefficient(Monomial monomial) {
+        Generic a=(Generic)content.get(monomial);
+        return a==null?coefficient(JSCLInteger.valueOf(0)):a;
+    }
+
+    void init(Polynomial polynomial) {
+        TreePolynomial q=(TreePolynomial)polynomial;
+        content.putAll(q.content);
+        degree=q.degree;
+        sugar=q.sugar;
+    }
+
+    void init(Expression expression) {
+        int sugar=0;
+        int n=expression.size();
+        for(int i=0;i<n;i++) {
+            Literal l=expression.literal(i);
+            JSCLInteger en=expression.coef(i);
+            Monomial m=monomial(l);
+            l=l.divide(m.literalValue());
+            Generic a2=coefficient(l.degree()>0?en.multiply(Expression.valueOf(l)):en);
+            Generic a1=coefficient(m);
+            Generic a=a1.add(a2);
+            if(a.signum()==0) content.remove(m);
+            else content.put(m,a);
+            sugar=Math.max(sugar,m.degree());
+        }
+        degree=degree(this);
+        this.sugar=sugar;
+    }
+
+    void init(Generic generic) {
+        if(generic instanceof Expression) {
+            init((Expression)generic);
+        } else {
+            Generic a=coefficient(generic);
+            if(a.signum()!=0) content.put(monomial(Literal.valueOf()),a);
+            degree=0;
+            sugar=0;
+        }
+    }
+
+    void init(Monomial monomial) {
+        content.put(monomial,coefficient(JSCLInteger.valueOf(1)));
+        degree=monomial.degree();
+        sugar=monomial.degree();
+    }
+
+    protected TreePolynomial newinstance() {
+        return new TreePolynomial(monomialFactory,coefFactory);
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/UnivariatePolynomial.java b/src/misc/src/jscl/math/polynomial/UnivariatePolynomial.java
new file mode 100644
index 00000000..ad500b85
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/UnivariatePolynomial.java
@@ -0,0 +1,493 @@
+package jscl.math.polynomial;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import jscl.math.Expression;
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.Literal;
+import jscl.math.NotDivisibleException;
+import jscl.math.Variable;
+import jscl.math.function.Inv;
+import jscl.util.ArrayUtils;
+
+public class UnivariatePolynomial extends Polynomial {
+    protected final Variable variable;
+    Generic content[]=new Generic[8];
+    int degree;
+
+    protected UnivariatePolynomial(Variable variable) {
+        this(variable,null);
+    }
+
+    UnivariatePolynomial(Variable variable, Generic coefFactory) {
+        super(Monomial.factory(new Variable[] {variable}),coefFactory);
+        this.variable=variable;
+    }
+
+    public Variable variable() {
+        return variable;
+    }
+
+    public int size() {
+        return degree+1;
+    }
+
+    public Iterator iterator(boolean direction, Monomial current) {
+        return new ContentIterator(direction,current);
+    }
+
+    class ContentIterator implements Iterator {
+        final boolean direction;
+        int index;
+
+        ContentIterator(boolean direction, Monomial current) {
+            this.direction=direction;
+            if(direction) {
+                index=indexOf(current,true);
+            } else {
+                index=indexOf(current,false);
+                if(current!=null && get(index).signum()!=0) index++;
+            }
+            seek();
+        }
+
+        void seek() {
+            if(direction) while(index>0 && get(index).signum()==0) index--;
+            else while(index<=degree && get(index).signum()==0) index++;
+        }
+        
+        public boolean hasNext() {
+            return direction?index>0:index<=degree;
+        }
+        
+        public Object next() {
+            Term t=direction?term(--index):term(index++);
+            seek();
+            return t;
+        }
+        
+        public void remove() {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    Term term(int n) {
+        return new Term(monomial(Literal.valueOf(variable,n)),get(n));
+    }
+
+    int indexOf(Monomial monomial, boolean direction) {
+        if(monomial==null) return direction?degree+1:0;
+        return monomial.degree();
+    }
+
+    public Polynomial add(Polynomial polynomial) {
+        UnivariatePolynomial p=newinstance();
+        UnivariatePolynomial q=(UnivariatePolynomial)polynomial;
+        int d=Math.max(degree,q.degree);
+        for(int i=d;i>=0;i--) {
+            p.put(i,get(i).add(q.get(i)));
+        }
+        return p;
+    }
+
+    public Polynomial subtract(Polynomial polynomial) {
+        UnivariatePolynomial p=newinstance();
+        UnivariatePolynomial q=(UnivariatePolynomial)polynomial;
+        int d=Math.max(degree,q.degree);
+        for(int i=d;i>=0;i--) {
+            p.put(i,get(i).subtract(q.get(i)));
+        }
+        return p;
+    }
+
+    public Polynomial multiply(Polynomial polynomial) {
+        UnivariatePolynomial p=newinstance();
+        UnivariatePolynomial q=(UnivariatePolynomial)polynomial;
+        for(int i=degree;i>=0;i--) {
+            for(int j=q.degree;j>=0;j--) {
+                p.put(i+j,get(i).multiply(q.get(j)));
+            }
+        }
+        return p;
+    }
+
+    public Polynomial multiply(Generic generic) {
+        UnivariatePolynomial p=newinstance();
+        for(int i=degree;i>=0;i--) {
+            p.put(i,get(i).multiply(generic));
+        }
+        return p;
+    }
+
+    public Polynomial multiply(Monomial monomial, Generic generic) {
+        UnivariatePolynomial p=newinstance();
+        int d=monomial.degree();
+        for(int i=degree;i>=0;i--) {
+            p.put(i+d,get(i).multiply(generic));
+        }
+        for(int i=d-1;i>=0;i--) {
+            p.put(i,JSCLInteger.valueOf(0));
+        }
+        return p;
+    }
+
+    public Polynomial multiply(Monomial monomial) {
+        return multiply(monomial,JSCLInteger.valueOf(1));
+    }
+
+    public Polynomial divide(Generic generic) throws ArithmeticException {
+        UnivariatePolynomial p=newinstance();
+        for(int i=degree;i>=0;i--) {
+            p.put(i,get(i).divide(generic));
+        }
+        return p;
+    }
+
+    public Polynomial divide(Monomial monomial) throws ArithmeticException {
+        UnivariatePolynomial p=newinstance();
+        int d=monomial.degree();
+        for(int i=d-1;i>=0;i--) {
+            if(get(i).signum()==0);
+            else throw new NotDivisibleException();
+        }
+        for(int i=degree;i>=d;i--) {
+            p.put(i-d,get(i));
+        }
+        return p;
+    }
+
+    public Polynomial[] divideAndRemainder(Polynomial polynomial) throws ArithmeticException {
+        UnivariatePolynomial p[]={newinstance(),this};
+        UnivariatePolynomial q=(UnivariatePolynomial)polynomial;
+        if(p[1].signum()==0) return p;
+        for(int i=p[1].degree-q.degree;i>=0;i--) {
+            p[0].put(i,p[1].get(i+q.degree).divide(q.get(q.degree)));
+            UnivariatePolynomial r=newinstance();
+            for(int j=i+q.degree-1;j>=0;j--) {
+                Generic a=p[1].get(j);
+                r.put(j,a.subtract(q.get(j-i).multiply(p[0].get(i))));
+            }
+            p[1]=r;
+        }
+        return p;
+    }
+
+    public Polynomial remainderUpToCoefficient(Polynomial polynomial) throws ArithmeticException {
+        UnivariatePolynomial p=this;
+        UnivariatePolynomial q=(UnivariatePolynomial)polynomial;
+        if(p.signum()==0) return p;
+        for(int i=p.degree-q.degree;i>=0;i--) {
+            UnivariatePolynomial r=newinstance();
+            for(int j=i+q.degree-1;j>=0;j--) {
+                Generic a=p.get(j).multiply(q.get(q.degree));
+                r.put(j,a.subtract(q.get(j-i).multiply(p.get(i+q.degree))));
+            }
+            p=r;
+        }
+        return p;
+    }
+
+    public Polynomial gcd(Polynomial polynomial) {
+        UnivariatePolynomial p=this;
+        UnivariatePolynomial q=(UnivariatePolynomial)polynomial;
+        if(p.signum()==0) return q;
+        else if(q.signum()==0) return p;
+        if(p.degree<q.degree) {
+            UnivariatePolynomial r=p;
+            p=q;
+            q=r;
+        }
+        int d=p.degree-q.degree;
+        Generic phi=JSCLInteger.valueOf(-1);
+        Generic beta=JSCLInteger.valueOf(-1).pow(d+1);
+        Polynomial a1[]=p.gcdAndNormalize();
+        Polynomial a2[]=q.gcdAndNormalize();
+        Generic gcd1=a1[0].genericValue();
+        Generic gcd2=a2[0].genericValue();
+        p=(UnivariatePolynomial)a1[1];
+        q=(UnivariatePolynomial)a2[1];
+        while(q.degree>0) {
+            UnivariatePolynomial r=(UnivariatePolynomial)p.remainderUpToCoefficient(q).divide(beta);
+            if(d>1) phi=q.get(q.degree).negate().pow(d).divide(phi.pow(d-1));
+            else phi=q.get(q.degree).negate().pow(d).multiply(phi.pow(1-d));
+            p=q;
+            q=r;
+            d=p.degree-q.degree;
+            beta=p.get(p.degree).negate().multiply(phi.pow(d));
+        }
+        if(q.signum()==0) {
+            p=(UnivariatePolynomial)p.normalize();
+        } else {
+            p=newinstance();
+            p.put(0,JSCLInteger.valueOf(1));
+        }
+        return p.multiply(gcd1.gcd(gcd2));
+    }
+
+    public Generic gcd() {
+        Generic a=coefficient(JSCLInteger.valueOf(0));
+        for(int i=degree;i>=0;i--) a=a.gcd(get(i));
+        return a.signum()==signum()?a:a.negate();
+    }
+
+    public Monomial monomialGcd() {
+        return monomial(tail());
+    }
+
+    public int degree() {
+        return degree;
+    }
+
+    public UnivariatePolynomial valueof(Generic generic[]) {
+        UnivariatePolynomial p=newinstance();
+        p.init(generic);
+        return p;
+    }
+
+    public Polynomial valueof(Polynomial polynomial) {
+        throw new UnsupportedOperationException();
+    }
+
+    public Polynomial valueof(Generic generic) {
+        UnivariatePolynomial p=newinstance();
+        p.init(generic);
+        return p;
+    }
+
+    public Polynomial valueof(Monomial monomial) {
+        throw new UnsupportedOperationException();
+    }
+
+    public Polynomial freeze() {
+        return this;
+    }
+
+    public Term head() {
+        return term(degree);
+    }
+
+    public Generic coefficient(Monomial monomial) {
+        return term(monomial.degree()).coef();
+    }
+
+    public Polynomial reduce(Generic generic, Monomial monomial, Polynomial polynomial, boolean inPlace) {
+        throw new UnsupportedOperationException();
+    }
+
+    public Generic genericValue() {
+        Generic s=JSCLInteger.valueOf(0);
+        for(int i=degree;i>=0;i--) {
+            Generic a=get(i).expressionValue();
+            s=s.add(i>0?a.multiply(Expression.valueOf(Literal.valueOf(variable,i))):a);
+        }
+        return s;
+    }
+
+    public Generic[] elements() {
+        Generic a[]=new Generic[degree+1];
+        for(int i=degree;i>=0;i--) a[i]=get(i);
+        return a;
+    }
+
+    public UnivariatePolynomial derivative(Variable variable) {
+        return (UnivariatePolynomial)derivative().multiply(this.variable.derivative(variable));
+    }
+
+    public Generic substitute(Generic generic) {
+        Generic s=JSCLInteger.valueOf(0);
+        for(int i=degree;i>=0;i--) {
+            s=s.add(get(i).multiply(generic.pow(i)));
+        }
+        return s;
+    }
+
+    public Generic solve() {
+        if(degree==1) {
+            return get(0).multiply(new Inv(get(1)).evaluate()).negate();
+        } else return null;
+    }
+
+    public Generic[] identification(UnivariatePolynomial polynomial) {
+        UnivariatePolynomial p=this;
+        UnivariatePolynomial q=polynomial;
+        if(p.degree<q.degree || (p.degree==0 && q.signum()==0)) {
+            UnivariatePolynomial r=p;
+            p=q;
+            q=r;
+        }
+        UnivariatePolynomial r=(UnivariatePolynomial)p.remainderUpToCoefficient(q);
+        Generic a[]=new Generic[r.degree+1];
+        for(int i=r.degree;i>=0;i--) a[r.degree-i]=r.get(i);
+        return a;
+    }
+
+    public Generic resultant(UnivariatePolynomial polynomial) {
+        UnivariatePolynomial p=this;
+        UnivariatePolynomial q=polynomial;
+        if(p.degree<q.degree || (p.degree==0 && q.signum()==0)) {
+            UnivariatePolynomial r=p;
+            p=q;
+            q=r;
+        }
+        int d=p.degree-q.degree;
+        Generic phi=JSCLInteger.valueOf(-1);
+        Generic beta=JSCLInteger.valueOf(-1).pow(d+1);
+        while(q.degree>0) {
+            UnivariatePolynomial r=(UnivariatePolynomial)p.remainderUpToCoefficient(q).divide(beta);
+            if(d>1) phi=q.get(q.degree).negate().pow(d).divide(phi.pow(d-1));
+            else phi=q.get(q.degree).negate().pow(d).multiply(phi.pow(1-d));
+            p=q;
+            q=r;
+            d=p.degree-q.degree;
+            beta=p.get(p.degree).negate().multiply(phi.pow(d));
+        }
+        return q.get(0);
+    }
+
+    public UnivariatePolynomial[] remainderSequence(UnivariatePolynomial polynomial) {
+        UnivariatePolynomial p=this;
+        UnivariatePolynomial q=polynomial;
+        if(p.degree<q.degree || (p.degree==0 && q.signum()==0)) {
+            UnivariatePolynomial r=p;
+            p=q;
+            q=r;
+        }
+        UnivariatePolynomial s[]=new UnivariatePolynomial[q.degree+1];
+        s[q.degree]=q;
+        int d=p.degree-q.degree;
+        Generic phi=JSCLInteger.valueOf(-1);
+        Generic beta=JSCLInteger.valueOf(-1).pow(d+1);
+        while(q.degree>0) {
+            UnivariatePolynomial r=(UnivariatePolynomial)p.remainderUpToCoefficient(q).divide(beta);
+            if(d>1) phi=q.get(q.degree).negate().pow(d).divide(phi.pow(d-1));
+            else phi=q.get(q.degree).negate().pow(d).multiply(phi.pow(1-d));
+            p=q;
+            q=r;
+            s[q.degree]=q;
+            d=p.degree-q.degree;
+            beta=p.get(p.degree).negate().multiply(phi.pow(d));
+        }
+        return s;
+    }
+
+    public UnivariatePolynomial squarefree() {
+        return (UnivariatePolynomial)divide(gcd(derivative()));
+    }
+
+    public UnivariatePolynomial[] squarefreeDecomposition() {
+        return SquarefreeDecomposition.compute(this);
+    }
+
+    public UnivariatePolynomial antiderivative() {
+        UnivariatePolynomial p=newinstance();
+        for(int i=degree;i>=0;i--) {
+            p.put(i+1,get(i).multiply(new Inv(JSCLInteger.valueOf(i+1)).evaluate()));
+        }
+        return p;
+    }
+
+    public UnivariatePolynomial derivative() {
+        UnivariatePolynomial p=newinstance();
+        for(int i=degree-1;i>=0;i--) {
+            p.put(i,get(i+1).multiply(JSCLInteger.valueOf(i+1)));
+        }
+        return p;
+    }
+
+    public int compareTo(Polynomial polynomial) {
+        UnivariatePolynomial p=(UnivariatePolynomial)polynomial;
+        int d=Math.max(degree,p.degree);
+        for(int i=d;i>=0;i--) {
+            Generic a1=get(i);
+            Generic a2=p.get(i);
+            int c=a1.compareTo(a2);
+            if(c<0) return -1;
+            else if(c>0) return 1;
+        }
+        return 0;
+    }
+
+    void init(Generic generic[]) {
+        for(int i=0;i<generic.length;i++) put(i,coefficient(generic[i]));
+    }
+
+    void init(Expression expression) {
+        int n=expression.size();
+        for(int i=0;i<n;i++) {
+            Literal l=expression.literal(i);
+            JSCLInteger en=expression.coef(i);
+            Monomial m=monomial(l);
+            l=l.divide(m.literalValue());
+            if(l.degree()>0) put(m.degree(),coefficient(en.multiply(Expression.valueOf(l))));
+            else put(m.degree(),coefficient(en));
+        }
+    }
+
+    protected void init(Generic generic) {
+        if(generic instanceof Expression) {
+            init((Expression)generic);
+        } else put(0,coefficient(generic));
+    }
+
+    void put(int n, Generic generic) {
+        Generic a=generic.add(get(n));
+        if(a.signum()==0) {
+            if(n<=degree) content[n]=null;
+            if(n==degree) {
+                while(n>0 && content[n]==null) n--;
+                degree=n;
+            }
+        } else {
+            if(n>=content.length) resize(n);
+            content[n]=a;
+            degree=Math.max(degree,n);
+        }
+    }
+
+    void resize(int n) {
+        int length=content.length<<1;
+        while(n>=length) length<<=1;
+        Generic content[]=new Generic[length];
+        System.arraycopy(this.content,0,content,0,this.content.length);
+        this.content=content;
+    }
+    
+    public Generic get(int n) {
+        Generic a=n<0 || n>degree?null:content[n];
+        return a==null?JSCLInteger.valueOf(0):a;
+    }
+
+    protected UnivariatePolynomial newinstance() {
+        return new UnivariatePolynomial(variable,coefFactory);
+    }
+}
+
+class SquarefreeDecomposition {
+    final List list=new ArrayList();
+
+    static UnivariatePolynomial[] compute(UnivariatePolynomial polynomial) {
+        SquarefreeDecomposition sd=new SquarefreeDecomposition();
+        Polynomial p[]=polynomial.gcdAndNormalize();
+        sd.init((UnivariatePolynomial)p[0]);
+        sd.process((UnivariatePolynomial)p[1]);
+        return sd.getValue();
+    }
+
+    void init(UnivariatePolynomial polynomial) {
+        list.add(polynomial);
+    }
+
+    void process(UnivariatePolynomial polynomial) {
+        UnivariatePolynomial r=(UnivariatePolynomial)polynomial.gcd(polynomial.derivative());
+        UnivariatePolynomial s=(UnivariatePolynomial)polynomial.divide(r);
+        list.add(s.divide(s.gcd(r)));
+        if(r.degree()==0);
+        else process(r);
+    }
+
+    UnivariatePolynomial[] getValue() {
+        return (UnivariatePolynomial[])ArrayUtils.toArray(list,new UnivariatePolynomial[list.size()]);
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/groebner/Block.java b/src/misc/src/jscl/math/polynomial/groebner/Block.java
new file mode 100644
index 00000000..5be3b126
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/groebner/Block.java
@@ -0,0 +1,60 @@
+package jscl.math.polynomial.groebner;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import jscl.math.Debug;
+import jscl.math.polynomial.Basis;
+import jscl.math.polynomial.DegreeOrdering;
+import jscl.math.polynomial.Ordering;
+import jscl.math.polynomial.Polynomial;
+
+class Block extends Standard {
+    boolean degree;
+
+    Block(Ordering ordering, int flags) {
+        super(flags);
+        degree=ordering instanceof DegreeOrdering;
+    }
+
+    void compute() {
+        Debug.println("compute");
+        int degree=0;
+        while(!pairs.isEmpty()) {
+            List list=new ArrayList();
+            Iterator it=pairs.keySet().iterator();
+            while(it.hasNext()) {
+                Pair pa=(Pair)it.next();
+                int d=(flags&Basis.SUGAR)>0?pa.sugar:pa.scm.degree();
+                if(degree==0) degree=d;
+                else if(d>degree || !this.degree) break;
+                list.add(pa);
+            }
+            process(list);
+            remove(list);
+            degree=0;
+        }
+    }
+
+    void add(List list) {
+        super.add(ReducedRowEchelonForm.compute(list));
+    }
+
+    void process(List pairs) {
+        List list=new ArrayList();
+        Iterator it=pairs.iterator();
+        while(it.hasNext()) {
+            Pair pa=(Pair)it.next();
+            if(criterion(pa)) continue;
+            Polynomial p=reduce(pa,polys);
+            if(p.signum()!=0) list.add(p);
+            npairs++;
+        }
+        add(list);
+    }
+
+    void remove(List pairs) {
+        Iterator it=pairs.iterator();
+        while(it.hasNext()) remove((Pair)it.next());
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/groebner/F4.java b/src/misc/src/jscl/math/polynomial/groebner/F4.java
new file mode 100644
index 00000000..b79d3a22
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/groebner/F4.java
@@ -0,0 +1,35 @@
+package jscl.math.polynomial.groebner;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import jscl.math.polynomial.Ordering;
+import jscl.math.polynomial.Polynomial;
+
+class F4 extends Block {
+    List reduction=new ArrayList();
+
+    F4(Ordering ordering, int flags) {
+        super(ordering,flags);
+    }
+
+    void add(List list) {
+        Iterator it=list.iterator();
+        while(it.hasNext()) {
+            Polynomial p=(Polynomial)it.next();
+            if(p.signum()!=0) add(p);
+        }
+    }
+
+    void process(List pairs) {
+        List list=new ArrayList();
+        Iterator it=pairs.iterator();
+        while(it.hasNext()) {
+            Pair pa=(Pair)it.next();
+            if(criterion(pa)) continue;
+            list.add(pa);
+        }
+        add(F4Reduction.compute(list,polys,reduction,flags));
+        npairs+=list.size();
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/groebner/F4Reduction.java b/src/misc/src/jscl/math/polynomial/groebner/F4Reduction.java
new file mode 100644
index 00000000..6b6273b6
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/groebner/F4Reduction.java
@@ -0,0 +1,98 @@
+package jscl.math.polynomial.groebner;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import jscl.math.Debug;
+import jscl.math.polynomial.Basis;
+import jscl.math.polynomial.Monomial;
+import jscl.math.polynomial.Polynomial;
+import jscl.math.polynomial.Term;
+
+class F4Reduction {
+    final Collection ideal;
+    final List list;
+    final int flags;
+    final List polys=new ArrayList();
+    final List content=new ArrayList();
+    final Map considered=new TreeMap();
+    final Map head=new TreeMap();
+    final Map proj=new TreeMap();
+
+    F4Reduction(Collection ideal, List list, int flags) {
+        this.ideal=ideal;
+        this.list=list;
+        this.flags=flags;
+    }
+
+    static List compute(List pairs, Collection ideal, List list, int flags) {
+        F4Reduction r=new F4Reduction(ideal,list,flags);
+        r.compute(pairs);
+        return r.content;
+    }
+
+    void compute(List pairs) {
+        Iterator it=pairs.iterator();
+        while(it.hasNext()) {
+            Pair pa=(Pair)it.next();
+            considered.put(pa.scm,null);
+            add(pa);
+        }
+        process();
+        if((flags&Basis.F4_SIMPLIFY)>0) list.add(this);
+    }
+
+    void add(Pair pair) {
+        Debug.println(pair);
+        Projection pr[]=new Projection[] {new Projection(pair,0),new Projection(pair,1)};
+        for(int i=0;i<pr.length;i++) if(!proj.containsKey(pr[i])) {
+            add(pr[i].simplify(list));
+            proj.put(pr[i],null);
+        }
+    }
+
+    void add(Projection projection) {
+        Polynomial p=projection.mult();
+        Monomial scm=projection.scm();
+        head.put(scm,null);
+        Iterator it=p.iterator(scm);
+        while(it.hasNext()) {
+            Term t=(Term)it.next();
+            Monomial m1=t.monomial();
+            if(considered.containsKey(m1)) continue;
+            else considered.put(m1,null);
+            Iterator iq=ideal.iterator();
+            while(iq.hasNext()) {
+                Polynomial q=(Polynomial)iq.next();
+                Monomial m2=q.head().monomial();
+                if(m1.multiple(m2)) {
+                    Monomial m=m1.divide(m2);
+                    add(new Projection(m,q).simplify(list));
+                    break;
+                }
+            }
+        }
+        content.add(p);
+    }
+
+    void process() {
+        List list=ReducedRowEchelonForm.compute(content);
+        content.clear();
+        int n=list.size();
+        for(int i=0;i<n;i++) {
+            Polynomial p=(Polynomial)list.get(i);
+            if(p.signum()!=0) {
+                Monomial m=p.head().monomial();
+                if(!head.containsKey(m)) content.add(p);
+                else {
+                    if(p.index()!=-1) p=p.copy();
+                    p.setIndex(polys.size());
+                    polys.add(p);
+                }
+            }
+        }
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/groebner/Instrumented.java b/src/misc/src/jscl/math/polynomial/groebner/Instrumented.java
new file mode 100644
index 00000000..2606a5f4
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/groebner/Instrumented.java
@@ -0,0 +1,44 @@
+package jscl.math.polynomial.groebner;
+
+import java.util.ArrayList;
+import java.util.List;
+import jscl.math.Generic;
+import jscl.math.polynomial.Basis;
+import jscl.math.polynomial.Polynomial;
+
+class Instrumented extends Standard {
+    final List aux=new ArrayList();
+
+    Instrumented(int flags) {
+        super(flags);
+    }
+
+    void populate(Basis basis) {
+        Basis aux=basis.modulo(2147483647);
+        Generic a[]=basis.elements();
+        for(int i=0;i<a.length;i++) {
+            Polynomial p=basis.polynomial(a[i]);
+            Polynomial x=aux.polynomial(a[i]);
+            if(x.signum()!=0 && p.signum()!=0) add(p,x);
+        }
+    }
+
+    void process(Pair pair) {
+        if(criterion(pair)) return;
+        Polynomial x=reduce(new Pair(new Polynomial[] {auxiliary(pair.polynomial[0]),auxiliary(pair.polynomial[1])}),aux);
+        if(x.signum()!=0) {
+            Polynomial p=reduce(pair,polys);
+            if(p.signum()!=0) add(p,x);
+        }
+        npairs++;
+    }
+
+    void add(Polynomial polynomial, Polynomial auxiliary) {
+        add(polynomial);
+        aux.add(auxiliary);
+    }
+
+    Polynomial auxiliary(Polynomial polynomial) {
+        return (Polynomial)aux.get(polynomial.index());
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/groebner/Natural.java b/src/misc/src/jscl/math/polynomial/groebner/Natural.java
new file mode 100644
index 00000000..4164273b
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/groebner/Natural.java
@@ -0,0 +1,17 @@
+package jscl.math.polynomial.groebner;
+
+import java.util.Comparator;
+
+class Natural implements Comparator {
+    public static final Comparator comparator=new Natural();
+
+    private Natural() {}
+
+    public int compare(Pair pa1, Pair pa2) {
+        return pa1.compareTo(pa2);
+    }
+
+    public int compare(Object o1, Object o2) {
+        return compare((Pair)o1,(Pair)o2);
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/groebner/Pair.java b/src/misc/src/jscl/math/polynomial/groebner/Pair.java
new file mode 100644
index 00000000..0ece98c1
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/groebner/Pair.java
@@ -0,0 +1,54 @@
+package jscl.math.polynomial.groebner;
+
+import jscl.math.polynomial.Monomial;
+import jscl.math.polynomial.Polynomial;
+
+class Pair implements Comparable {
+    final Polynomial polynomial[];
+    final Monomial monomial[];
+    final Monomial scm;
+    final int sugar;
+    boolean coprime;
+    boolean reduction;
+    Polynomial principal;
+
+    Pair(Polynomial p1, Polynomial p2) {
+        this(new Polynomial[] {p1,p2});
+        coprime=monomial[0].gcd(monomial[1]).degree()==0;
+        int index[]=monomial[0].compareTo(monomial[1])<0?new int[] {0,1}:new int[] {1,0};
+        reduction=monomial[index[1]].multiple(monomial[index[0]]);
+        principal=polynomial[index[1]];
+    }
+
+    Pair(Polynomial polynomial[]) {
+        this.polynomial=polynomial;
+        monomial=new Monomial[] {polynomial[0].head().monomial(),polynomial[1].head().monomial()};
+        scm=monomial[0].scm(monomial[1]);
+        sugar=Math.max(polynomial[0].sugar()-polynomial[0].degree(),polynomial[1].sugar()-polynomial[1].degree())+scm.degree();
+    }
+
+    public int compareTo(Pair pair) {
+        int c=scm.compareTo(pair.scm);
+        if(c<0) return -1;
+        else if(c>0) return 1;
+        else {
+            c=polynomial[1].index()-pair.polynomial[1].index();
+            if(c<0) return -1;
+            else if(c>0) return 1;
+            else {
+                c=polynomial[0].index()-pair.polynomial[0].index();
+                if(c<0) return -1;
+                else if(c>0) return 1;
+                else return 0;
+            }
+        }
+    }
+
+    public int compareTo(Object o) {
+        return compareTo((Pair)o);
+    }
+
+    public String toString() {
+        return "{"+polynomial[0].index()+", "+polynomial[1].index()+"}, "+sugar+", "+reduction;
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/groebner/Projection.java b/src/misc/src/jscl/math/polynomial/groebner/Projection.java
new file mode 100644
index 00000000..6aa75c12
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/groebner/Projection.java
@@ -0,0 +1,73 @@
+package jscl.math.polynomial.groebner;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import jscl.math.polynomial.Monomial;
+import jscl.math.polynomial.Polynomial;
+
+class Projection implements Comparable {
+    final Monomial monomial;
+    final Polynomial polynomial;
+
+    Projection(Pair pair, int index) {
+        this(pair.scm.divide(pair.monomial[index]),pair.polynomial[index]);
+    }
+
+    Projection(Monomial monomial, Polynomial polynomial) {
+        this.monomial=monomial;
+        this.polynomial=polynomial;
+    }
+
+    Monomial scm() {
+        return polynomial.head().monomial().multiply(monomial);
+    }
+
+    Polynomial mult() {
+        return polynomial.multiply(monomial);
+    }
+
+    Projection simplify(List list) {
+        Monomial t=monomial;
+        if(t.degree()>0) {
+            Monomial m=polynomial.head().monomial();
+            int n=list.size();
+            for(int i=0;i<n;i++) {
+                Collection ideal=((F4Reduction)list.get(i)).polys;
+                Iterator it=ideal.iterator();
+                while(it.hasNext()) {
+                    Polynomial p=(Polynomial)it.next();
+                    Monomial u=p.head().monomial();
+                    if(u.multiple(m,true)) {
+                        u=u.divide(m);
+                        if(t.multiple(u,true)) {
+                            Projection pr=new Projection(t.divide(u),p).simplify(list);
+                            return pr;
+                        }
+                    }
+                }
+            }
+        }
+        return this;
+    }
+
+    public int compareTo(Projection proj) {
+        int c=monomial.compareTo(proj.monomial);
+        if(c<0) return -1;
+        else if(c>0) return 1;
+        else {
+            c=polynomial.index()-proj.polynomial.index();
+            if(c<0) return -1;
+            else if(c>0) return 1;
+            else return 0;
+        }
+    }
+
+    public int compareTo(Object o) {
+        return compareTo((Projection)o);
+    }
+
+    public String toString() {
+        return "{"+monomial+", "+polynomial.head().monomial()+"}";
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/groebner/ReducedRowEchelonForm.java b/src/misc/src/jscl/math/polynomial/groebner/ReducedRowEchelonForm.java
new file mode 100644
index 00000000..2e0a2258
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/groebner/ReducedRowEchelonForm.java
@@ -0,0 +1,57 @@
+package jscl.math.polynomial.groebner;
+
+import java.util.ArrayList;
+import java.util.List;
+import jscl.math.Generic;
+import jscl.math.polynomial.Monomial;
+import jscl.math.polynomial.Polynomial;
+
+class ReducedRowEchelonForm {
+    List content=new ArrayList();
+
+    ReducedRowEchelonForm(List list) {
+        content.addAll(list);
+    }
+
+    static List compute(List list) {
+        ReducedRowEchelonForm f=new ReducedRowEchelonForm(list);
+        f.compute();
+        return f.content;
+    }
+
+    void compute() {
+        int n=content.size();
+        for(int i=0;i<n;i++) reduce(i,false);
+        for(int i=n-1;i>=0;i--) reduce(i,true);
+    }
+
+    void reduce(int pivot, boolean direction) {
+        Polynomial p=polynomial(pivot);
+        content.set(pivot,p=p.normalize().freeze());
+        if(p.signum()==0) return;
+        Monomial m=p.head().monomial();
+        int b=direction?0:pivot+1;
+        int n=direction?pivot:content.size();
+        for(int i=b;i<n;i++) {
+            Polynomial q=polynomial(i);
+            Generic a=q.coefficient(m);
+            if(a.signum()!=0) content.set(i,q.reduce(a,p));
+        }
+    }
+
+    Polynomial polynomial(int n) {
+        return (Polynomial)content.get(n);
+    }
+
+    public String toString() {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append("{");
+        int n=content.size();
+        for(int i=0;i<n;i++) {
+            Polynomial p=polynomial(i);
+            buffer.append(i>0?", ":"").append(p);
+        }
+        buffer.append("}");
+        return buffer.toString();
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/groebner/Standard.java b/src/misc/src/jscl/math/polynomial/groebner/Standard.java
new file mode 100644
index 00000000..fe5c9e26
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/groebner/Standard.java
@@ -0,0 +1,227 @@
+package jscl.math.polynomial.groebner;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import jscl.math.Debug;
+import jscl.math.Generic;
+import jscl.math.polynomial.Basis;
+import jscl.math.polynomial.Monomial;
+import jscl.math.polynomial.Ordering;
+import jscl.math.polynomial.Polynomial;
+import jscl.util.ArrayUtils;
+
+public class Standard {
+    final int flags;
+    final Comparator comparator;
+    final Map pairs;
+    final List polys=new ArrayList();
+    final Map removed=new TreeMap();
+    int npairs;
+    int npolys;
+
+    Standard(int flags) {
+        this.flags=flags;
+        pairs=new TreeMap(comparator=(flags&Basis.SUGAR)>0?Sugar.comparator:Natural.comparator);
+    }
+
+    public static Basis compute(Basis basis) {
+        return compute(basis,0);
+    }
+
+    public static Basis compute(Basis basis, int flags) {
+        return compute(basis,flags,(flags&Basis.INSTRUMENTED)>0);
+    }
+
+    static Basis compute(Basis basis, int flags, boolean instrumented) {
+        Standard a=instrumented?new Instrumented(flags):algorithm(basis.ordering(),flags);
+        a.computeValue(basis);
+        basis=basis.valueof(a.elements());
+        if(instrumented) return compute(basis,flags,false);
+        return basis;
+    }
+
+    static Standard algorithm(Ordering ordering, int flags) {
+        switch(flags&Basis.ALGORITHM) {
+        case Basis.F4:
+            return new F4(ordering,flags);
+        case Basis.BLOCK:
+            return new Block(ordering,flags);
+        default:
+            return new Standard(flags);
+        }
+    }
+
+    void computeValue(Basis basis) {
+        Debug.println(basis);
+        populate(basis);
+        npolys=0;
+        compute();
+        remove();
+        reduce();
+        Debug.println("signature = ("+npairs+", "+npolys+", "+polys.size()+")");
+    }
+
+    void populate(Basis basis) {
+        List list=new ArrayList();
+        Generic a[]=basis.elements();
+        for(int i=0;i<a.length;i++) list.add(basis.polynomial(a[i]));
+        add(list);
+    }
+
+    void add(List list) {
+        Iterator it=list.iterator();
+        while(it.hasNext()) {
+            Polynomial p=(Polynomial)it.next();
+            if(p.signum()!=0) add(p);
+        }
+    }
+
+    void compute() {
+        Debug.println("compute");
+        while(!pairs.isEmpty()) {
+            Pair pa=(Pair)pairs.keySet().iterator().next();
+            process(pa);
+            remove(pa);
+        }
+    }
+
+    void process(Pair pair) {
+        if(criterion(pair)) return;
+        Polynomial p=reduce(pair,polys);
+        if(p.signum()!=0) add(p);
+        npairs++;
+    }
+
+    static Polynomial reduce(Pair pair, Collection ideal) {
+        Debug.println(pair);
+        return s_polynomial(pair.polynomial[0],pair.polynomial[1]).reduce(ideal,false).normalize().freeze();
+    }
+
+    static Polynomial s_polynomial(Polynomial p1, Polynomial p2) {
+        Monomial m1=p1.head().monomial();
+        Monomial m2=p2.head().monomial();
+        Monomial m=m1.gcd(m2);
+        m1=m1.divide(m);
+        m2=m2.divide(m);
+        return p1.multiply(m2).reduce(p1.head().coef(),m1,p2);
+    }
+
+    void remove(Pair pair) {
+        pairs.remove(pair);
+        if(pair.reduction) removed.put(pair.principal,null);
+    }
+
+    void add(Polynomial polynomial) {
+        polynomial.setIndex(polys.size());
+        Debug.println("("+polynomial.head().monomial()+", "+polynomial.index()+")");
+        if((flags&Basis.GM_SETTING)>0) makePairsGM(polynomial);
+        else makePairs(polynomial);
+        polys.add(polynomial);
+        npolys++;
+    }
+
+    boolean criterion(Pair pair) {
+        return (flags&Basis.GM_SETTING)>0?false:b_criterion(pair);
+    }
+
+    void makePairs(Polynomial polynomial) {
+        Iterator it=polys.iterator();
+        while(it.hasNext()) {
+            Polynomial p=(Polynomial)it.next();
+            Pair pa=new Pair(p,polynomial);
+            if(!pa.coprime) pairs.put(pa,null);
+        }
+    }
+
+    boolean b_criterion(Pair pair) {
+        Iterator it=polys.iterator();
+        while(it.hasNext()) {
+            Polynomial p=(Polynomial)it.next();
+            if(pair.scm.multiple(p.head().monomial())) {
+                Pair pa1=new Pair(sort(pair.polynomial[0],p));
+                Pair pa2=new Pair(sort(pair.polynomial[1],p));
+                if(considered(pa1) && considered(pa2)) return true;
+            }
+        }
+        return false;
+    }
+
+    boolean considered(Pair pair) {
+        return !pairs.containsKey(pair);
+    }
+
+    Polynomial[] sort(Polynomial p1, Polynomial p2) {
+        return p1.index()<p2.index()?new Polynomial[] {p1,p2}:new Polynomial[] {p2,p1};
+    }
+
+    void makePairsGM(Polynomial polynomial) {
+        List list=new ArrayList();
+        Iterator it=pairs.keySet().iterator();
+        while(it.hasNext()) {
+            Pair pa=(Pair)it.next();
+            Pair p1=new Pair(new Polynomial[] {pa.polynomial[0],polynomial});
+            Pair p2=new Pair(new Polynomial[] {pa.polynomial[1],polynomial});
+            if(multiple(pa,p1) && multiple(pa,p2)) list.add(pa);
+        }
+        int n=list.size();
+        for(int i=0;i<n;i++) {
+            Pair pa=(Pair)list.get(i);
+            remove(pa);
+        }
+        Map map=new TreeMap((flags&Basis.SUGAR)>0 && (flags&Basis.FUSSY)>0?Sugar.comparator:Natural.comparator);
+        it=polys.iterator();
+        while(it.hasNext()) {
+            Polynomial p=(Polynomial)it.next();
+            Pair pa=new Pair(p,polynomial);
+            pairs.put(pa,null);
+            map.put(pa,null);
+        }
+        list=ArrayUtils.list(map.keySet());
+        n=list.size();
+        for(int i=0;i<n;i++) {
+            Pair pa=(Pair)list.get(i);
+            for(int j=i+1;j<n;j++) {
+                Pair pa2=(Pair)list.get(j);
+                if(pa2.scm.multiple(pa.scm)) remove(pa2);
+            }
+            if(pa.coprime) remove(pa);
+        }
+    }
+
+    boolean multiple(Pair p1, Pair p2) {
+        return p1.scm.multiple(p2.scm,true) && ((flags&Basis.SUGAR)>0 && (flags&Basis.FUSSY)>0?Sugar.comparator.compare(p1,p2)>0:true);
+    }
+
+    void remove() {
+        Iterator it=polys.iterator();
+        while(it.hasNext()) if(removed.containsKey(it.next())) it.remove();
+    }
+
+    void reduce() {
+        Debug.println("reduce");
+        Map map=new TreeMap();
+        int size=polys.size();
+        for(int i=0;i<size;i++) {
+            Polynomial p=(Polynomial)polys.get(i);
+            polys.set(i,p=p.reduce(polys,true).normalize().freeze());
+            Debug.println("("+p.head().monomial()+")");
+            map.put(p,null);
+        }
+        polys.clear();
+        polys.addAll(map.keySet());
+    }
+
+    Generic[] elements() {
+        int size=polys.size();
+        Generic a[]=new Generic[size];
+        for(int i=0;i<size;i++) {
+            a[i]=((Polynomial)polys.get(i)).genericValue();
+        }
+        return a;
+    }
+}
diff --git a/src/misc/src/jscl/math/polynomial/groebner/Sugar.java b/src/misc/src/jscl/math/polynomial/groebner/Sugar.java
new file mode 100644
index 00000000..96721cca
--- /dev/null
+++ b/src/misc/src/jscl/math/polynomial/groebner/Sugar.java
@@ -0,0 +1,19 @@
+package jscl.math.polynomial.groebner;
+
+import java.util.Comparator;
+
+class Sugar implements Comparator {
+    public static final Comparator comparator=new Sugar();
+
+    private Sugar() {}
+
+    public int compare(Pair pa1, Pair pa2) {
+        if(pa1.sugar<pa2.sugar) return -1;
+        else if(pa1.sugar>pa2.sugar) return 1;
+        else return pa1.compareTo(pa2);
+    }
+
+    public int compare(Object o1, Object o2) {
+        return compare((Pair)o1,(Pair)o2);
+    }
+}
diff --git a/src/misc/src/jscl/mathml/MathML.java b/src/misc/src/jscl/mathml/MathML.java
new file mode 100644
index 00000000..74e655f2
--- /dev/null
+++ b/src/misc/src/jscl/mathml/MathML.java
@@ -0,0 +1,66 @@
+package jscl.mathml;
+
+import java.io.ByteArrayOutputStream;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+import org.apache.xerces.dom.CoreDocumentImpl;
+import org.apache.xerces.dom.DocumentTypeImpl;
+import org.apache.xerces.dom.ElementImpl;
+import org.apache.xerces.dom.TextImpl;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+
+public class MathML {
+    static Transformer xhtml;
+    Node node;
+
+    MathML(Node node) {
+        this.node=node;
+    }
+
+    public Document document() {
+        return node instanceof CoreDocumentImpl?(Document)node:node.getOwnerDocument();
+    }
+
+    public MathML(String qualifiedName, String publicID, String systemID) {
+        this(new CoreDocumentImpl());
+        CoreDocumentImpl document=(CoreDocumentImpl)document();
+        document.setXmlEncoding("utf-8");
+        document.appendChild(new DocumentTypeImpl(document,qualifiedName,publicID,systemID));
+    }
+
+    public MathML element(String name) {
+        CoreDocumentImpl document=(CoreDocumentImpl)document();
+        return new MathML(new ElementImpl(document,name));
+    }
+
+    public void setAttribute(String name, String value) {
+        ((Element)node).setAttribute(name, value);
+    }
+
+    public MathML text(String data) {
+        CoreDocumentImpl document=(CoreDocumentImpl)document();
+        return new MathML(new TextImpl(document,data));
+    }
+
+    public void appendChild(MathML math) {
+        node.appendChild(math.node);
+    }
+
+    public String toString() {
+        ByteArrayOutputStream os=new ByteArrayOutputStream();
+        try {
+            transformer().transform(new DOMSource(node), new StreamResult(os));
+        } catch (TransformerException e) {}
+        String s=os.toString();
+        return s.substring(s.indexOf(">")+1);
+    }
+
+    static Transformer transformer() throws TransformerException {
+        return xhtml==null?xhtml=TransformerFactory.newInstance().newTransformer():xhtml;
+    }
+}
diff --git a/src/misc/src/jscl/text/BracketedExpression.java b/src/misc/src/jscl/text/BracketedExpression.java
new file mode 100644
index 00000000..35b4821e
--- /dev/null
+++ b/src/misc/src/jscl/text/BracketedExpression.java
@@ -0,0 +1,36 @@
+package jscl.text;
+
+import jscl.math.ExpressionVariable;
+import jscl.math.Generic;
+
+public class BracketedExpression extends Parser {
+    public static final Parser parser=new BracketedExpression();
+
+    private BracketedExpression() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        Generic a;
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && str.charAt(pos[0])=='(') {
+            str.charAt(pos[0]++);
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        try {
+            a=(Generic)ExpressionParser.parser.parse(str,pos);
+        } catch (ParseException e) {
+            pos[0]=pos0;
+            throw e;
+        }
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && str.charAt(pos[0])==')') {
+            str.charAt(pos[0]++);
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        return new ExpressionVariable(a);
+    }
+}
diff --git a/src/misc/src/jscl/text/CommaAndExpression.java b/src/misc/src/jscl/text/CommaAndExpression.java
new file mode 100644
index 00000000..af59e3cf
--- /dev/null
+++ b/src/misc/src/jscl/text/CommaAndExpression.java
@@ -0,0 +1,28 @@
+package jscl.text;
+
+import jscl.math.Generic;
+
+public class CommaAndExpression extends Parser {
+    public static final Parser parser=new CommaAndExpression();
+
+    private CommaAndExpression() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        Generic a;
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && str.charAt(pos[0])==',') {
+            str.charAt(pos[0]++);
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        try {
+            a=(Generic)ExpressionParser.parser.parse(str,pos);
+        } catch (ParseException e) {
+            pos[0]=pos0;
+            throw e;
+        }
+        return a;
+    }
+}
diff --git a/src/misc/src/jscl/text/CommaAndVector.java b/src/misc/src/jscl/text/CommaAndVector.java
new file mode 100644
index 00000000..a764701f
--- /dev/null
+++ b/src/misc/src/jscl/text/CommaAndVector.java
@@ -0,0 +1,28 @@
+package jscl.text;
+
+import jscl.math.JSCLVector;
+
+public class CommaAndVector extends Parser {
+    public static final Parser parser=new CommaAndVector();
+
+    private CommaAndVector() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        JSCLVector v;
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && str.charAt(pos[0])==',') {
+            str.charAt(pos[0]++);
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        try {
+            v=(JSCLVector)VectorParser.parser.parse(str,pos);
+        } catch (ParseException e) {
+            pos[0]=pos0;
+            throw e;
+        }
+        return v;
+    }
+}
diff --git a/src/misc/src/jscl/text/CompoundIdentifier.java b/src/misc/src/jscl/text/CompoundIdentifier.java
new file mode 100644
index 00000000..7d5759e8
--- /dev/null
+++ b/src/misc/src/jscl/text/CompoundIdentifier.java
@@ -0,0 +1,54 @@
+package jscl.text;
+
+public class CompoundIdentifier extends Parser {
+    public static final Parser parser=new CompoundIdentifier();
+
+    private CompoundIdentifier() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        StringBuffer buffer=new StringBuffer();
+        skipWhitespaces(str,pos);
+        try {
+            String s=(String)Identifier.parser.parse(str,pos);
+            buffer.append(s);
+        } catch (ParseException e) {
+            pos[0]=pos0;
+            throw e;
+        }
+        while(true) {
+            try {
+                String s=(String)DotAndIdentifier.parser.parse(str,pos);
+                buffer.append(".").append(s);
+            } catch (ParseException e) {
+                break;
+            }
+        }
+        return buffer.toString();
+    }
+}
+
+class DotAndIdentifier extends Parser {
+    public static final Parser parser=new DotAndIdentifier();
+
+    private DotAndIdentifier() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        String s;
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && str.charAt(pos[0])=='.') {
+            str.charAt(pos[0]++);
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        try {
+            s=(String)Identifier.parser.parse(str,pos);
+        } catch (ParseException e) {
+            pos[0]=pos0;
+            throw e;
+        }
+        return s;
+    }
+}
diff --git a/src/misc/src/jscl/text/ConstantParser.java b/src/misc/src/jscl/text/ConstantParser.java
new file mode 100644
index 00000000..9a62d723
--- /dev/null
+++ b/src/misc/src/jscl/text/ConstantParser.java
@@ -0,0 +1,91 @@
+package jscl.text;
+
+import java.util.ArrayList;
+import java.util.List;
+import jscl.math.Generic;
+import jscl.math.function.Constant;
+import jscl.util.ArrayUtils;
+
+public class ConstantParser extends Parser {
+    public static final Parser parser=new ConstantParser();
+
+    private ConstantParser() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        String name;
+        int prime=0;
+        List l=new ArrayList();
+        try {
+            name=(String)CompoundIdentifier.parser.parse(str,pos);
+        } catch (ParseException e) {
+            throw e;
+        }
+        while(true) {
+            try {
+                Generic s=(Generic)Subscript.parser.parse(str,pos);
+                l.add(s);
+            } catch (ParseException e) {
+                break;
+            }
+        }
+        try {
+            prime=((Integer)Prime.parser.parse(str,pos)).intValue();
+        } catch (ParseException e) {}
+        Generic s[]=(Generic[])ArrayUtils.toArray(l,new Generic[l.size()]);
+        Constant v=new Constant(name,prime,s);
+        return v;
+    }
+}
+
+class Prime extends Parser {
+    public static final Parser parser=new Prime();
+
+    private Prime() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        int c;
+        try {
+            c=((Integer)PrimeCharacters.parser.parse(str,pos)).intValue();
+        } catch (ParseException e) {
+            try {
+                c=((Integer)Superscript.parser.parse(str,pos)).intValue();
+            } catch (ParseException e2) {
+                throw e2;
+            }
+        }
+        return new Integer(c);
+    }
+}
+
+class Superscript extends Parser {
+    public static final Parser parser=new Superscript();
+
+    private Superscript() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        int c;
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && str.charAt(pos[0])=='{') {
+            str.charAt(pos[0]++);
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        try {
+            c=((Integer)IntegerParser.parser.parse(str,pos)).intValue();
+        } catch (ParseException e) {
+            pos[0]=pos0;
+            throw e;
+        }
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && str.charAt(pos[0])=='}') {
+            str.charAt(pos[0]++);
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        return new Integer(c);
+    }
+}
diff --git a/src/misc/src/jscl/text/Digits.java b/src/misc/src/jscl/text/Digits.java
new file mode 100644
index 00000000..092fad0e
--- /dev/null
+++ b/src/misc/src/jscl/text/Digits.java
@@ -0,0 +1,25 @@
+package jscl.text;
+
+public class Digits extends Parser {
+    public static final Parser parser=new Digits();
+
+    private Digits() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        StringBuffer buffer=new StringBuffer();
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && Character.isDigit(str.charAt(pos[0]))) {
+            char c=str.charAt(pos[0]++);
+            buffer.append(c);
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        while(pos[0]<str.length() && Character.isDigit(str.charAt(pos[0]))) {
+            char c=str.charAt(pos[0]++);
+            buffer.append(c);
+        }
+        return buffer.toString();
+    }
+}
diff --git a/src/misc/src/jscl/text/DoubleParser.java b/src/misc/src/jscl/text/DoubleParser.java
new file mode 100644
index 00000000..80eb2641
--- /dev/null
+++ b/src/misc/src/jscl/text/DoubleParser.java
@@ -0,0 +1,164 @@
+package jscl.text;
+
+import jscl.math.NumericWrapper;
+import jscl.math.numeric.JSCLDouble;
+
+public class DoubleParser extends Parser {
+    public static final Parser parser=new DoubleParser();
+
+    private DoubleParser() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        double d;
+        try {
+            d=((Double)Singularity.parser.parse(str,pos)).doubleValue();
+        } catch (ParseException e) {
+            try {
+                d=((Double)FloatingPointLiteral.parser.parse(str,pos)).doubleValue();
+            } catch (ParseException e2) {
+                throw e2;
+            }
+        }
+        return new NumericWrapper(JSCLDouble.valueOf(d));
+    }
+}
+
+class Singularity extends Parser {
+    public static final Parser parser=new Singularity();
+
+    private Singularity() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        double d;
+        try {
+            String s=(String)Identifier.parser.parse(str,pos);
+            if(s.compareTo("NaN")==0) d=Double.NaN;
+            else if(s.compareTo("Infinity")==0) d=Double.POSITIVE_INFINITY;
+            else {
+                pos[0]=pos0;
+                throw new ParseException();
+            }
+        } catch (ParseException e) {
+            throw e;
+        }
+        return new Double(d);
+    }
+}
+
+class FloatingPointLiteral extends Parser {
+    public static final Parser parser=new FloatingPointLiteral();
+
+    private FloatingPointLiteral() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        StringBuffer buffer=new StringBuffer();
+        boolean digits=false;
+        boolean point=false;
+        try {
+            String s=(String)Digits.parser.parse(str,pos);
+            buffer.append(s);
+            digits=true;
+        } catch (ParseException e) {}
+        try {
+            DecimalPoint.parser.parse(str,pos);
+            buffer.append(".");
+            point=true;
+        } catch (ParseException e) {
+            if(!digits) {
+                pos[0]=pos0;
+                throw e;
+            }
+        }
+        try {
+            String s=(String)Digits.parser.parse(str,pos);
+            buffer.append(s);
+        } catch (ParseException e) {
+            if(!digits) {
+                pos[0]=pos0;
+                throw e;
+            }
+        }
+        try {
+            String s=(String)ExponentPart.parser.parse(str,pos);
+            buffer.append(s);
+        } catch (ParseException e) {
+            if(!point) {
+                pos[0]=pos0;
+                throw e;
+            }
+        }
+        return new Double(buffer.toString());
+    }
+}
+
+class DecimalPoint extends Parser {
+    public static final Parser parser=new DecimalPoint();
+
+    private DecimalPoint() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && str.charAt(pos[0])=='.') {
+            str.charAt(pos[0]++);
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        return null;
+    }
+}
+
+class ExponentPart extends Parser {
+    public static final Parser parser=new ExponentPart();
+
+    private ExponentPart() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        StringBuffer buffer=new StringBuffer();
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && (str.charAt(pos[0])=='e' || str.charAt(pos[0])=='E')) {
+            char c=str.charAt(pos[0]++);
+            buffer.append(c);
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        try {
+            String s=(String)SignedInteger.parser.parse(str,pos);
+            buffer.append(s);
+        } catch (ParseException e) {
+            pos[0]=pos0;
+            throw e;
+        }
+        return buffer.toString();
+    }
+}
+
+class SignedInteger extends Parser {
+    public static final Parser parser=new SignedInteger();
+
+    private SignedInteger() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        StringBuffer buffer=new StringBuffer();
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && (str.charAt(pos[0])=='+' || str.charAt(pos[0])=='-')) {
+            char c=str.charAt(pos[0]++);
+            buffer.append(c);
+        }
+        try {
+            int n=((Integer)IntegerParser.parser.parse(str,pos)).intValue();
+            buffer.append(n);
+        } catch (ParseException e) {
+            pos[0]=pos0;
+            throw e;
+        }
+        return buffer.toString();
+    }
+}
diff --git a/src/misc/src/jscl/text/DoubleVariableParser.java b/src/misc/src/jscl/text/DoubleVariableParser.java
new file mode 100644
index 00000000..d5a19407
--- /dev/null
+++ b/src/misc/src/jscl/text/DoubleVariableParser.java
@@ -0,0 +1,20 @@
+package jscl.text;
+
+import jscl.math.DoubleVariable;
+import jscl.math.NumericWrapper;
+
+public class DoubleVariableParser extends Parser {
+    public static final Parser parser=new DoubleVariableParser();
+
+    private DoubleVariableParser() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        NumericWrapper a;
+        try {
+            a=(NumericWrapper)DoubleParser.parser.parse(str,pos);
+        } catch (ParseException e) {
+            throw e;
+        }
+        return new DoubleVariable(a);
+    }
+}
diff --git a/src/misc/src/jscl/text/ExpressionParser.java b/src/misc/src/jscl/text/ExpressionParser.java
new file mode 100644
index 00000000..44fe3832
--- /dev/null
+++ b/src/misc/src/jscl/text/ExpressionParser.java
@@ -0,0 +1,355 @@
+package jscl.text;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.ListIterator;
+import jscl.math.Generic;
+import jscl.math.GenericVariable;
+import jscl.math.JSCLInteger;
+import jscl.math.NotIntegerException;
+import jscl.math.Variable;
+import jscl.math.function.Frac;
+import jscl.math.function.Inv;
+import jscl.math.function.Pow;
+import jscl.math.operator.Factorial;
+
+public class ExpressionParser extends Parser {
+    public static final Parser parser=new ExpressionParser();
+
+    private ExpressionParser() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        Generic a;
+        boolean sign=false;
+        try {
+            MinusParser.parser.parse(str,pos);
+            sign=true;
+        } catch (ParseException e) {}
+        try {
+            a=(Generic)TermParser.parser.parse(str,pos);
+        } catch (ParseException e) {
+            throw e;
+        }
+        if(sign) a=a.negate();
+        while(true) {
+            try {
+                Generic a2=(Generic)PlusOrMinusTerm.parser.parse(str,pos);
+                a=a.add(a2);
+            } catch (ParseException e) {
+                break;
+            }
+        }
+        return a;
+    }
+}
+
+class MinusParser extends Parser {
+    public static final Parser parser=new MinusParser();
+
+    private MinusParser() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && str.charAt(pos[0])=='-') {
+            str.charAt(pos[0]++);
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        return null;
+    }
+}
+
+class PlusOrMinusTerm extends Parser {
+    public static final Parser parser=new PlusOrMinusTerm();
+
+    private PlusOrMinusTerm() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        boolean sign;
+        Generic a;
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && (str.charAt(pos[0])=='+' || str.charAt(pos[0])=='-')) {
+            sign=str.charAt(pos[0]++)=='-';
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        try {
+            a=(Generic)TermParser.parser.parse(str,pos);
+        } catch (ParseException e) {
+            pos[0]=pos0;
+            throw e;
+        }
+        return sign?a.negate():a;
+    }
+}
+
+class TermParser extends Parser {
+    public static final Parser parser=new TermParser();
+
+    private TermParser() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        Generic a=JSCLInteger.valueOf(1);
+        Generic s;
+        try {
+            s=(Generic)UnsignedFactor.parser.parse(str,pos);
+        } catch (ParseException e) {
+            throw e;
+        }
+        while(true) {
+            try {
+                Generic b=(Generic)MultiplyOrDivideFactor.multiply.parse(str,pos);
+                a=a.multiply(s);
+                s=b;
+            } catch (ParseException e) {
+                try {
+                    Generic b=(Generic)MultiplyOrDivideFactor.divide.parse(str,pos);
+                    if(s.compareTo(JSCLInteger.valueOf(1))==0) s=new Inv(GenericVariable.content(b,true)).expressionValue();
+                    else s=new Frac(GenericVariable.content(s,true),GenericVariable.content(b,true)).expressionValue();
+                } catch (ParseException e2) {
+                    break;
+                }
+            }
+        }
+        a=a.multiply(s);
+        return a;
+    }
+}
+
+class MultiplyOrDivideFactor extends Parser {
+    public static final Parser multiply=new MultiplyOrDivideFactor(true);
+    public static final Parser divide=new MultiplyOrDivideFactor(false);
+    boolean option;
+
+    private MultiplyOrDivideFactor(boolean option) {
+        this.option=option;
+    }
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        Generic a;
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && str.charAt(pos[0])==(option?'*':'/')) {
+            str.charAt(pos[0]++);
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        try {
+            a=(Generic)Factor.parser.parse(str,pos);
+        } catch (ParseException e) {
+            pos[0]=pos0;
+            throw e;
+        }
+        return a;
+    }
+}
+
+class Factor extends Parser {
+    public static final Parser parser=new Factor();
+
+    private Factor() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        Generic a;
+        boolean sign=false;
+        try {
+            MinusParser.parser.parse(str,pos);
+            sign=true;
+        } catch (ParseException e) {}
+        try {
+            a=(Generic)UnsignedFactor.parser.parse(str,pos);
+        } catch (ParseException e) {
+            throw e;
+        }
+        return sign?a.negate():a;
+    }
+}
+
+class UnsignedFactor extends Parser {
+    public static final Parser parser=new UnsignedFactor();
+
+    private UnsignedFactor() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        Generic a;
+        List l=new ArrayList();
+        try {
+            a=(Generic)UnsignedExponent.parser.parse(str,pos);
+            l.add(a);
+        } catch (ParseException e) {
+            throw e;
+        }
+        while(true) {
+            try {
+                a=(Generic)PowerExponent.parser.parse(str,pos);
+                l.add(a);
+            } catch (ParseException e) {
+                break;
+            }
+        }
+        ListIterator it=l.listIterator(l.size());
+        a=(Generic)it.previous();
+        while(it.hasPrevious()) {
+            Generic b=(Generic)it.previous();
+            try {
+                int c=a.integerValue().intValue();
+                if(c<0) a=new Pow(GenericVariable.content(b,true),JSCLInteger.valueOf(c)).expressionValue();
+                else a=b.pow(c);
+            } catch (NotIntegerException e) {
+                a=new Pow(GenericVariable.content(b,true),GenericVariable.content(a,true)).expressionValue();
+            }
+        }
+        return a;
+    }
+}
+
+class PowerExponent extends Parser {
+    public static final Parser parser=new PowerExponent();
+
+    private PowerExponent() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        Generic a;
+        try {
+            PowerParser.parser.parse(str,pos);
+        } catch (ParseException e) {
+            pos[0]=pos0;
+            throw e;
+        }
+        try {
+            a=(Generic)Exponent.parser.parse(str,pos);
+        } catch (ParseException e) {
+            pos[0]=pos0;
+            throw e;
+        }
+        return a;
+    }
+}
+
+class PowerParser extends Parser {
+    public static final Parser parser=new PowerParser();
+
+    private PowerParser() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && str.charAt(pos[0])=='^') {
+            str.charAt(pos[0]++);
+        } else {
+            if(pos[0]+1<str.length() && str.charAt(pos[0])=='*' && str.charAt(pos[0]+1)=='*') {
+                str.charAt(pos[0]++);
+                str.charAt(pos[0]++);
+            } else {
+                pos[0]=pos0;
+                throw new ParseException();
+            }
+        }
+        return null;
+    }
+}
+
+class Exponent extends Parser {
+    public static final Parser parser=new Exponent();
+
+    private Exponent() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        Generic a;
+        boolean sign=false;
+        try {
+            MinusParser.parser.parse(str,pos);
+            sign=true;
+        } catch (ParseException e) {}
+        try {
+            a=(Generic)UnsignedExponent.parser.parse(str,pos);
+        } catch (ParseException e) {
+            pos[0]=pos0;
+            throw e;
+        }
+        return sign?a.negate():a;
+    }
+}
+
+class UnsignedExponent extends Parser {
+    public static final Parser parser=new UnsignedExponent();
+
+    private UnsignedExponent() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        Generic a;
+        boolean factorial=false;
+        try {
+            a=(Generic)PrimaryExpression.parser.parse(str,pos);
+        } catch (ParseException e) {
+            throw e;
+        }
+        try {
+            FactorialParser.parser.parse(str,pos);
+            factorial=true;
+        } catch (ParseException e) {}
+        return factorial?new Factorial(GenericVariable.content(a,true)).expressionValue():a;
+    }
+}
+
+class FactorialParser extends Parser {
+    public static final Parser parser=new FactorialParser();
+
+    private FactorialParser() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && str.charAt(pos[0])=='!') {
+            str.charAt(pos[0]++);
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        return null;
+    }
+}
+
+class PrimaryExpression extends Parser {
+    public static final Parser parser=new PrimaryExpression();
+
+    private PrimaryExpression() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        Generic a;
+        try {
+            a=((Variable)DoubleVariableParser.parser.parse(str,pos)).expressionValue();
+        } catch (ParseException e) {
+            try {
+                a=(Generic)JSCLIntegerParser.parser.parse(str,pos);
+            } catch (ParseException e2) {
+                try {
+                    a=((Variable)VariableParser.parser.parse(str,pos)).expressionValue();
+                } catch (ParseException e3) {
+                    try {
+                        a=((Variable)MatrixVariableParser.parser.parse(str,pos)).expressionValue();
+                    } catch (ParseException e4) {
+                        try {
+                            a=((Variable)VectorVariableParser.parser.parse(str,pos)).expressionValue();
+                        } catch (ParseException e5) {
+                            try {
+                                a=((Variable)BracketedExpression.parser.parse(str,pos)).expressionValue();
+                            } catch (ParseException e6) {
+                                throw e6;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return a;
+    }
+}
diff --git a/src/misc/src/jscl/text/FunctionParser.java b/src/misc/src/jscl/text/FunctionParser.java
new file mode 100644
index 00000000..ca156b4f
--- /dev/null
+++ b/src/misc/src/jscl/text/FunctionParser.java
@@ -0,0 +1,113 @@
+package jscl.text;
+
+import jscl.math.Generic;
+import jscl.math.function.Abs;
+import jscl.math.function.Comparison;
+import jscl.math.function.Conjugate;
+import jscl.math.function.Cubic;
+import jscl.math.function.Exp;
+import jscl.math.function.Function;
+import jscl.math.function.Log;
+import jscl.math.function.Sgn;
+import jscl.math.function.Sqrt;
+import jscl.math.function.hyperbolic.Acosh;
+import jscl.math.function.hyperbolic.Acoth;
+import jscl.math.function.hyperbolic.Asinh;
+import jscl.math.function.hyperbolic.Atanh;
+import jscl.math.function.hyperbolic.Cosh;
+import jscl.math.function.hyperbolic.Coth;
+import jscl.math.function.hyperbolic.Sinh;
+import jscl.math.function.hyperbolic.Tanh;
+import jscl.math.function.trigonometric.Acos;
+import jscl.math.function.trigonometric.Acot;
+import jscl.math.function.trigonometric.Asin;
+import jscl.math.function.trigonometric.Atan;
+import jscl.math.function.trigonometric.Cos;
+import jscl.math.function.trigonometric.Cot;
+import jscl.math.function.trigonometric.Sin;
+import jscl.math.function.trigonometric.Tan;
+
+public class FunctionParser extends Parser {
+    public static final Parser parser=new FunctionParser();
+
+    private FunctionParser() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        Function v;
+        try {
+            v=(Function)UsualFunctionParser.parser.parse(str,pos);
+        } catch (ParseException e) {
+            try {
+                v=(Function)RootParser.parser.parse(str,pos);
+            } catch (ParseException e2) {
+                try {
+                    v=(Function)ImplicitFunctionParser.parser.parse(str,pos);
+                } catch (ParseException e3) {
+                    throw e3;
+                }
+            }
+        }
+        return v;
+    }
+}
+
+class UsualFunctionParser extends Parser {
+    public static final Parser parser=new UsualFunctionParser();
+
+    private UsualFunctionParser() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        String name;
+        Generic a[];
+        try {
+            name=(String)Identifier.parser.parse(str,pos);
+            if(valid(name));
+            else {
+                pos[0]=pos0;
+                throw new ParseException();
+            }
+        } catch (ParseException e) {
+            throw e;
+        }
+        try {
+            a=(Generic[])ParameterList.parser.parse(str,pos);
+        } catch (ParseException e) {
+            pos[0]=pos0;
+            throw e;
+        }
+        Function v=null;
+        if(name.compareTo("sin")==0) v=new Sin(a[0]);
+        else if(name.compareTo("cos")==0) v=new Cos(a[0]);
+        else if(name.compareTo("tan")==0) v=new Tan(a[0]);
+        else if(name.compareTo("cot")==0) v=new Cot(a[0]);
+        else if(name.compareTo("asin")==0) v=new Asin(a[0]);
+        else if(name.compareTo("acos")==0) v=new Acos(a[0]);
+        else if(name.compareTo("atan")==0) v=new Atan(a[0]);
+        else if(name.compareTo("acot")==0) v=new Acot(a[0]);
+        else if(name.compareTo("log")==0) v=new Log(a[0]);
+        else if(name.compareTo("exp")==0) v=new Exp(a[0]);
+        else if(name.compareTo("sqrt")==0) v=new Sqrt(a[0]);
+        else if(name.compareTo("cubic")==0) v=new Cubic(a[0]);
+        else if(name.compareTo("sinh")==0) v=new Sinh(a[0]);
+        else if(name.compareTo("cosh")==0) v=new Cosh(a[0]);
+        else if(name.compareTo("tanh")==0) v=new Tanh(a[0]);
+        else if(name.compareTo("coth")==0) v=new Coth(a[0]);
+        else if(name.compareTo("asinh")==0) v=new Asinh(a[0]);
+        else if(name.compareTo("acosh")==0) v=new Acosh(a[0]);
+        else if(name.compareTo("atanh")==0) v=new Atanh(a[0]);
+        else if(name.compareTo("acoth")==0) v=new Acoth(a[0]);
+        else if(name.compareTo("abs")==0) v=new Abs(a[0]);
+        else if(name.compareTo("sgn")==0) v=new Sgn(a[0]);
+        else if(name.compareTo("conjugate")==0) v=new Conjugate(a[0]);
+        else if(name.compareTo("eq")==0 || name.compareTo("le")==0 || name.compareTo("ge")==0 || name.compareTo("ne")==0 || name.compareTo("lt")==0 || name.compareTo("gt")==0 || name.compareTo("ap")==0) v=new Comparison(name,a[0],a[1]);
+        return v;
+    }
+
+    static boolean valid(String name) {
+        for(int i=0;i<na.length;i++) if(name.compareTo(na[i])==0) return true;
+        return false;
+    }
+
+    private static String na[]={"sin","cos","tan","cot","asin","acos","atan","acot","log","exp","sqrt","cubic","sinh","cosh","tanh","coth","asinh","acosh","atanh","acoth","abs","sgn","conjugate","eq","le","ge","ne","lt","gt","ap"};
+}
diff --git a/src/misc/src/jscl/text/Identifier.java b/src/misc/src/jscl/text/Identifier.java
new file mode 100644
index 00000000..eb6fb85f
--- /dev/null
+++ b/src/misc/src/jscl/text/Identifier.java
@@ -0,0 +1,31 @@
+package jscl.text;
+
+public class Identifier extends Parser {
+    public static final Parser parser=new Identifier();
+
+    private Identifier() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        StringBuffer buffer=new StringBuffer();
+        skipWhitespaces(str,pos);
+//      if(pos[0]<str.length() && Character.isLetter(str.charAt(pos[0]))) {
+        if(pos[0]<str.length() && isLetter(str.charAt(pos[0]))) {
+            char c=str.charAt(pos[0]++);
+            buffer.append(c);
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+//      while(pos[0]<str.length() && Character.isLetterOrDigit(str.charAt(pos[0]))) {
+        while(pos[0]<str.length() && (isLetter(str.charAt(pos[0])) || Character.isDigit(str.charAt(pos[0])))) {
+            char c=str.charAt(pos[0]++);
+            buffer.append(c);
+        }
+        return buffer.toString();
+    }
+
+    static boolean isLetter(char c) {
+        return (c>='A' && c<='Z') || (c>='a' && c<='z') || c=='_';
+    }
+}
diff --git a/src/misc/src/jscl/text/ImplicitFunctionParser.java b/src/misc/src/jscl/text/ImplicitFunctionParser.java
new file mode 100644
index 00000000..efdad98d
--- /dev/null
+++ b/src/misc/src/jscl/text/ImplicitFunctionParser.java
@@ -0,0 +1,137 @@
+package jscl.text;
+
+import java.util.ArrayList;
+import java.util.List;
+import jscl.math.Generic;
+import jscl.math.function.ImplicitFunction;
+import jscl.util.ArrayUtils;
+
+public class ImplicitFunctionParser extends Parser {
+    public static final Parser parser=new ImplicitFunctionParser();
+
+    private ImplicitFunctionParser() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        String name;
+        Generic a[];
+        int b[];
+        List l=new ArrayList();
+        try {
+            name=(String)CompoundIdentifier.parser.parse(str,pos);
+        } catch (ParseException e) {
+            pos[0]=pos0;
+            throw e;
+        }
+        while(true) {
+            try {
+                Generic s=(Generic)Subscript.parser.parse(str,pos);
+                l.add(s);
+            } catch (ParseException e) {
+                break;
+            }
+        }
+        try {
+            b=(int [])Derivation.parser.parse(str,pos);
+        } catch (ParseException e) {
+            b=new int[0];
+                }
+        try {
+            a=(Generic[])ParameterList.parser.parse(str,pos);
+        } catch (ParseException e) {
+            pos[0]=pos0;
+            throw e;
+        }
+        Generic s[]=(Generic[])ArrayUtils.toArray(l,new Generic[l.size()]);
+        int derivation[]=new int[a.length];
+        for(int i=0;i<a.length && i<b.length;i++) derivation[i]=b[i];
+        return new ImplicitFunction(name,a,derivation,s);
+    }
+}
+
+class Derivation extends Parser {
+    public static final Parser parser=new Derivation();
+
+    private Derivation() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        int c[];
+        try {
+            c=new int[] {((Integer)PrimeCharacters.parser.parse(str,pos)).intValue()};
+        } catch (ParseException e) {
+            try {
+                c=(int [])SuperscriptList.parser.parse(str,pos);
+            } catch (ParseException e2) {
+                throw e2;
+            }
+        }
+        return c;
+    }
+}
+
+class SuperscriptList extends Parser {
+    public static final Parser parser=new SuperscriptList();
+
+    private SuperscriptList() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        List l=new ArrayList();
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && str.charAt(pos[0])=='{') {
+            str.charAt(pos[0]++);
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        try {
+            Integer in=(Integer)IntegerParser.parser.parse(str,pos);
+            l.add(in);
+        } catch (ParseException e) {
+            pos[0]=pos0;
+            throw e;
+        }
+        while(true) {
+            try {
+                Integer in=(Integer)CommaAndInteger.parser.parse(str,pos);
+                l.add(in);
+            } catch (ParseException e) {
+                break;
+            }
+        }
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && str.charAt(pos[0])=='}') {
+            str.charAt(pos[0]++);
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        return (int[])ArrayUtils.toArray(l,new int[l.size()]);
+    }
+}
+
+class CommaAndInteger extends Parser {
+    public static final Parser parser=new CommaAndInteger();
+
+    private CommaAndInteger() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        int c;
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && str.charAt(pos[0])==',') {
+            str.charAt(pos[0]++);
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        try {
+            c=((Integer)IntegerParser.parser.parse(str,pos)).intValue();
+        } catch (ParseException e) {
+            pos[0]=pos0;
+            throw e;
+        }
+        return new Integer(c);
+    }
+}
diff --git a/src/misc/src/jscl/text/IntegerParser.java b/src/misc/src/jscl/text/IntegerParser.java
new file mode 100644
index 00000000..8d0e912b
--- /dev/null
+++ b/src/misc/src/jscl/text/IntegerParser.java
@@ -0,0 +1,29 @@
+package jscl.text;
+
+public class IntegerParser extends Parser {
+    public static final Parser parser=new IntegerParser();
+
+    private IntegerParser() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+//      StringBuffer buffer=new StringBuffer();
+        int n;
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && Character.isDigit(str.charAt(pos[0]))) {
+            char c=str.charAt(pos[0]++);
+//          buffer.append(c);
+            n=c-'0';
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        while(pos[0]<str.length() && Character.isDigit(str.charAt(pos[0]))) {
+            char c=str.charAt(pos[0]++);
+//          buffer.append(c);
+            n=10*n+(c-'0');
+        }
+//      return new Integer(buffer.toString());
+        return new Integer(n);
+    }
+}
diff --git a/src/misc/src/jscl/text/JSCLIntegerParser.java b/src/misc/src/jscl/text/JSCLIntegerParser.java
new file mode 100644
index 00000000..307b2bd3
--- /dev/null
+++ b/src/misc/src/jscl/text/JSCLIntegerParser.java
@@ -0,0 +1,22 @@
+package jscl.text;
+
+import java.math.BigInteger;
+import jscl.math.JSCLInteger;
+
+public class JSCLIntegerParser extends Parser {
+    public static final Parser parser=new JSCLIntegerParser();
+
+    private JSCLIntegerParser() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        StringBuffer buffer=new StringBuffer();
+        try {
+            String s=(String)Digits.parser.parse(str,pos);
+            buffer.append(s);
+        } catch (ParseException e) {
+            throw e;
+        }
+        return new JSCLInteger(new BigInteger(buffer.toString()));
+    }
+}
diff --git a/src/misc/src/jscl/text/MatrixParser.java b/src/misc/src/jscl/text/MatrixParser.java
new file mode 100644
index 00000000..62987330
--- /dev/null
+++ b/src/misc/src/jscl/text/MatrixParser.java
@@ -0,0 +1,49 @@
+package jscl.text;
+
+import java.util.ArrayList;
+import java.util.List;
+import jscl.math.JSCLVector;
+import jscl.math.Matrix;
+import jscl.util.ArrayUtils;
+
+public class MatrixParser extends Parser {
+    public static final Parser parser=new MatrixParser();
+
+    private MatrixParser() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        List l=new ArrayList();
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && str.charAt(pos[0])=='{') {
+            str.charAt(pos[0]++);
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        try {
+            JSCLVector v=(JSCLVector)VectorParser.parser.parse(str,pos);
+            l.add(v);
+        } catch (ParseException e) {
+            pos[0]=pos0;
+            throw e;
+        }
+        while(true) {
+            try {
+                JSCLVector v=(JSCLVector)CommaAndVector.parser.parse(str,pos);
+                l.add(v);
+            } catch (ParseException e) {
+                break;
+            }
+        }
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && str.charAt(pos[0])=='}') {
+            str.charAt(pos[0]++);
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        JSCLVector v[]=(JSCLVector[])ArrayUtils.toArray(l,new JSCLVector[l.size()]);
+        return Matrix.frame(v).transpose();
+    }
+}
diff --git a/src/misc/src/jscl/text/MatrixVariableParser.java b/src/misc/src/jscl/text/MatrixVariableParser.java
new file mode 100644
index 00000000..c04238a5
--- /dev/null
+++ b/src/misc/src/jscl/text/MatrixVariableParser.java
@@ -0,0 +1,20 @@
+package jscl.text;
+
+import jscl.math.Matrix;
+import jscl.math.MatrixVariable;
+
+class MatrixVariableParser extends Parser {
+    public static final Parser parser=new MatrixVariableParser();
+
+    private MatrixVariableParser() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        Matrix m;
+        try {
+            m=(Matrix)MatrixParser.parser.parse(str,pos);
+        } catch (ParseException e) {
+            throw e;
+        }
+        return new MatrixVariable(m);
+    }
+}
diff --git a/src/misc/src/jscl/text/OperatorParser.java b/src/misc/src/jscl/text/OperatorParser.java
new file mode 100644
index 00000000..395b73a3
--- /dev/null
+++ b/src/misc/src/jscl/text/OperatorParser.java
@@ -0,0 +1,107 @@
+package jscl.text;
+
+import jscl.math.Expression;
+import jscl.math.Generic;
+import jscl.math.JSCLInteger;
+import jscl.math.function.Constant;
+import jscl.math.operator.Coefficient;
+import jscl.math.operator.Derivative;
+import jscl.math.operator.Division;
+import jscl.math.operator.Groebner;
+import jscl.math.operator.IndefiniteIntegral;
+import jscl.math.operator.Integral;
+import jscl.math.operator.Limit;
+import jscl.math.operator.Modulo;
+import jscl.math.operator.Operator;
+import jscl.math.operator.Product;
+import jscl.math.operator.Solve;
+import jscl.math.operator.Substitute;
+import jscl.math.operator.Sum;
+import jscl.math.operator.matrix.Determinant;
+import jscl.math.operator.matrix.Trace;
+import jscl.math.operator.matrix.Transpose;
+import jscl.math.operator.number.EulerPhi;
+import jscl.math.operator.number.ModInverse;
+import jscl.math.operator.number.ModPow;
+import jscl.math.operator.number.PrimitiveRoots;
+import jscl.math.operator.product.ComplexProduct;
+import jscl.math.operator.product.GeometricProduct;
+import jscl.math.operator.product.MatrixProduct;
+import jscl.math.operator.product.QuaternionProduct;
+import jscl.math.operator.product.TensorProduct;
+import jscl.math.operator.product.VectorProduct;
+import jscl.math.operator.vector.Curl;
+import jscl.math.operator.vector.Dalembertian;
+import jscl.math.operator.vector.Del;
+import jscl.math.operator.vector.Divergence;
+import jscl.math.operator.vector.Grad;
+import jscl.math.operator.vector.Jacobian;
+import jscl.math.operator.vector.Laplacian;
+
+public class OperatorParser extends Parser {
+    public static final Parser parser=new OperatorParser();
+
+    private OperatorParser() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        String name;
+        Generic a[];
+        try {
+            name=(String)Identifier.parser.parse(str,pos);
+            if(valid(name));
+            else {
+                pos[0]=pos0;
+                throw new ParseException();
+            }
+        } catch (ParseException e) {
+            throw e;
+        }
+        try {
+            a=(Generic[])ParameterList.parser.parse(str,pos);
+        } catch (ParseException e) {
+            pos[0]=pos0;
+            throw e;
+        }
+        Operator v=null;
+        if(name.compareTo("d")==0) v=new Derivative(a[0],a[1],a.length>2?a[2]:a[1],a.length>3?a[3]:JSCLInteger.valueOf(1));
+        else if(name.compareTo("grad")==0) v=new Grad(a[0],a[1]);
+        else if(name.compareTo("diverg")==0) v=new Divergence(a[0],a[1]);
+        else if(name.compareTo("curl")==0) v=new Curl(a[0],a[1]);
+        else if(name.compareTo("jacobian")==0) v=new Jacobian(a[0],a[1]);
+        else if(name.compareTo("laplacian")==0) v=new Laplacian(a[0],a[1]);
+        else if(name.compareTo("dalembertian")==0) v=new Dalembertian(a[0],a[1]);
+        else if(name.compareTo("del")==0) v=new Del(a[0],a[1],a.length>2?a[2]:JSCLInteger.valueOf(0));
+        else if(name.compareTo("vector")==0) v=new VectorProduct(a[0],a[1]);
+        else if(name.compareTo("complex")==0) v=new ComplexProduct(a[0],a[1]);
+        else if(name.compareTo("quaternion")==0) v=new QuaternionProduct(a[0],a[1]);
+        else if(name.compareTo("geometric")==0) v=new GeometricProduct(a[0],a[1],a.length>2?a[2]:JSCLInteger.valueOf(0));
+        else if(name.compareTo("matrix")==0) v=new MatrixProduct(a[0],a[1]);
+        else if(name.compareTo("tensor")==0) v=new TensorProduct(a[0],a[1]);
+        else if(name.compareTo("tran")==0) v=new Transpose(a[0]);
+        else if(name.compareTo("trace")==0) v=new Trace(a[0]);
+        else if(name.compareTo("det")==0) v=new Determinant(a[0]);
+        else if(name.compareTo("coef")==0) v=new Coefficient(a[0],a[1]);
+        else if(name.compareTo("solve")==0) v=new Solve(a[0],a[1],a.length>2?a[2]:JSCLInteger.valueOf(0));
+        else if(name.compareTo("subst")==0) v=new Substitute(a[0],a[1],a[2]).transmute();
+        else if(name.compareTo("lim")==0) v=new Limit(a[0],a[1],a[2],a.length>3 && (a[2].compareTo(Constant.infinity)!=0 && a[2].compareTo(Constant.infinity.negate())!=0)?JSCLInteger.valueOf(a[3].signum()):JSCLInteger.valueOf(0));
+        else if(name.compareTo("sum")==0) v=new Sum(a[0],a[1],a[2],a[3]);
+        else if(name.compareTo("prod")==0) v=new Product(a[0],a[1],a[2],a[3]);
+        else if(name.compareTo("integral")==0) v=a.length>2?(Operator)new Integral(a[0],a[1],a[2],a[3]):new IndefiniteIntegral(a[0],a[1]);
+        else if(name.compareTo("groebner")==0) v=new Groebner(a[0],a[1],a.length>2?a[2]:Expression.valueOf("lex"),a.length>3?a[3]:JSCLInteger.valueOf(0)).transmute();
+        else if(name.compareTo("div")==0) v=new Division(a[0],a[1]);
+        else if(name.compareTo("mod")==0) v=new Modulo(a[0],a[1]);
+        else if(name.compareTo("modpow")==0) v=new ModPow(a[0],a[1],a[2]);
+        else if(name.compareTo("modinv")==0) v=new ModInverse(a[0],a[1]);
+        else if(name.compareTo("eulerphi")==0) v=new EulerPhi(a[0]);
+        else if(name.compareTo("primitiveroots")==0) v=new PrimitiveRoots(a[0]);
+        return v;
+    }
+
+    static boolean valid(String name) {
+        for(int i=0;i<na.length;i++) if(name.compareTo(na[i])==0) return true;
+        return false;
+    }
+
+    private static String na[]={"d","grad","diverg","curl","jacobian","laplacian","dalembertian","del","vector","complex","quaternion","geometric","matrix","tensor","tran","trace","det","coef","solve","subst","lim","sum","prod","integral","groebner","div","mod","modpow","modinv","eulerphi","primitiveroots"};
+}
diff --git a/src/misc/src/jscl/text/ParameterList.java b/src/misc/src/jscl/text/ParameterList.java
new file mode 100644
index 00000000..d6e0b194
--- /dev/null
+++ b/src/misc/src/jscl/text/ParameterList.java
@@ -0,0 +1,47 @@
+package jscl.text;
+
+import java.util.ArrayList;
+import java.util.List;
+import jscl.math.Generic;
+import jscl.util.ArrayUtils;
+
+public class ParameterList extends Parser {
+    public static final Parser parser=new ParameterList();
+
+    private ParameterList() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        List l=new ArrayList();
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && str.charAt(pos[0])=='(') {
+            str.charAt(pos[0]++);
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        try {
+            Generic a=(Generic)ExpressionParser.parser.parse(str,pos);
+            l.add(a);
+        } catch (ParseException e) {
+            pos[0]=pos0;
+            throw e;
+        }
+        while(true) {
+            try {
+                Generic a=(Generic)CommaAndExpression.parser.parse(str,pos);
+                l.add(a);
+            } catch (ParseException e) {
+                break;
+            }
+        }
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && str.charAt(pos[0])==')') {
+            str.charAt(pos[0]++);
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        return (Generic[])ArrayUtils.toArray(l,new Generic[l.size()]);
+    }
+}
diff --git a/src/misc/src/jscl/text/ParseException.java b/src/misc/src/jscl/text/ParseException.java
new file mode 100644
index 00000000..b1cfa7ac
--- /dev/null
+++ b/src/misc/src/jscl/text/ParseException.java
@@ -0,0 +1,9 @@
+package jscl.text;
+
+public class ParseException extends Exception {
+    public ParseException() {}
+
+    public ParseException(String s) {
+        super(s);
+    }
+}
diff --git a/src/misc/src/jscl/text/Parser.java b/src/misc/src/jscl/text/Parser.java
new file mode 100644
index 00000000..098d7b47
--- /dev/null
+++ b/src/misc/src/jscl/text/Parser.java
@@ -0,0 +1,14 @@
+package jscl.text;
+
+public abstract class Parser {
+    public abstract Object parse(String str, int pos[]) throws ParseException;
+
+    public static void skipWhitespaces(String str, int pos[]) {
+//      while(pos[0]<str.length() && Character.isWhitespace(str.charAt(pos[0]))) pos[0]++;
+        while(pos[0]<str.length() && isWhitespace(str.charAt(pos[0]))) pos[0]++;
+    }
+
+    static boolean isWhitespace(char c) {
+        return c==' ' || c=='\t' || c=='\n';
+    }
+}
diff --git a/src/misc/src/jscl/text/PrimeCharacters.java b/src/misc/src/jscl/text/PrimeCharacters.java
new file mode 100644
index 00000000..88c74f87
--- /dev/null
+++ b/src/misc/src/jscl/text/PrimeCharacters.java
@@ -0,0 +1,25 @@
+package jscl.text;
+
+public class PrimeCharacters extends Parser {
+    public static final Parser parser=new PrimeCharacters();
+
+    private PrimeCharacters() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        int c;
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && str.charAt(pos[0])=='\'') {
+            str.charAt(pos[0]++);
+            c=1;
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        while(pos[0]<str.length() && str.charAt(pos[0])=='\'') {
+            str.charAt(pos[0]++);
+            c++;
+        }
+        return new Integer(c);
+    }
+}
diff --git a/src/misc/src/jscl/text/RootParser.java b/src/misc/src/jscl/text/RootParser.java
new file mode 100644
index 00000000..cca53bc1
--- /dev/null
+++ b/src/misc/src/jscl/text/RootParser.java
@@ -0,0 +1,40 @@
+package jscl.text;
+
+import jscl.math.Generic;
+import jscl.math.function.Root;
+
+public class RootParser extends Parser {
+    public static final Parser parser=new RootParser();
+
+    private RootParser() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        String name;
+        Generic subscript;
+        Generic a[];
+        try {
+            name=(String)Identifier.parser.parse(str,pos);
+            if(name.compareTo("root")==0);
+            else {
+                pos[0]=pos0;
+                throw new ParseException();
+            }
+        } catch (ParseException e) {
+            throw e;
+        }
+        try {
+            subscript=(Generic)Subscript.parser.parse(str,pos);
+        } catch (ParseException e) {
+            pos[0]=pos0;
+            throw e;
+        }
+        try {
+            a=(Generic[])ParameterList.parser.parse(str,pos);
+        } catch (ParseException e) {
+            pos[0]=pos0;
+            throw e;
+        }
+        return new Root(a,subscript);
+    }
+}
diff --git a/src/misc/src/jscl/text/Subscript.java b/src/misc/src/jscl/text/Subscript.java
new file mode 100644
index 00000000..d7364497
--- /dev/null
+++ b/src/misc/src/jscl/text/Subscript.java
@@ -0,0 +1,35 @@
+package jscl.text;
+
+import jscl.math.Generic;
+
+public class Subscript extends Parser {
+    public static final Parser parser=new Subscript();
+
+    private Subscript() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        Generic a;
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && str.charAt(pos[0])=='[') {
+            str.charAt(pos[0]++);
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        try {
+            a=(Generic)ExpressionParser.parser.parse(str,pos);
+        } catch (ParseException e) {
+            pos[0]=pos0;
+            throw e;
+        }
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && str.charAt(pos[0])==']') {
+            str.charAt(pos[0]++);
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        return a;
+    }
+}
diff --git a/src/misc/src/jscl/text/VariableParser.java b/src/misc/src/jscl/text/VariableParser.java
new file mode 100644
index 00000000..c80ca9f0
--- /dev/null
+++ b/src/misc/src/jscl/text/VariableParser.java
@@ -0,0 +1,27 @@
+package jscl.text;
+
+import jscl.math.Variable;
+
+public class VariableParser extends Parser {
+    public static final Parser parser=new VariableParser();
+
+    private VariableParser() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        Variable v;
+        try {
+            v=(Variable)OperatorParser.parser.parse(str,pos);
+        } catch (ParseException e) {
+            try {
+                v=(Variable)FunctionParser.parser.parse(str,pos);
+            } catch (ParseException e2) {
+                try {
+                    v=(Variable)ConstantParser.parser.parse(str,pos);
+                } catch (ParseException e3) {
+                    throw e3;
+                }
+            }
+        }
+        return v;
+    }
+}
diff --git a/src/misc/src/jscl/text/VectorParser.java b/src/misc/src/jscl/text/VectorParser.java
new file mode 100644
index 00000000..2f7b8e06
--- /dev/null
+++ b/src/misc/src/jscl/text/VectorParser.java
@@ -0,0 +1,49 @@
+package jscl.text;
+
+import java.util.ArrayList;
+import java.util.List;
+import jscl.math.Generic;
+import jscl.math.JSCLVector;
+import jscl.util.ArrayUtils;
+
+public class VectorParser extends Parser {
+    public static final Parser parser=new VectorParser();
+
+    private VectorParser() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        int pos0=pos[0];
+        List l=new ArrayList();
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && str.charAt(pos[0])=='{') {
+            str.charAt(pos[0]++);
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        try {
+            Generic a=(Generic)ExpressionParser.parser.parse(str,pos);
+            l.add(a);
+        } catch (ParseException e) {
+            pos[0]=pos0;
+            throw e;
+        }
+        while(true) {
+            try {
+                Generic a=(Generic)CommaAndExpression.parser.parse(str,pos);
+                l.add(a);
+            } catch (ParseException e) {
+                break;
+            }
+        }
+        skipWhitespaces(str,pos);
+        if(pos[0]<str.length() && str.charAt(pos[0])=='}') {
+            str.charAt(pos[0]++);
+        } else {
+            pos[0]=pos0;
+            throw new ParseException();
+        }
+        Generic element[]=(Generic[])ArrayUtils.toArray(l,new Generic[l.size()]);
+        return new JSCLVector(element);
+    }
+}
diff --git a/src/misc/src/jscl/text/VectorVariableParser.java b/src/misc/src/jscl/text/VectorVariableParser.java
new file mode 100644
index 00000000..c6603e5e
--- /dev/null
+++ b/src/misc/src/jscl/text/VectorVariableParser.java
@@ -0,0 +1,20 @@
+package jscl.text;
+
+import jscl.math.JSCLVector;
+import jscl.math.VectorVariable;
+
+public class VectorVariableParser extends Parser {
+    public static final Parser parser=new VectorVariableParser();
+
+    private VectorVariableParser() {}
+
+    public Object parse(String str, int pos[]) throws ParseException {
+        JSCLVector v;
+        try {
+            v=(JSCLVector)VectorParser.parser.parse(str,pos);
+        } catch (ParseException e) {
+            throw e;
+        }
+        return new VectorVariable(v);
+    }
+}
diff --git a/src/misc/src/jscl/util/ArrayComparator.java b/src/misc/src/jscl/util/ArrayComparator.java
new file mode 100644
index 00000000..56cf1aec
--- /dev/null
+++ b/src/misc/src/jscl/util/ArrayComparator.java
@@ -0,0 +1,23 @@
+package jscl.util;
+
+import java.util.Comparator;
+
+public class ArrayComparator implements Comparator {
+    public static final Comparator comparator=new ArrayComparator();
+
+    private ArrayComparator() {}
+
+    public int compare(Comparable co1[], Comparable co2[]) {
+        if(co1.length<co2.length) return -1;
+        else if(co1.length>co2.length) return 1;
+        for(int i=co1.length-1;i>=0;i--) {
+            if(co1[i].compareTo(co2[i])<0) return -1;
+            else if(co1[i].compareTo(co2[i])>0) return 1;
+        }
+        return 0;
+    }
+
+    public int compare(Object o1, Object o2) {
+        return compare((Comparable[])o1,(Comparable[])o2);
+    }
+}
diff --git a/src/misc/src/jscl/util/ArrayUtils.java b/src/misc/src/jscl/util/ArrayUtils.java
new file mode 100644
index 00000000..78cf21a5
--- /dev/null
+++ b/src/misc/src/jscl/util/ArrayUtils.java
@@ -0,0 +1,112 @@
+package jscl.util;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.RandomAccess;
+
+public class ArrayUtils {
+    private ArrayUtils() {}
+
+    public static Object[] concat(Object o1[], Object o2[], Object res[]) {
+        System.arraycopy(o1,0,res,0,o1.length);
+        System.arraycopy(o2,0,res,o1.length,o2.length);
+        return res;
+    }
+
+    public static Object[] toArray(List list, Object res[]) {
+//      return list.toArray(res);
+        int n=list.size();
+        for(int i=0;i<n;i++) res[i]=list.get(i);
+        return res;
+    }
+
+    public static int[] toArray(List list, int res[]) {
+        int n=list.size();
+        for(int i=0;i<n;i++) res[i]=((Integer)list.get(i)).intValue();
+        return res;
+    }
+
+    public static List list(Collection collection) {
+//      List list=new ArrayList(collection);
+        List list=new ArrayList();
+        Iterator it=collection.iterator();
+        while(it.hasNext()) list.add(it.next());
+        return list;
+    }
+
+    public static String toString(Object obj[]) {
+        StringBuffer buffer=new StringBuffer();
+        buffer.append("{");
+        for(int i=0;i<obj.length;i++) {
+            buffer.append(obj[i]).append(i<obj.length-1?", ":"");
+        }
+        buffer.append("}");
+        return buffer.toString();
+    }
+
+    private static final int BINARYSEARCH_THRESHOLD   = 5000;
+
+    public static int binarySearch(List list, Object key) {
+        if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
+            return indexedBinarySearch(list, key);
+        else
+            return iteratorBinarySearch(list, key);
+    }
+
+    private static int indexedBinarySearch(List list, Object key) {
+        int low = 0;
+        int high = list.size()-1;
+
+        while (low <= high) {
+            int mid = (low + high) >> 1;
+            Object midVal = list.get(mid);
+            int cmp = ((Comparable)midVal).compareTo(key);
+
+            if (cmp < 0)
+                low = mid + 1;
+            else if (cmp > 0)
+                high = mid - 1;
+            else
+                return mid; // key found
+        }
+        return -(low + 1);  // key not found
+    }
+
+    private static int iteratorBinarySearch(List list, Object key) {
+        int low = 0;
+        int high = list.size()-1;
+        ListIterator i = list.listIterator();
+
+        while (low <= high) {
+            int mid = (low + high) >> 1;
+            Object midVal = get(i, mid);
+            int cmp = ((Comparable)midVal).compareTo(key);
+
+            if (cmp < 0)
+                low = mid + 1;
+            else if (cmp > 0)
+                high = mid - 1;
+            else
+                return mid; // key found
+        }
+        return -(low + 1);  // key not found
+    }
+
+    private static Object get(ListIterator i, int index) {
+        Object obj = null;
+        int pos = i.nextIndex();
+        if (pos <= index) {
+            do {
+                obj = i.next();
+            } while (pos++ < index);
+        } else {
+            do {
+                obj = i.previous();
+            } while (--pos > index);
+        }
+        return obj;
+    }
+}