funcRefsMap) {
+ InstructionHandle startPos = arg1.bytecodeGen(clsName, mg, cp, factory, il, argsMap, argsStartPos, funcRefsMap);
+ TYPE ty = Utils.getConvertedType(arg1.getType(), arg2.getType());
+ BytecodeUtils.typeCast(il, arg1.getType(), ty);
+ arg2.bytecodeGen(clsName, mg, cp, factory, il, argsMap, argsStartPos, funcRefsMap);
+ BytecodeUtils.typeCast(il, arg2.getType(), ty);
+ if(ty == TYPE.DOUBLE)
+ il.append(InstructionConstants.DDIV);
+ else if(ty == TYPE.INT)
+ il.append(InstructionConstants.IDIV);
+ else if(ty == TYPE.LONG)
+ il.append(InstructionConstants.LDIV);
+ else if(ty == TYPE.FLOAT)
+ il.append(InstructionConstants.FDIV);
+ else
+ il.append(InstructionConstants.IDIV);
+ return startPos;
+ }
+ @Override
+ public void updateLabel() {
+ label = SymPrinting.addParenthsesIfNeeded(arg1, this)
+ + "/" +
+ SymPrinting.addParenthsesIfNeeded2(arg2, this);
+ sortKey = arg1.getSortKey()+arg2.getSortKey();
+ }
}
diff --git a/src/symjava/symbolic/Exp.java b/src/symjava/symbolic/Exp.java
index 6927dbd..7954d96 100644
--- a/src/symjava/symbolic/Exp.java
+++ b/src/symjava/symbolic/Exp.java
@@ -6,7 +6,8 @@
public class Exp extends Pow {
public Exp(Expr arg) {
super(SymMath.E, arg);
- String displayExp = String.format("{%s}", this.arg2);
+ //String displayExp = String.format("{%s}", this.arg2);
+ String displayExp = String.format("%s", this.arg2);
if(arg instanceof SymReal) {
SymReal realExp = (SymReal)arg;
if(realExp.isInteger()) {
@@ -15,9 +16,14 @@ public Exp(Expr arg) {
//if(realExp.isNegative())
// displayExp = "{"+displayExp+"}";
}
- label = "e^" + displayExp + "";
+ //label = "e^" + displayExp + "";
+ label = "pow(e," + displayExp + ")";
sortKey = "epower"+String.valueOf(displayExp);
}
+
+ public String toString() {
+ return label;
+ }
public static Expr simplifiedIns(Expr expr) {
return new Exp(expr);
diff --git a/src/symjava/symbolic/Expr.java b/src/symjava/symbolic/Expr.java
index 8aec5c4..3115e48 100644
--- a/src/symjava/symbolic/Expr.java
+++ b/src/symjava/symbolic/Expr.java
@@ -1,24 +1,30 @@
package symjava.symbolic;
-import java.math.BigInteger;
import java.util.List;
+import java.util.Map;
+import lambdacloud.core.lang.LCAssign;
+import lambdacloud.core.lang.LCDevice;
import symjava.logic.And;
import symjava.logic.Not;
import symjava.logic.Or;
import symjava.logic.Xor;
-import symjava.relational.Ge;
-import symjava.relational.Relation;
import symjava.symbolic.utils.Utils;
+import com.sun.org.apache.bcel.internal.generic.ConstantPoolGen;
+import com.sun.org.apache.bcel.internal.generic.InstructionFactory;
+import com.sun.org.apache.bcel.internal.generic.InstructionHandle;
+import com.sun.org.apache.bcel.internal.generic.InstructionList;
+import com.sun.org.apache.bcel.internal.generic.MethodGen;
+
abstract public class Expr implements Cloneable {
/**
- * Label(or name) of an expression(Symbol, Func,...)
+ * Label(or name) of an expression
*/
protected String label = null;
/**
- * A string used to sort terms in an expression
+ * A string used to sort the terms in an expression
*/
protected String sortKey = null;
@@ -26,25 +32,37 @@ abstract public class Expr implements Cloneable {
* Number of operations for simplifying an expression
*/
public int simplifyOpNum = 0;
-
+
+ /**
+ * Return true if simplify() is called
+ */
public boolean isSimplified = false;
+ /**
+ * Simplify the expression
+ * @return
+ */
public abstract Expr simplify();
+ /**
+ * Return true if two expressions are equal in the sense of mathematics
+ * @param other
+ * @return
+ */
public abstract boolean symEquals(Expr other);
/**
- * Return the arguments of the expr
+ * Return the arguments of the expression
* @return
*/
- public Expr[] args() { return new Expr[0]; }
+ public abstract Expr[] args();// { return new Expr[0]; }
/**
- * Derivative of expr
- * @param expr
+ * Derivative of the expression with respect to x
+ * @param x
* @return
*/
- public abstract Expr diff(Expr expr);
+ public abstract Expr diff(Expr x);
/**
* Functional derivative of f with respect to df
@@ -93,12 +111,20 @@ public boolean isAbstract() {
}
/**
- * Return the string expression
+ * Return the string representation of the expression
*/
public String toString() {
return label;
}
+ /**
+ * Return the LaTex representation of the expression
+ * @return
+ */
+ public String toLaTex() {
+ return label;
+ }
+
/**
* Set the label(or name) of the expression
* @param label
@@ -118,7 +144,7 @@ public String getLabel() {
}
/**
- * Set a string key for arranging terms in an expression
+ * Set a string key for sorting the terms in the expression
* @param sortKey
* @return
*/
@@ -128,7 +154,7 @@ public Expr setSortKey(String sortKey) {
}
/**
- * Get the string key used to arrange terms in an expression
+ * Get the string key used to sort the terms in the expression
* @param sortKey
* @return
*/
@@ -161,7 +187,7 @@ public Expr setAsSimplified() {
}
/**
- * Operator overload support:
+ * Operator overloading support:
* Expr a = 5;
*
* @param v
@@ -180,7 +206,7 @@ public static Expr valueOf(double v) {
return new SymDouble(v);
}
/**
- * Operator overload support:
+ * Operator overloading support:
* a+b
* @param other
* @return
@@ -212,9 +238,29 @@ public Expr add(double other) {
public Expr addRev(double other) {
return Add.simplifiedIns(new SymDouble(other), this);
}
-
/**
- * Operator overload support:
+ * Operator overload support for Groovy:
+ * a+b
+ * @param other
+ * @return
+ */
+ public Expr plus(Expr other) {
+ return Add.simplifiedIns(this, other);
+ }
+ public Expr plus(int other) {
+ return Add.simplifiedIns(this, new SymInteger(other));
+ }
+ public Expr plus(long other) {
+ return Add.simplifiedIns(this, new SymLong(other));
+ }
+ public Expr plus(float other) {
+ return Add.simplifiedIns(this, new SymFloat(other));
+ }
+ public Expr plus(double other) {
+ return Add.simplifiedIns(this, new SymDouble(other));
+ }
+ /**
+ * Operator overloading support:
* a-b
* @param other
* @return
@@ -246,9 +292,29 @@ public Expr subtract(double other) {
public Expr subtractRev(double other) {
return Subtract.simplifiedIns(new SymDouble(other), this);
}
-
/**
- * Operator overload support:
+ * Operator overload support for Groovy:
+ * a-b
+ * @param other
+ * @return
+ */
+ public Expr minus(Expr other) {
+ return Subtract.simplifiedIns(this, other);
+ }
+ public Expr minus(int other) {
+ return Subtract.simplifiedIns(this, new SymInteger(other));
+ }
+ public Expr minus(long other) {
+ return Subtract.simplifiedIns(this, new SymLong(other));
+ }
+ public Expr minus(float other) {
+ return Subtract.simplifiedIns(this, new SymFloat(other));
+ }
+ public Expr minus(double other) {
+ return Subtract.simplifiedIns(this, new SymDouble(other));
+ }
+ /**
+ * Operator overloading support:
* a*b
* @param other
* @return
@@ -282,7 +348,7 @@ public Expr multiplyRev(double other) {
}
/**
- * Operator overload support:
+ * Operator overloading support:
* a/b
* @param other
* @return
@@ -314,9 +380,29 @@ public Expr divide(double other) {
public Expr divideRev(double other) {
return Divide.simplifiedIns(new SymDouble(other), this);
}
-
/**
- * Operator overload support:
+ * Operator overload support for Groovy:
+ * a/b
+ * @param other
+ * @return
+ */
+ public Expr div(Expr other) {
+ return Divide.simplifiedIns(this, other);
+ }
+ public Expr divi(int other) {
+ return Divide.simplifiedIns(this, new SymInteger(other));
+ }
+ public Expr div(long other) {
+ return Divide.simplifiedIns(this, new SymLong(other));
+ }
+ public Expr div(float other) {
+ return Divide.simplifiedIns(this, new SymFloat(other));
+ }
+ public Expr div(double other) {
+ return Divide.simplifiedIns(this, new SymDouble(other));
+ }
+ /**
+ * Operator overloading support:
* -a
*
*/
@@ -374,7 +460,7 @@ public Expr xor(Expr other) {
}
// /**
-// * TODO We cannot use the comparison operator overload in java-oo for our use case
+// * TODO We cannot use the comparison Operator overloading in java-oo for our use case
// * @param other
// * @return
// */
@@ -414,7 +500,7 @@ public Expr subs(Expr from, double to) {
return subs(from, new SymDouble(to));
}
- protected Expr clone() {
+ public Expr clone() {
try {
return (Expr) super.clone();
} catch (CloneNotSupportedException e) {
@@ -436,4 +522,124 @@ public int hashCode() {
public boolean equals(Object obj) {
return this.label.equals(((Expr)obj).label);
}
+
+////////////////////////////////////////////////////////////////////////////
+// /**
+// * Assign the result of evaluating an expression to a local variable
+// * when compiling. The local variable must be a symbol which is declared
+// * as a local variable.
+// *
+// * The call of this function can be understand as
+// * Symbol symLocal; //Declared somewhere
+// * symLocal = this;
+// *
+// *
+// * Note: The name of a symbol is a global name. Make sure you don't have
+// * two symbols with the same name, otherwise they are treated as the same
+// * symbol or local variable in compiled code.
+// *
+// * @param symLocal A symbol declared as a local variable
+// * @return An instance of operator OPAsign
+// */
+// public Expr assignTo(Symbol symLocal) {
+// return new OPAsign(symLocal, this);
+// }
+
+ public InstructionHandle bytecodeGen(String clsName, MethodGen mg,
+ ConstantPoolGen cp, InstructionFactory factory,
+ InstructionList il, Map argsMap, int argsStartPos,
+ Map funcRefsMap) {
+ throw new UnsupportedOperationException();//il.append(InstructionConstants.NOP);
+ }
+
+
+ /**
+ * Reset the compile flags for an expression.
+ *
+ * For example, a matrix is defined and stored to new a local variable when it is referenced
+ * at the first time. The following references of the matrix just load the local variable.
+ * By calling this function, the state is reset to define a new local variable.
+ */
+ public void bytecodeGenReset() {
+
+ }
+
+ public enum TYPE {INT, LONG, FLOAT, DOUBLE, BOOLEAN, BYTE, CHAR, SHORT, VOID,
+ MATRIX, VECTOR, TENSOR};
+
+ public abstract TypeInfo getTypeInfo();
+
+ public TYPE getType() {
+ return getTypeInfo().type;
+ }
+
+ public Expr assign(Expr expr) {
+ return new LCAssign(this, expr);
+ }
+
+ public Expr assign(double val) {
+ return new LCAssign(this, Expr.valueOf(val));
+ }
+
+ public Expr assign(int val) {
+ return new LCAssign(this, Expr.valueOf(val));
+ }
+/////////////////////////////////////////////////////////////////////////
+
+ protected LCDevice device = null;
+ public Expr runOn(LCDevice dev) {
+ device = dev;
+ return this;
+ }
+
+ public LCDevice getDevice() {
+ return device;
+ }
+
+ /**
+ * Set the argument of the current expression
+ * Depends on the specific implementation
+ *
+ * @param index The position of the argument
+ * @param arg The expression of the argument
+ * @return
+ */
+ public Expr setArg(int index, Expr arg) {
+ throw new UnsupportedOperationException();
+ }
+
+ abstract public void updateLabel();
+
+ /**
+ * Parent expression, for example: a sub-matrix or sub-vector has a parent
+ */
+ public Expr getParent() {
+ throw new UnsupportedOperationException();
+ }
+
+ /**
+ * Return the dimension of a vector
+ * @return
+ */
+ public int dim() {
+ throw new UnsupportedOperationException();
+ }
+
+ /**
+ * return the dimension of a matrix or tensor
+ * @return
+ */
+ public int[] dims() {
+ throw new UnsupportedOperationException();
+ }
+
+ /**
+ * return the element at index
+ * @param index
+ * @return
+ */
+ public Expr get(int index) {
+ throw new UnsupportedOperationException();
+ }
}
+
diff --git a/src/symjava/symbolic/Func.java b/src/symjava/symbolic/Func.java
index 442fe47..3e7eabf 100644
--- a/src/symjava/symbolic/Func.java
+++ b/src/symjava/symbolic/Func.java
@@ -16,6 +16,11 @@ public class Func extends NaryOp {
/**
* Construct an abstract function
+ * Note: For an abstract function with only one argument, define it by
+ * passing an array for the second parameter
+ *
+ * Func f = new Func("F", new Expr[]{Symbol.x}); // F(x)
+ *
* @param name
* @param args
*/
@@ -26,6 +31,13 @@ public Func(String name, Expr ...args) {
this.sortKey = label;
}
+ /**
+ * Construct a function with expression expr
+ * For example:
+ * Func f = new Func("F", Symbol.x); // F(x)=x
+ * @param name
+ * @param expr
+ */
public Func(String name, Expr expr) {
super(new Expr[] {expr});
//Extract free variables from expr
@@ -146,6 +158,11 @@ public Expr simplify() {
public boolean symEquals(Expr other) {
if(other instanceof Func) {
Func o = (Func)other;
+ //TODO support map(expr, [e1,e2,e3])
+ if(this.label.equals("_") && other.label.equals("_"))
+ return true;
+ if(this.label.equals("__") && other.label.equals("__"))
+ return true;
Boolean rlt = Utils.symCompareNull(this.expr, o.expr);
if(rlt != null && rlt == false)
return false;
@@ -178,4 +195,15 @@ public void flattenMultiply(List outList) {
outList.add(this);
}
+ @Override
+ public TypeInfo getTypeInfo() {
+ return expr.getTypeInfo();
+ }
+
+ @Override
+ public void updateLabel() {
+ // TODO Auto-generated method stub
+
+ }
+
}
diff --git a/src/symjava/symbolic/Infinity.java b/src/symjava/symbolic/Infinity.java
index 26f2c90..353fe21 100644
--- a/src/symjava/symbolic/Infinity.java
+++ b/src/symjava/symbolic/Infinity.java
@@ -1,14 +1,17 @@
package symjava.symbolic;
+/**
+ * A symbol represents infinity
+ *
+ */
public class Infinity extends Expr {
public Infinity() {
- this.label = "oo";
- this.sortKey = label;
+ updateLabel();
}
@Override
public Expr diff(Expr expr) {
- return null;
+ throw new UnsupportedOperationException();
}
@Override
@@ -20,4 +23,21 @@ public Expr simplify() {
public boolean symEquals(Expr other) {
return false;
}
+
+ @Override
+ public Expr[] args() {
+ return null;
+ }
+
+ @Override
+ public TypeInfo getTypeInfo() {
+ //TODO
+ return null;
+ }
+
+ @Override
+ public void updateLabel() {
+ this.label = "oo";
+ this.sortKey = label;
+ }
}
diff --git a/src/symjava/symbolic/Integrate.java b/src/symjava/symbolic/Integrate.java
index c00f333..b13cbdb 100644
--- a/src/symjava/symbolic/Integrate.java
+++ b/src/symjava/symbolic/Integrate.java
@@ -17,17 +17,20 @@ public class Integrate extends Expr {
public Expr integrand = null;
public Domain domain = null;
+ /**
+ * \int_{domain}{integrand}
+ *
+ * @param integrand
+ * @param domain
+ */
public Integrate(Expr integrand, Domain domain) {
this.integrand = integrand;
this.domain = domain;
- String postfix = "d" + Utils.joinLabels(domain.getCoordVars(),"d");
- if(domain instanceof Interval) {
- Interval o = (Interval)domain;
- this.label = "\\int_{"+o.getStart()+"}^{"+o.getEnd()+"}{"+integrand+"}" + postfix;
- }
- else
- this.label = "\\int_{"+domain+"}{"+integrand+"}" + postfix;
- this.sortKey = integrand.toString()+domain.toString();
+ updateLabel();
+ }
+
+ public String toString() {
+ return "integrate("+integrand+","+domain+")";
}
public static Expr apply(Expr integrand, Domain domain) {
@@ -63,6 +66,14 @@ public Integrate changeOfVars(Transformation trans) {
this.domain.transform(this.domain.getLabel()+"T", trans));
}
+ /**
+ * Change of Variables for the integration
+ *
+ * @param subsList
+ * @param jac
+ * @param target
+ * @return
+ */
public Integrate changeOfVars(List subsList, Expr jac, Domain target) {
Expr tmp = this.integrand;
for(ExprPair p : subsList) {
@@ -99,4 +110,27 @@ public boolean isMultipleIntegral() {
return this.domain.getConstraint() == null;
}
+ @Override
+ public Expr[] args() {
+ //DOTO
+ return integrand.args();
+ }
+
+ @Override
+ public TypeInfo getTypeInfo() {
+ return null;
+ }
+
+ @Override
+ public void updateLabel() {
+ String postfix = "d" + Utils.joinLabels(domain.getCoordVars(),"d");
+ if(domain instanceof Interval) {
+ Interval o = (Interval)domain;
+ this.label = "\\int_{"+o.getStart()+"}^{"+o.getEnd()+"}{"+integrand+"}" + postfix;
+ }
+ else
+ this.label = "\\int_{"+domain+"}{"+integrand+"}" + postfix;
+ this.sortKey = integrand.toString()+domain.toString();
+ }
+
}
diff --git a/src/symjava/symbolic/Limit.java b/src/symjava/symbolic/Limit.java
index 150bd70..b924000 100644
--- a/src/symjava/symbolic/Limit.java
+++ b/src/symjava/symbolic/Limit.java
@@ -1,5 +1,46 @@
package symjava.symbolic;
-public class Limit {
+/**
+ * TODO
+ *
+ *
+ */
+public class Limit extends Expr {
+
+ @Override
+ public Expr simplify() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public boolean symEquals(Expr other) {
+ // TODO Auto-generated method stub
+ return false;
+ }
+
+ @Override
+ public Expr diff(Expr expr) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Expr[] args() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public TypeInfo getTypeInfo() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public void updateLabel() {
+ // TODO Auto-generated method stub
+
+ }
}
diff --git a/src/symjava/symbolic/Log.java b/src/symjava/symbolic/Log.java
index 96ad21f..e3e4014 100644
--- a/src/symjava/symbolic/Log.java
+++ b/src/symjava/symbolic/Log.java
@@ -1,9 +1,26 @@
package symjava.symbolic;
+import java.util.Map;
+
+import com.sun.org.apache.bcel.internal.Constants;
+import com.sun.org.apache.bcel.internal.generic.ConstantPoolGen;
+import com.sun.org.apache.bcel.internal.generic.InstructionFactory;
+import com.sun.org.apache.bcel.internal.generic.InstructionHandle;
+import com.sun.org.apache.bcel.internal.generic.InstructionList;
+import com.sun.org.apache.bcel.internal.generic.MethodGen;
+import com.sun.org.apache.bcel.internal.generic.ObjectType;
+import com.sun.org.apache.bcel.internal.generic.Type;
+
import symjava.math.SymMath;
import symjava.symbolic.arity.BinaryOp;
import symjava.symbolic.utils.Utils;
+/**
+ * logarithm
+ *
+ * log(A): if A is a matrix do element wise log
+ *
+ */
public class Log extends BinaryOp {
/**
@@ -12,8 +29,8 @@ public class Log extends BinaryOp {
*/
public Log(Expr expr) {
super(SymMath.E, expr);
- label = "log(" + expr + ")";
- sortKey = label;
+ updateLabel();
+
}
/**
@@ -27,6 +44,13 @@ public Log(Expr base, Expr expr) {
sortKey = label;
}
+ public String toString() {
+ if(!arg1.symEquals(SymMath.E))
+ return "log(" + arg1 + "," + arg2 + ")";
+ else
+ return label;
+ }
+
public static Expr simplifiedIns(Expr base, Expr expr) {
if(base instanceof SymReal && expr instanceof SymReal) {
return new SymDouble(
@@ -61,9 +85,47 @@ public Expr simplify() {
return this;
}
+ @Override
+ public Expr subs(Expr from, Expr to) {
+ if(Utils.symCompare(this, from))
+ return to;
+ Expr sl = arg1.subs(from, to);
+ Expr sr = arg2.subs(from, to);
+ if(sl == arg1 && sr == arg2)
+ return this;
+ return new Log(sl, sr);
+ }
+
@Override
public boolean symEquals(Expr other) {
return false;
}
+
+ public InstructionHandle bytecodeGen(String clsName, MethodGen mg,
+ ConstantPoolGen cp, InstructionFactory factory,
+ InstructionList il, Map argsMap, int argsStartPos,
+ Map funcRefsMap) {
+ InstructionHandle startPos = arg1.bytecodeGen(clsName, mg, cp, factory, il, argsMap, argsStartPos, funcRefsMap);
+ arg2.bytecodeGen(clsName, mg, cp, factory, il, argsMap, argsStartPos, funcRefsMap);
+ if(arg2.getType() == TYPE.MATRIX || arg2.getType() == TYPE.VECTOR) {
+ il.append(factory.createInvoke("symjava.symbolic.utils.BytecodeOpSupport", "log",
+ new ObjectType("Jama.Matrix"),
+ new Type[] { Type.DOUBLE, new ObjectType("Jama.Matrix") },
+ Constants.INVOKESTATIC));
+ } else {
+ il.append(factory.createInvoke("symjava.symbolic.utils.BytecodeSupport", "log",
+ Type.DOUBLE, new Type[] { Type.DOUBLE, Type.DOUBLE }, Constants.INVOKESTATIC));
+ }
+
+ return startPos;
+ }
+ @Override
+ public void updateLabel() {
+ if(arg1.symEquals(SymMath.E))
+ label = "log(" + arg2 + ")";
+ else
+ label = "log_{"+arg1+"}(" + arg2 + ")";
+ sortKey = label;
+ }
}
diff --git a/src/symjava/symbolic/Log10.java b/src/symjava/symbolic/Log10.java
index cb99c1a..1b4b99f 100644
--- a/src/symjava/symbolic/Log10.java
+++ b/src/symjava/symbolic/Log10.java
@@ -1,14 +1,21 @@
package symjava.symbolic;
+
public class Log10 extends Log {
public Log10(Expr expr) {
super(Expr.valueOf(10), expr);
- label = "log10(" + expr + ")";
- sortKey = label;
+ updateLabel();
}
public static Expr simplifiedIns(Expr expr) {
return new Log10(expr);
}
+
+ @Override
+ public void updateLabel() {
+ label = "log10(" + arg2 + ")";
+ sortKey = label;
+ }
+
}
diff --git a/src/symjava/symbolic/Log2.java b/src/symjava/symbolic/Log2.java
index e297b2e..d057f9f 100644
--- a/src/symjava/symbolic/Log2.java
+++ b/src/symjava/symbolic/Log2.java
@@ -4,11 +4,16 @@ public class Log2 extends Log {
public Log2(Expr expr) {
super(Expr.valueOf(2), expr);
- label = "log2(" + expr + ")";
- sortKey = label;
+ updateLabel();
}
-
+
public static Expr simplifiedIns(Expr expr) {
return new Log2(expr);
}
+
+ @Override
+ public void updateLabel() {
+ label = "log2(" + arg2 + ")";
+ sortKey = label;
+ }
}
diff --git a/src/symjava/symbolic/Matrix.java b/src/symjava/symbolic/Matrix.java
new file mode 100644
index 0000000..d041f9b
--- /dev/null
+++ b/src/symjava/symbolic/Matrix.java
@@ -0,0 +1,158 @@
+package symjava.symbolic;
+
+import java.util.Map;
+
+import com.sun.org.apache.bcel.internal.Constants;
+import com.sun.org.apache.bcel.internal.generic.ALOAD;
+import com.sun.org.apache.bcel.internal.generic.ASTORE;
+import com.sun.org.apache.bcel.internal.generic.ArrayType;
+import com.sun.org.apache.bcel.internal.generic.ConstantPoolGen;
+import com.sun.org.apache.bcel.internal.generic.DSTORE;
+import com.sun.org.apache.bcel.internal.generic.InstructionConstants;
+import com.sun.org.apache.bcel.internal.generic.InstructionFactory;
+import com.sun.org.apache.bcel.internal.generic.InstructionHandle;
+import com.sun.org.apache.bcel.internal.generic.InstructionList;
+import com.sun.org.apache.bcel.internal.generic.LocalVariableGen;
+import com.sun.org.apache.bcel.internal.generic.MethodGen;
+import com.sun.org.apache.bcel.internal.generic.NEW;
+import com.sun.org.apache.bcel.internal.generic.ObjectType;
+import com.sun.org.apache.bcel.internal.generic.PUSH;
+import com.sun.org.apache.bcel.internal.generic.Type;
+
+import symjava.matrix.ExprMatrix;
+import symjava.symbolic.Expr.TYPE;
+
+public class Matrix extends Tensor {
+ public int nRowStart;
+ public int nColStart;
+ public int nRow;
+ public int nCol;
+ public Matrix parent;
+
+ protected int indexLVT = -1;
+ public Matrix(String name, int nRow, int nCol) {
+ super(name);
+ nRowStart = 0;
+ nColStart = 0;
+ this.nRow = nRow;
+ this.nCol = nCol;
+ }
+
+ public Matrix(Matrix parent, int nRowStart, int nColStart, int nRow, int nCol) {
+ super(parent.label+"_"+nRowStart+"_"+nColStart+"_"+nRow+"_"+nCol);
+ this.nRowStart = nRowStart;
+ this.nColStart = nColStart;
+ this.nRow = nRow;
+ this.nCol = nCol;
+ this.parent = parent;
+ }
+
+ public Matrix(Matrix parent, String name, int nRowStart, int nColStart, int nRow, int nCol) {
+ super(name);
+ this.nRowStart = nRowStart;
+ this.nColStart = nColStart;
+ this.nRow = nRow;
+ this.nCol = nCol;
+ this.parent = parent;
+ }
+
+
+ public ExprMatrix split(int nRowBlock, int nColBlock) {
+ int m = nRow/nRowBlock;
+ if(nRow%nRowBlock > 0)
+ m = (nRow+(nRowBlock-nRow%nRowBlock))/nRowBlock;
+ int n = nCol/nColBlock;
+ if(nCol%nColBlock > 0)
+ n = (nCol+(nColBlock-nCol%nColBlock))/nColBlock;
+ int last_m = nRow%m==0?m:nRow%m;
+ int last_n = nCol%n==0?n:nCol%n;
+/* System.out.println(m);
+ System.out.println(n);
+ System.out.println(last_m);
+ System.out.println(last_n);
+*/ Expr[][] items = new Expr[nRowBlock][nColBlock];
+ for(int i=0; i argsMap, int argsStartPos,
+ Map funcRefsMap) {
+ // Create an instance of Jama.Matrix and store it to local variable index with this.indexLVT
+ if(indexLVT == -1) {
+ //jama.Matrix l_m = null;
+ LocalVariableGen lg = mg.addLocalVariable("l_"+getLabel(),
+ new ObjectType("Jama.Matrix"), null, null);
+ indexLVT = lg.getIndex();
+// il.append(InstructionConstants.ACONST_NULL);
+// lg.setStart(il.append(new DSTORE(idx)));
+
+ // First time touch the matrix, declare a local reference of Java.Matrix
+ il.append(new NEW(cp.addClass("Jama.Matrix")));
+ il.append(InstructionConstants.DUP);
+
+ //prepare argument: double[] vals
+ //il.append(new ALOAD(argsStartPos));
+ //il.append(new PUSH(cp, argsMap.get(this.label)));
+ //il.append(InstructionConstants.DALOAD); //Load double from array
+ //////////////il.append(new ALOAD(argsMap.get(this.label))); //Load reference from local variable (from function arguments)
+ //il.append(new ALOAD(1)); //Load reference from local variable (from function arguments)
+
+ il.append(new ALOAD(argsStartPos));
+ il.append(new PUSH(cp, argsMap.get(this.label)));
+ il.append(InstructionConstants.AALOAD); //Load double from array
+
+ //prepare argument: double m - number of rows
+ il.append(new PUSH(cp, nRow));
+ il.append(factory.createInvoke("Jama.Matrix", "",
+ Type.VOID, new Type[] { new ArrayType(Type.DOUBLE, 1), Type.INT },
+ Constants.INVOKESPECIAL));
+
+ //jama.Matrix l_m = new jama.Matrix(args[], nRow);
+ lg.setStart(il.append(new ASTORE(indexLVT)));
+ }
+ // Retrun the local reference of the matrix
+ return il.append(new ALOAD(indexLVT));
+
+ //For test purpose
+ //il.append(new ALOAD(indexLVT));
+ //il.append(new PUSH(cp, 1.0));
+ //return il.append(InstructionConstants.DRETURN);
+ }
+
+ @Override
+ public TypeInfo getTypeInfo() {
+ TypeInfo ti = new TypeInfo(TYPE.MATRIX, new int[2]);
+ ti.dim[0] = this.nRow;
+ ti.dim[1] = this.nCol;
+ return ti;
+ }
+
+ public void bytecodeGenReset() {
+ this.indexLVT = -1;
+ }
+
+ @Override
+ public Expr getParent() {
+ return this.parent;
+ }
+
+ public static void main(String[] args) {
+ Matrix m = new Matrix("A",6,8);
+ ExprMatrix sm = m.split(3, 2);
+ System.out.println(sm);
+
+ }
+}
diff --git a/src/symjava/symbolic/Multiply.java b/src/symjava/symbolic/Multiply.java
index 0cacfe8..acb1e38 100644
--- a/src/symjava/symbolic/Multiply.java
+++ b/src/symjava/symbolic/Multiply.java
@@ -2,10 +2,26 @@
import java.util.ArrayList;
import java.util.List;
+import java.util.Map;
+import symjava.symbolic.Expr.TYPE;
import symjava.symbolic.arity.BinaryOp;
+import symjava.symbolic.utils.BytecodeUtils;
import symjava.symbolic.utils.Utils;
+import com.sun.org.apache.bcel.internal.Constants;
+import com.sun.org.apache.bcel.internal.generic.ALOAD;
+import com.sun.org.apache.bcel.internal.generic.ArrayType;
+import com.sun.org.apache.bcel.internal.generic.ConstantPoolGen;
+import com.sun.org.apache.bcel.internal.generic.InstructionConstants;
+import com.sun.org.apache.bcel.internal.generic.InstructionFactory;
+import com.sun.org.apache.bcel.internal.generic.InstructionHandle;
+import com.sun.org.apache.bcel.internal.generic.InstructionList;
+import com.sun.org.apache.bcel.internal.generic.MethodGen;
+import com.sun.org.apache.bcel.internal.generic.ObjectType;
+import com.sun.org.apache.bcel.internal.generic.PUSH;
+import com.sun.org.apache.bcel.internal.generic.Type;
+
public class Multiply extends BinaryOp {
public Multiply(Expr l, Expr r) {
super(l, r);
@@ -17,14 +33,7 @@ public Multiply(Expr l, Expr r) {
arg1 = l;
arg2 = r;
}
- label = SymPrinting.addParenthsesIfNeeded(arg1, this)
- + "*" +
- SymPrinting.addParenthsesIfNeeded(arg2, this);
- if(this.isCoeffMulSymbol()) {
- sortKey = this.getSymbolTerm().getSortKey();//+this.getCoeffTerm().getSortKey();
- } else {
- sortKey = arg1.getSortKey()+arg2.getSortKey();
- }
+ updateLabel();
}
public static Expr shallowSimplifiedIns(Expr l, Expr r) {
@@ -69,19 +78,19 @@ else if(Symbol.C0.symEquals(l) || Symbol.C0.symEquals(r)) {
Pow lp = (Pow)l;
Pow rp = (Pow)r;
if(Utils.symCompare(lp.arg1, rp.arg1)) {
- return Pow.simplifiedIns( lp.arg1, lp.arg2+rp.arg2).setSimplifyOps(simOps).setAsSimplified();
+ return Pow.simplifiedIns( lp.arg1, lp.arg2.add(rp.arg2)).setSimplifyOps(simOps).setAsSimplified();
} else if(lp.arg2 == rp.arg2) {
return Pow.simplifiedIns( simplifiedIns(lp.arg1, rp.arg1), lp.arg2).setSimplifyOps(simOps).setAsSimplified();
}
} else if(l instanceof Pow) {
Pow lp = (Pow)l;
if(Utils.symCompare(lp.arg1, r)) {
- return new Pow(lp.arg1, lp.arg2 + 1).setSimplifyOps(simOps).setAsSimplified();
+ return new Pow(lp.arg1, lp.arg2.add(1)).setSimplifyOps(simOps).setAsSimplified();
}
} else if(r instanceof Pow) {
Pow rp = (Pow)r;
if(Utils.symCompare(rp.arg1, l)) {
- return new Pow(rp.arg1, rp.arg2 + 1).setSimplifyOps(simOps).setAsSimplified();
+ return new Pow(rp.arg1, rp.arg2.add(1)).setSimplifyOps(simOps).setAsSimplified();
}
}
if(Utils.symCompare(l, r)) {
@@ -139,16 +148,20 @@ public Expr simplify() {
@Override
public void flattenAdd(List outList) {
- List list1 = new ArrayList();
- List list2 = new ArrayList();
- arg1.flattenAdd(list1);
- arg2.flattenAdd(list2);
- if(list1.size()==1 && list2.size()==1)
+ if(device != null) {
outList.add(this);
- else {
- for(Expr e1 : list1) {
- for(Expr e2 : list2) {
- outList.add( shallowSimplifiedIns(e1, e2) );
+ } else {
+ List list1 = new ArrayList();
+ List list2 = new ArrayList();
+ arg1.flattenAdd(list1);
+ arg2.flattenAdd(list2);
+ if(list1.size()==1 && list2.size()==1)
+ outList.add(this);
+ else {
+ for(Expr e1 : list1) {
+ for(Expr e2 : list2) {
+ outList.add( shallowSimplifiedIns(e1, e2) );
+ }
}
}
}
@@ -156,12 +169,104 @@ public void flattenAdd(List outList) {
@Override
public void flattenMultiply(List outList) {
- arg1.flattenMultiply(outList);
- arg2.flattenMultiply(outList);
+ if(device != null) {
+ outList.add(this);
+ } else {
+ arg1.flattenMultiply(outList);
+ arg2.flattenMultiply(outList);
+ }
}
public boolean symEquals(Expr other) {
//return Utils.flattenSortAndCompare(this, other);
return Utils.flattenSortAndCompare(this.simplify(), other.simplify());
}
+
+ @Override
+ public InstructionHandle bytecodeGen(String clsName, MethodGen mg,
+ ConstantPoolGen cp, InstructionFactory factory,
+ InstructionList il, Map argsMap, int argsStartPos,
+ Map funcRefsMap) {
+ InstructionHandle startPos = arg1.bytecodeGen(clsName, mg, cp, factory, il, argsMap, argsStartPos, funcRefsMap);
+ if(arg1.getType() == TYPE.MATRIX) {
+ arg2.bytecodeGen(clsName, mg, cp, factory, il, argsMap, argsStartPos, funcRefsMap);
+ if(arg2.getType() == TYPE.VECTOR) {
+ il.append(factory.createInvoke("Jama.Matrix", "times",
+ new ObjectType("Jama.Matrix"), new Type[] { new ObjectType("Jama.Matrix") },
+ //Type.getType(Jama.Matrix.class), new Type[] { Type.getType(Jama.Matrix.class) },
+ Constants.INVOKEVIRTUAL));
+/* Move the return part out of here to class CompileUtil
+ //Copy results to outAry
+ il.append(factory.createInvoke("Jama.Matrix", "getColumnPackedCopy",
+ new ArrayType(Type.DOUBLE,1), new Type[] {},
+ Constants.INVOKEVIRTUAL));
+ il.append(new PUSH(cp, 0));
+ il.append(InstructionConstants.ALOAD_1); //outAry (output buffer)
+ il.append(InstructionConstants.ILOAD_2); //outPos (start position of output buffer)
+ Vector x = (Vector)arg2;
+ il.append(new PUSH(cp, x.nDim));
+ //Call System.arraycopy(src, srcPos, dest, destPos, length);
+ il.append(factory.createInvoke("java.lang.System", "arraycopy",
+ Type.VOID, new Type[] { Type.OBJECT, Type.INT, Type.OBJECT, Type.INT, Type.INT },
+ Constants.INVOKESTATIC));
+*/
+ //test only
+ //il.append(new ALOAD(indexLVT));
+ //il.append(new PUSH(cp, 1.0));
+ //return il.append(InstructionConstants.DRETURN);
+
+ } else if(arg2.getType() == TYPE.DOUBLE) {
+
+ }
+
+ return startPos;
+ }
+
+ TYPE ty = Utils.getConvertedType(arg1.getType(), arg2.getType());
+ BytecodeUtils.typeCast(il, arg1.getType(), ty);
+ arg2.bytecodeGen(clsName, mg, cp, factory, il, argsMap, argsStartPos, funcRefsMap);
+ BytecodeUtils.typeCast(il, arg2.getType(), ty);
+ if(ty == TYPE.DOUBLE)
+ il.append(InstructionConstants.DMUL);
+ else if(ty == TYPE.INT)
+ il.append(InstructionConstants.IMUL);
+ else if(ty == TYPE.LONG)
+ il.append(InstructionConstants.LMUL);
+ else if(ty == TYPE.FLOAT)
+ il.append(InstructionConstants.FMUL);
+ else
+ il.append(InstructionConstants.IMUL);
+ return startPos;
+ }
+
+ @Override
+ public void updateLabel() {
+ label = SymPrinting.addParenthsesIfNeeded(arg1, this)
+ + "*" +
+ SymPrinting.addParenthsesIfNeeded(arg2, this);
+ if(this.isCoeffMulSymbol()) {
+ sortKey = this.getSymbolTerm().getSortKey();//+this.getCoeffTerm().getSortKey();
+ } else {
+ sortKey = arg1.getSortKey()+arg2.getSortKey();
+ }
+ }
+
+ @Override
+ public TypeInfo getTypeInfo() {
+ if(arg1.getType() == TYPE.MATRIX) {
+ if(arg2.getType() == TYPE.VECTOR)
+ return arg2.getTypeInfo();
+ else if(arg2.getType() == TYPE.MATRIX) {
+ //A_mn * B_nl = C_ml
+ TypeInfo ti = new TypeInfo(TYPE.MATRIX, new int[2]);
+ ti.dim[0] = arg1.getTypeInfo().dim[0];
+ ti.dim[1] = arg2.getTypeInfo().dim[1];
+ return ti;
+ } else
+ return arg1.getTypeInfo(); //matrix * scalar?
+ }
+ TYPE ty = Utils.getConvertedType(arg1.getType(), arg2.getType());
+ TypeInfo tyi = new TypeInfo(ty);
+ return tyi;
+ }
}
diff --git a/src/symjava/symbolic/Negate.java b/src/symjava/symbolic/Negate.java
index d7bf7d7..4a2ab23 100644
--- a/src/symjava/symbolic/Negate.java
+++ b/src/symjava/symbolic/Negate.java
@@ -2,7 +2,19 @@
import java.util.ArrayList;
import java.util.List;
+import java.util.Map;
+import com.sun.org.apache.bcel.internal.Constants;
+import com.sun.org.apache.bcel.internal.generic.ConstantPoolGen;
+import com.sun.org.apache.bcel.internal.generic.InstructionConstants;
+import com.sun.org.apache.bcel.internal.generic.InstructionFactory;
+import com.sun.org.apache.bcel.internal.generic.InstructionHandle;
+import com.sun.org.apache.bcel.internal.generic.InstructionList;
+import com.sun.org.apache.bcel.internal.generic.MethodGen;
+import com.sun.org.apache.bcel.internal.generic.ObjectType;
+import com.sun.org.apache.bcel.internal.generic.Type;
+
+import symjava.symbolic.Expr.TYPE;
import symjava.symbolic.arity.UnaryOp;
import symjava.symbolic.utils.Utils;
@@ -10,8 +22,7 @@ public class Negate extends UnaryOp {
public Negate(Expr expr) {
super(expr);
- label = "-" + SymPrinting.addParenthsesIfNeeded(expr, this);
- sortKey = arg.getSortKey();
+ updateLabel();
}
@Override
@@ -100,5 +111,28 @@ public void flattenMultiply(List outList) {
}
}
}
+
+ @Override
+ public InstructionHandle bytecodeGen(String clsName, MethodGen mg,
+ ConstantPoolGen cp, InstructionFactory factory,
+ InstructionList il, Map argsMap, int argsStartPos,
+ Map funcRefsMap) {
+ InstructionHandle startPos = arg.bytecodeGen(clsName, mg, cp, factory, il, argsMap, argsStartPos, funcRefsMap);
+ if(arg.getType() == TYPE.MATRIX || arg.getType() == TYPE.VECTOR) {
+ il.append(factory.createInvoke("symjava.symbolic.utils.BytecodeOpSupport", "negate",
+ new ObjectType("Jama.Matrix"),
+ new Type[] { new ObjectType("Jama.Matrix") },
+ Constants.INVOKESTATIC));
+ } else {
+ il.append(InstructionConstants.DNEG);
+ }
+ return startPos;
+ }
+
+ @Override
+ public void updateLabel() {
+ label = "-" + SymPrinting.addParenthsesIfNeeded(arg, this);
+ sortKey = arg.getSortKey();
+ }
}
diff --git a/src/symjava/symbolic/Pow.java b/src/symjava/symbolic/Pow.java
index 2f011e2..7ce6608 100644
--- a/src/symjava/symbolic/Pow.java
+++ b/src/symjava/symbolic/Pow.java
@@ -1,31 +1,28 @@
package symjava.symbolic;
import java.util.List;
+import java.util.Map;
import symjava.symbolic.arity.BinaryOp;
import symjava.symbolic.utils.Utils;
+import com.sun.org.apache.bcel.internal.Constants;
+import com.sun.org.apache.bcel.internal.generic.ConstantPoolGen;
+import com.sun.org.apache.bcel.internal.generic.InstructionFactory;
+import com.sun.org.apache.bcel.internal.generic.InstructionHandle;
+import com.sun.org.apache.bcel.internal.generic.InstructionList;
+import com.sun.org.apache.bcel.internal.generic.MethodGen;
+import com.sun.org.apache.bcel.internal.generic.Type;
+
public class Pow extends BinaryOp {
public Pow(Expr base, Expr exponent) {
super(base, exponent);
- String displayExp = String.format("%s", this.arg2);
- if(exponent instanceof SymReal) {
- SymReal realExp = (SymReal)exponent;
- if(realExp.isInteger()) {
- displayExp = String.format("%d", realExp.getIntValue());
- }
- if(realExp.isNegative())
- displayExp = "{"+displayExp+"}";
- }
- if(base instanceof Symbol) {
- label = base + "^" + displayExp + "";
- label = "pow(" + base + ","+displayExp+")";
- } else {
- label = "("+base + ")^" + displayExp;
- }
- //TODO? x^3 + x^2 + x + 1
- sortKey = base.getSortKey()+"power"+String.valueOf(displayExp);
+ updateLabel();
+ }
+
+ public String toString() {
+ return "pow("+arg1+","+arg2+")";
}
public static Expr simplifiedIns(Expr base, Expr exponent) {
@@ -63,7 +60,7 @@ public Expr subs(Expr from, Expr to) {
public Expr diff(Expr expr) {
if(arg2 instanceof SymReal) {
SymReal realExp = (SymReal)arg2;
- return realExp.multiply(Pow.simplifiedIns(arg1, arg2 - 1)).multiply(arg1.diff(expr));
+ return realExp.multiply(Pow.simplifiedIns(arg1, arg2.subtract(1))).multiply(arg1.diff(expr));
} else {
Expr x = expr;
Expr b = arg1;
@@ -100,19 +97,66 @@ public void flattenAdd(List outList) {
@Override
public void flattenMultiply(List outList) {
+ if(device != null) {
+ outList.add(this);
+ } else {
+ if(arg2 instanceof SymReal) {
+ SymReal realExp = (SymReal)arg2;
+ if(realExp.isPositive()) {
+ double exp = realExp.getDoubleValue();
+ for(int i=0; i<(int)exp; i++)
+ outList.add(arg1);
+ double remain = exp - Math.floor(exp);
+ if(remain > 0.0) {
+ outList.add(simplifiedIns(arg1, Expr.valueOf(remain)));
+ }
+ return;
+ }
+ }
+ outList.add(this);
+ }
+ }
+ @Override
+ public InstructionHandle bytecodeGen(String clsName, MethodGen mg,
+ ConstantPoolGen cp, InstructionFactory factory,
+ InstructionList il, Map argsMap, int argsStartPos,
+ Map funcRefsMap) {
+ InstructionHandle startPos = arg1.bytecodeGen(clsName, mg, cp, factory, il, argsMap, argsStartPos, funcRefsMap);
+ arg2.bytecodeGen(clsName, mg, cp, factory, il, argsMap, argsStartPos, funcRefsMap);
if(arg2 instanceof SymReal) {
SymReal realExp = (SymReal)arg2;
- if(realExp.isPositive()) {
- double exp = realExp.getDoubleValue();
- for(int i=0; i<(int)exp; i++)
- outList.add(arg1);
- double remain = exp - Math.floor(exp);
- if(remain > 0.0) {
- outList.add(simplifiedIns(arg1, Expr.valueOf(remain)));
- }
- return;
+ if(realExp.isInteger()) {
+ il.append(factory.createInvoke("symjava.symbolic.utils.BytecodeSupport", "powi",
+ Type.DOUBLE, new Type[] { Type.DOUBLE, Type.INT }, Constants.INVOKESTATIC));
+ return startPos;
}
}
- outList.add(this);
+ il.append(factory.createInvoke("java.lang.Math", "pow",
+ Type.DOUBLE, new Type[] { Type.DOUBLE, Type.DOUBLE }, Constants.INVOKESTATIC));
+ return startPos;
}
+
+ @Override
+ public void updateLabel() {
+ Expr base = arg1;
+ Expr exponent = arg2;
+// String displayExp = exponent.toString();
+// if(exponent instanceof SymReal) {
+// SymReal realExp = (SymReal)exponent;
+// if(realExp.isInteger()) {
+// displayExp = String.format("%d", realExp.getIntValue());
+// }
+// if(realExp.isNegative())
+// displayExp = "{"+displayExp+"}";
+// }
+// if(base instanceof Symbol) {
+// label = base + "^" + displayExp + "";
+// } else {
+// label = "("+base + ")^" + displayExp;
+// }
+ //TODO? x^3 + x^2 + x + 1
+ label = "pow(" + base + ","+exponent+")";
+ sortKey = base.getSortKey()+"power"+exponent.getSortKey();
+
+ }
}
diff --git a/src/symjava/symbolic/Prod.java b/src/symjava/symbolic/Prod.java
index aa032ef..0b00b80 100644
--- a/src/symjava/symbolic/Prod.java
+++ b/src/symjava/symbolic/Prod.java
@@ -1,5 +1,46 @@
package symjava.symbolic;
-public class Prod {
+/**
+ * TODO
+ * a*b*c*d...
+ *
+ */
+public class Prod extends Expr {
+
+ @Override
+ public Expr simplify() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public boolean symEquals(Expr other) {
+ // TODO Auto-generated method stub
+ return false;
+ }
+
+ @Override
+ public Expr diff(Expr expr) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Expr[] args() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public TypeInfo getTypeInfo() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public void updateLabel() {
+ // TODO Auto-generated method stub
+
+ }
}
diff --git a/src/symjava/symbolic/Reciprocal.java b/src/symjava/symbolic/Reciprocal.java
index 322c51f..a652baf 100644
--- a/src/symjava/symbolic/Reciprocal.java
+++ b/src/symjava/symbolic/Reciprocal.java
@@ -1,14 +1,23 @@
package symjava.symbolic;
+import java.util.Map;
+
import symjava.symbolic.arity.UnaryOp;
+import symjava.symbolic.utils.BytecodeUtils;
import symjava.symbolic.utils.Utils;
+import com.sun.org.apache.bcel.internal.generic.ConstantPoolGen;
+import com.sun.org.apache.bcel.internal.generic.InstructionConstants;
+import com.sun.org.apache.bcel.internal.generic.InstructionFactory;
+import com.sun.org.apache.bcel.internal.generic.InstructionHandle;
+import com.sun.org.apache.bcel.internal.generic.InstructionList;
+import com.sun.org.apache.bcel.internal.generic.MethodGen;
+
public class Reciprocal extends UnaryOp {
public Reciprocal(Expr base) {
super(base);
- label = "1/" + SymPrinting.addParenthsesIfNeeded(base, this);
- sortKey = base.getSortKey();
+ updateLabel();
}
@Override
@@ -23,7 +32,7 @@ public Expr simplify() {
if(arg instanceof Pow) {
Pow p = (Pow)arg.simplify();
p.isSimplified = true;
- Expr rlt = Pow.simplifiedIns(p.arg1, -p.arg2);
+ Expr rlt = Pow.simplifiedIns(p.arg1, p.arg2.negate());
rlt.isSimplified = true;
return rlt;
}
@@ -59,5 +68,23 @@ public Expr subs(Expr from, Expr to) {
return this;
return Reciprocal.simplifiedIns(arg.subs(from, to));
}
+
+ @Override
+ public InstructionHandle bytecodeGen(String clsName, MethodGen mg,
+ ConstantPoolGen cp, InstructionFactory factory,
+ InstructionList il, Map argsMap, int argsStartPos,
+ Map funcRefsMap) {
+ InstructionHandle startPos = il.append(InstructionConstants.DCONST_1);
+ arg.bytecodeGen(clsName, mg, cp, factory, il, argsMap, argsStartPos, funcRefsMap);
+ BytecodeUtils.typeCast(il, arg.getType(), TYPE.DOUBLE);
+ il.append(InstructionConstants.DDIV);
+ return startPos;
+ }
+ @Override
+ public void updateLabel() {
+ label = "1/" + SymPrinting.addParenthsesIfNeeded(arg, this);
+ sortKey = arg.getSortKey();
+ }
+
}
diff --git a/src/symjava/symbolic/Remainder.java b/src/symjava/symbolic/Remainder.java
index ad80b6b..8e3cf8f 100644
--- a/src/symjava/symbolic/Remainder.java
+++ b/src/symjava/symbolic/Remainder.java
@@ -1,12 +1,30 @@
package symjava.symbolic;
+import static com.sun.org.apache.bcel.internal.generic.InstructionConstants.DREM;
+import static com.sun.org.apache.bcel.internal.generic.InstructionConstants.FREM;
+import static com.sun.org.apache.bcel.internal.generic.InstructionConstants.IREM;
+import static com.sun.org.apache.bcel.internal.generic.InstructionConstants.LREM;
+
+import java.util.Map;
+
import symjava.symbolic.arity.BinaryOp;
+import symjava.symbolic.utils.BytecodeUtils;
+import symjava.symbolic.utils.Utils;
+import com.sun.org.apache.bcel.internal.generic.ConstantPoolGen;
+import com.sun.org.apache.bcel.internal.generic.InstructionFactory;
+import com.sun.org.apache.bcel.internal.generic.InstructionHandle;
+import com.sun.org.apache.bcel.internal.generic.InstructionList;
+import com.sun.org.apache.bcel.internal.generic.MethodGen;
+
+/**
+ * a % b
+ *
+ */
public class Remainder extends BinaryOp {
public Remainder(Expr arg1, Expr arg2) {
super(arg1, arg2);
- this.label = arg1+"%"+arg2;
- this.sortKey = this.label;
+ updateLabel();
}
@Override
@@ -16,12 +34,41 @@ public Expr simplify() {
@Override
public boolean symEquals(Expr other) {
+ //TODO
return false;
}
@Override
public Expr diff(Expr expr) {
- //???
- return this;
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public InstructionHandle bytecodeGen(String clsName, MethodGen mg,
+ ConstantPoolGen cp, InstructionFactory factory,
+ InstructionList il, Map argsMap, int argsStartPos,
+ Map funcRefsMap) {
+ InstructionHandle startPos = arg1.bytecodeGen(clsName, mg, cp, factory, il, argsMap, argsStartPos, funcRefsMap);
+ TYPE ty = Utils.getConvertedType(arg1.getType(), arg2.getType());
+ BytecodeUtils.typeCast(il, arg1.getType(), ty);
+ arg2.bytecodeGen(clsName, mg, cp, factory, il, argsMap, argsStartPos, funcRefsMap);
+ BytecodeUtils.typeCast(il, arg2.getType(), ty);
+ if(ty == TYPE.DOUBLE)
+ il.append(DREM);
+ else if(ty == TYPE.INT)
+ il.append(IREM);
+ else if(ty == TYPE.LONG)
+ il.append(LREM);
+ else if(ty == TYPE.FLOAT)
+ il.append(FREM);
+ else
+ il.append(IREM);
+ return startPos;
+ }
+
+ @Override
+ public void updateLabel() {
+ this.label = arg1+"%"+arg2;
+ this.sortKey = this.label;
}
}
diff --git a/src/symjava/symbolic/Select.java b/src/symjava/symbolic/Select.java
new file mode 100644
index 0000000..f6439f9
--- /dev/null
+++ b/src/symjava/symbolic/Select.java
@@ -0,0 +1,63 @@
+package symjava.symbolic;
+
+public class Select extends Expr {
+
+ public Select(Expr ...cols) {
+
+ }
+
+ public Select from(Expr ...tables) {
+ return this;
+ }
+
+ public Select where() {
+ return this;
+ }
+
+ public Select groupBy(Expr ...cols) {
+ return this;
+ }
+
+
+ public static void main(String[] args) {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public Expr simplify() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public boolean symEquals(Expr other) {
+ // TODO Auto-generated method stub
+ return false;
+ }
+
+ @Override
+ public Expr[] args() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Expr diff(Expr x) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public TypeInfo getTypeInfo() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public void updateLabel() {
+ // TODO Auto-generated method stub
+
+ }
+
+}
diff --git a/src/symjava/symbolic/Sin.java b/src/symjava/symbolic/Sin.java
index 4dd7b52..d6803fd 100644
--- a/src/symjava/symbolic/Sin.java
+++ b/src/symjava/symbolic/Sin.java
@@ -1,5 +1,16 @@
package symjava.symbolic;
+import java.util.Map;
+
+import com.sun.org.apache.bcel.internal.Constants;
+import com.sun.org.apache.bcel.internal.generic.ConstantPoolGen;
+import com.sun.org.apache.bcel.internal.generic.InstructionFactory;
+import com.sun.org.apache.bcel.internal.generic.InstructionHandle;
+import com.sun.org.apache.bcel.internal.generic.InstructionList;
+import com.sun.org.apache.bcel.internal.generic.MethodGen;
+import com.sun.org.apache.bcel.internal.generic.ObjectType;
+import com.sun.org.apache.bcel.internal.generic.Type;
+
import symjava.symbolic.arity.UnaryOp;
import symjava.symbolic.utils.Utils;
@@ -7,8 +18,7 @@ public class Sin extends UnaryOp {
public Sin(Expr arg) {
super(arg);
- label = "sin(" + arg + ")";
- sortKey = label;
+ updateLabel();
}
@Override
@@ -25,6 +35,16 @@ public Expr simplify() {
return this;
}
+ @Override
+ public Expr subs(Expr from, Expr to) {
+ if(Utils.symCompare(this, from))
+ return to;
+ Expr sl = arg.subs(from, to);
+ if(sl == arg)
+ return this;
+ return new Sin(sl);
+ }
+
@Override
public boolean symEquals(Expr other) {
if(other instanceof Sin) {
@@ -32,5 +52,30 @@ public boolean symEquals(Expr other) {
}
return false;
}
+
+ @Override
+ public InstructionHandle bytecodeGen(String clsName, MethodGen mg,
+ ConstantPoolGen cp, InstructionFactory factory,
+ InstructionList il, Map argsMap, int argsStartPos,
+ Map funcRefsMap) {
+ InstructionHandle startPos = arg.bytecodeGen(clsName, mg, cp, factory, il, argsMap, argsStartPos, funcRefsMap);
+ if(arg.getType() == TYPE.MATRIX || arg.getType() == TYPE.VECTOR) {
+ il.append(factory.createInvoke("symjava.symbolic.utils.BytecodeOpSupport", "sin",
+ new ObjectType("Jama.Matrix"),
+ new Type[] { new ObjectType("Jama.Matrix") },
+ Constants.INVOKESTATIC));
+ } else {
+ il.append(factory.createInvoke("java.lang.Math", "sin",
+ Type.DOUBLE,
+ new Type[] { Type.DOUBLE },
+ Constants.INVOKESTATIC));
+ }
+ return startPos;
+ }
+ @Override
+ public void updateLabel() {
+ label = "sin(" + arg + ")";
+ sortKey = label;
+ }
}
diff --git a/src/symjava/symbolic/Sqrt.java b/src/symjava/symbolic/Sqrt.java
index 836619d..e696e23 100644
--- a/src/symjava/symbolic/Sqrt.java
+++ b/src/symjava/symbolic/Sqrt.java
@@ -1,32 +1,33 @@
package symjava.symbolic;
+import java.util.Map;
+
import symjava.symbolic.arity.BinaryOp;
import symjava.symbolic.utils.Utils;
+import com.sun.org.apache.bcel.internal.Constants;
+import com.sun.org.apache.bcel.internal.generic.ConstantPoolGen;
+import com.sun.org.apache.bcel.internal.generic.InstructionConstants;
+import com.sun.org.apache.bcel.internal.generic.InstructionFactory;
+import com.sun.org.apache.bcel.internal.generic.InstructionHandle;
+import com.sun.org.apache.bcel.internal.generic.InstructionList;
+import com.sun.org.apache.bcel.internal.generic.MethodGen;
+import com.sun.org.apache.bcel.internal.generic.Type;
+
public class Sqrt extends BinaryOp {
public Sqrt(Expr expr) {
super(expr, Expr.valueOf(2));
- label = "\\sqrt{" + expr + "}";
- sortKey = expr.getSortKey()+"sqrt[2]"+String.valueOf(arg2);
+ updateLabel();
}
public Sqrt(Expr expr, Expr root) {
super(expr, root);
- String displayRoot = String.format("%s", this.arg2);
- if(root instanceof SymReal) {
- SymReal realExp = (SymReal)root;
- if(realExp.isInteger()) {
- displayRoot = String.format("%d", realExp.getIntValue());
- }
- }
- label = "\\sqrt["+displayRoot+"]{" + expr + "}";
- //TODO
- sortKey = expr.getSortKey()+"sqrt["+root+"]"+String.valueOf(root);
+ updateLabel();
}
@Override
public Expr diff(Expr expr) {
- return Pow.simplifiedIns(arg1, 1.0/arg2).diff(expr);
+ return Pow.simplifiedIns(arg1, arg2.divideRev(1.0)).diff(expr);
}
public static Expr simplifiedIns(Expr expr, Expr root) {
@@ -74,4 +75,40 @@ public Expr subs(Expr from, Expr to) {
return to;
return new Sqrt(arg1.subs(from, to), arg2.subs(from, to));
}
+
+ @Override
+ public InstructionHandle bytecodeGen(String clsName, MethodGen mg,
+ ConstantPoolGen cp, InstructionFactory factory,
+ InstructionList il, Map argsMap, int argsStartPos,
+ Map funcRefsMap) {
+ InstructionHandle startPos = arg1.bytecodeGen(clsName, mg, cp, factory, il, argsMap, argsStartPos, funcRefsMap);
+ il.append(InstructionConstants.DCONST_1);
+ arg2.bytecodeGen(clsName, mg, cp, factory, il, argsMap, argsStartPos, funcRefsMap);
+ if(arg2 instanceof SymReal) {
+ SymReal realExp = (SymReal)arg2;
+ if(realExp.isInteger()) {
+ il.append(InstructionConstants.I2D);
+ }
+ }
+ il.append(InstructionConstants.DDIV);
+ il.append(factory.createInvoke("java.lang.Math", "pow",
+ Type.DOUBLE,
+ new Type[] { Type.DOUBLE, Type.DOUBLE },
+ Constants.INVOKESTATIC));
+ return startPos;
+ }
+
+ @Override
+ public void updateLabel() {
+ if(arg2 instanceof SymReal) {
+ SymReal t = (SymReal)arg2;
+ if(t.isInteger() && t.getIntValue() == 2) {
+ label = "sqrt(" + arg1 + ")";
+ sortKey = arg1.getSortKey()+"sqrt[2]"+arg2;
+ return;
+ }
+ }
+ label = "sqrtn(" + arg1 + "," + arg2 + ")";
+ sortKey = arg1.getSortKey()+"sqrt"+arg2.getSortKey();
+ }
}
diff --git a/src/symjava/symbolic/Subtract.java b/src/symjava/symbolic/Subtract.java
index 5c24df9..90b403a 100644
--- a/src/symjava/symbolic/Subtract.java
+++ b/src/symjava/symbolic/Subtract.java
@@ -1,19 +1,28 @@
package symjava.symbolic;
import java.util.List;
+import java.util.Map;
+import symjava.symbolic.Expr.TYPE;
import symjava.symbolic.arity.BinaryOp;
+import symjava.symbolic.utils.BytecodeUtils;
import symjava.symbolic.utils.Utils;
+import com.sun.org.apache.bcel.internal.Constants;
+import com.sun.org.apache.bcel.internal.generic.ConstantPoolGen;
+import com.sun.org.apache.bcel.internal.generic.InstructionConstants;
+import com.sun.org.apache.bcel.internal.generic.InstructionFactory;
+import com.sun.org.apache.bcel.internal.generic.InstructionHandle;
+import com.sun.org.apache.bcel.internal.generic.InstructionList;
+import com.sun.org.apache.bcel.internal.generic.MethodGen;
+import com.sun.org.apache.bcel.internal.generic.ObjectType;
+import com.sun.org.apache.bcel.internal.generic.Type;
+
public class Subtract extends BinaryOp {
public Subtract(Expr l, Expr r) {
super(l, r);
- if(arg2 instanceof Add || arg2 instanceof Subtract)
- label = arg1 + " - (" + arg2 + ")";
- else
- label = arg1 + " - " + arg2;
+ updateLabel();
- sortKey = arg1.getSortKey()+arg2.getSortKey();
}
@Override
@@ -75,4 +84,51 @@ public boolean symEquals(Expr other) {
//return Utils.flattenSortAndCompare(this, other);
return Utils.flattenSortAndCompare(this.simplify(), other.simplify());
}
+
+ @Override
+ public InstructionHandle bytecodeGen(String clsName, MethodGen mg,
+ ConstantPoolGen cp, InstructionFactory factory,
+ InstructionList il, Map argsMap, int argsStartPos,
+ Map funcRefsMap) {
+ InstructionHandle startPos = arg1.bytecodeGen(clsName, mg, cp, factory, il, argsMap, argsStartPos, funcRefsMap);
+ if(arg1.getType() == TYPE.MATRIX && arg2.getType() == TYPE.MATRIX) {
+ arg2.bytecodeGen(clsName, mg, cp, factory, il, argsMap, argsStartPos, funcRefsMap);
+ il.append(factory.createInvoke("Jama.Matrix", "minus",
+ new ObjectType("Jama.Matrix"), new Type[] { new ObjectType("Jama.Matrix") },
+ Constants.INVOKEVIRTUAL));
+ return startPos;
+ } else if(arg1.getType() == TYPE.VECTOR && arg2.getType() == TYPE.VECTOR) {
+ arg2.bytecodeGen(clsName, mg, cp, factory, il, argsMap, argsStartPos, funcRefsMap);
+ il.append(factory.createInvoke("Jama.Matrix", "minus",
+ new ObjectType("Jama.Matrix"), new Type[] { new ObjectType("Jama.Matrix") },
+ Constants.INVOKEVIRTUAL));
+ return startPos;
+ }
+
+ TYPE ty = Utils.getConvertedType(arg1.getType(), arg2.getType());
+ BytecodeUtils.typeCast(il, arg1.getType(), ty);
+ arg2.bytecodeGen(clsName, mg, cp, factory, il, argsMap, argsStartPos, funcRefsMap);
+ BytecodeUtils.typeCast(il, arg2.getType(), ty);
+ if(ty == TYPE.DOUBLE)
+ il.append(InstructionConstants.DSUB);
+ else if(ty == TYPE.INT)
+ il.append(InstructionConstants.ISUB);
+ else if(ty == TYPE.LONG)
+ il.append(InstructionConstants.LSUB);
+ else if(ty == TYPE.FLOAT)
+ il.append(InstructionConstants.FSUB);
+ else
+ il.append(InstructionConstants.ISUB);
+ return startPos;
+ }
+
+ @Override
+ public void updateLabel() {
+ if(arg2 instanceof Add || arg2 instanceof Subtract)
+ label = arg1 + " - (" + arg2 + ")";
+ else
+ label = arg1 + " - " + arg2;
+
+ sortKey = arg1.getSortKey()+arg2.getSortKey();
+ }
}
diff --git a/src/symjava/symbolic/Sum.java b/src/symjava/symbolic/Sum.java
index 3eba735..5278fac 100644
--- a/src/symjava/symbolic/Sum.java
+++ b/src/symjava/symbolic/Sum.java
@@ -7,6 +7,9 @@
import symjava.symbolic.utils.AddList;
import symjava.symbolic.utils.Utils;
+/**
+ * a+b+c+d+...
+ */
public class Sum extends Expr {
public Expr summandTemplate;
public Expr indexExpr;
@@ -14,6 +17,14 @@ public class Sum extends Expr {
public int end;
HashMap