forked from yuemingl/SymJava
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathSubtract.java
More file actions
134 lines (118 loc) · 4.72 KB
/
Subtract.java
File metadata and controls
134 lines (118 loc) · 4.72 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
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);
updateLabel();
}
@Override
public Expr subs(Expr from, Expr to) {
if(Utils.symCompare(this, from))
return to;
return new Subtract(arg1.subs(from, to), arg2.subs(from, to));
}
public static Expr shallowSimplifiedIns(Expr l, Expr r) {
int simOps = l.getSimplifyOps() + r.getSimplifyOps() + 1;
if(Utils.symCompare(l, r)) {
return new SymInteger(0).setSimplifyOps(simOps).setAsSimplified();
} else if(l instanceof SymReal<?> && r instanceof SymReal<?>) {
if(l instanceof SymInteger && r instanceof SymInteger) {
SymInteger il = (SymInteger)l;
SymInteger ir = (SymInteger)r;
return new SymInteger(il.getValue()-ir.getValue()).setSimplifyOps(simOps).setAsSimplified();
} else if(l instanceof SymLong && r instanceof SymLong) {
SymLong il = (SymLong)l;
SymLong ir = (SymLong)r;
return new SymLong(il.getValue()-ir.getValue()).setSimplifyOps(simOps).setAsSimplified();
}
Number t1 = (Number)((SymReal<?>)l).getValue();
Number t2 = (Number)((SymReal<?>)r).getValue();
return new SymDouble(t1.doubleValue() - t2.doubleValue()).setSimplifyOps(simOps).setAsSimplified();
} else if(Symbol.C0.symEquals(r))
return l.clone().setSimplifyOps(simOps).setAsSimplified();
else if(Symbol.C0.symEquals(l))
return new Negate(r).setSimplifyOps(simOps).setAsSimplified();
return new Subtract(l, r).setAsSimplified();
}
public static Expr simplifiedIns(Expr l, Expr r) {
//return shallowSimplifiedIns(l,r);
return Utils.flattenSortAndSimplify(shallowSimplifiedIns(l,r));
}
@Override
public Expr diff(Expr expr) {
return arg1.diff(expr).subtract(arg2.diff(expr));
}
@Override
public Expr simplify() {
if(!this.isSimplified) {
return simplifiedIns(arg1, arg2);
}
return this;
}
@Override
public void flattenAdd(List<Expr> outList) {
arg1.flattenAdd(outList);
new Negate(arg2).flattenAdd(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<String, Integer> argsMap, int argsStartPos,
Map<Expr, Integer> 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();
}
}