diff options
| author | Benjamin Culkin <bjculkin@mix.wvu.edu> | 2018-04-09 15:42:35 -0700 |
|---|---|---|
| committer | Benjamin Culkin <bjculkin@mix.wvu.edu> | 2018-04-09 15:42:35 -0700 |
| commit | 88fc0b666c58334009bc274105ea0d2b90edf75d (patch) | |
| tree | 7af54f97dd1e75873984069dbbf3e73ebe4e2893 /CSMath/src/bisection/DualExpr.java | |
Initial commit
Diffstat (limited to 'CSMath/src/bisection/DualExpr.java')
| -rw-r--r-- | CSMath/src/bisection/DualExpr.java | 269 |
1 files changed, 269 insertions, 0 deletions
diff --git a/CSMath/src/bisection/DualExpr.java b/CSMath/src/bisection/DualExpr.java new file mode 100644 index 0000000..0e16b3a --- /dev/null +++ b/CSMath/src/bisection/DualExpr.java @@ -0,0 +1,269 @@ +package bisection;
+/**
+ * Represents an expression using dual numbers.
+ *
+ * Useful for automatically differentiating expressions.
+ */
+public class DualExpr {
+ /**
+ * Represents the various types of dual expressions.
+ */
+ public static enum ExprType {
+ /**
+ * A fixed number.
+ */
+ CONSTANT,
+ /**
+ * An addition operation.
+ */
+ ADDITION,
+ /**
+ * A subtraction operation.
+ */
+ SUBTRACTION,
+ /**
+ * A multiplication operation.
+ */
+ MULTIPLICATION,
+ /**
+ * A division operation.
+ */
+ DIVISION,
+ /**
+ * A sine operation.
+ */
+ SIN,
+ /**
+ * A cosine operation.
+ */
+ COS,
+ /**
+ * An exponential function.
+ */
+ EXPONENTIAL,
+ /**
+ * A logarithm function.
+ */
+ LOGARITHM,
+ /**
+ * A power operation.
+ */
+ POWER,
+ /**
+ * An absolute value.
+ */
+ ABSOLUTE
+ }
+
+ /**
+ * The type of the expression.
+ */
+ public final DualExpr.ExprType type;
+
+ /**
+ * The dual number value, for constants.
+ */
+ public Dual number;
+
+ /**
+ * The left (or first) part of the expression.
+ */
+ public DualExpr left;
+ /**
+ * The right (or second) part of the expression.
+ */
+ public DualExpr right;
+
+ /**
+ * The power to use, for power operations.
+ */
+ public int power;
+
+ /**
+ * Create a new constant dual number.
+ *
+ * @param num
+ * The value of the dual number.
+ */
+ public DualExpr(Dual num) {
+ this.type = ExprType.CONSTANT;
+
+ number = num;
+ }
+
+ /**
+ * Create a new unary dual number.
+ *
+ * @param type
+ * The type of operation to perform.
+ * @param val
+ * The parameter to the value.
+ */
+ public DualExpr(DualExpr.ExprType type, DualExpr val) {
+ this.type = type;
+
+ left = val;
+ }
+
+ /**
+ * Create a new binary dual number.
+ *
+ * @param type
+ * The type of operation to perform.
+ * @param val
+ * The parameter to the value.
+ */
+ public DualExpr(DualExpr.ExprType type, DualExpr left, DualExpr right) {
+ this.type = type;
+
+ this.left = left;
+ this.right = right;
+ }
+
+ /**
+ * Create a new power expression.
+ *
+ * @param left
+ * The expression to raise.
+ * @param power
+ * The power to raise it by.
+ */
+ public DualExpr(DualExpr left, int power) {
+ this.type = ExprType.POWER;
+
+ this.left = left;
+ this.power = power;
+ }
+
+ /**
+ * Evaluate an expression to a number.
+ *
+ * Uses the rules provided in
+ * https://en.wikipedia.org/wiki/Automatic_differentiation
+ *
+ * @return The evaluated expression.
+ */
+ public Dual evaluate() {
+ /* The evaluated dual numbers. */
+ Dual lval, rval;
+
+ /* Perform the right operation for each type. */
+ switch (type) {
+ case CONSTANT:
+ return number;
+ case ADDITION:
+ lval = left.evaluate();
+ rval = right.evaluate();
+
+ return new Dual(lval.real + rval.real, lval.dual + rval.dual);
+ case SUBTRACTION:
+ lval = left.evaluate();
+ rval = right.evaluate();
+
+ return new Dual(lval.real - rval.real, lval.dual - rval.dual);
+ case MULTIPLICATION:
+ lval = left.evaluate();
+ rval = right.evaluate();
+
+ {
+ double lft = lval.dual * rval.real;
+ double rght = lval.real * rval.dual;
+
+ return new Dual(lval.real * rval.real, lft + rght);
+ }
+ case DIVISION:
+ lval = left.evaluate();
+ rval = right.evaluate();
+
+ {
+ if (rval.real == 0) {
+ throw new IllegalArgumentException("ERROR: Attempted to divide by zero.");
+ }
+
+ double lft = lval.dual * rval.real;
+ double rght = lval.real * rval.dual;
+
+ double val = (lft - rght) / (rval.real * rval.real);
+
+ return new Dual(lval.real / rval.real, val);
+ }
+ case SIN:
+ lval = left.evaluate();
+
+ return new Dual(Math.sin(lval.real), lval.dual * Math.cos(lval.real));
+ case COS:
+ lval = left.evaluate();
+
+ return new Dual(Math.cos(lval.real), -lval.dual * Math.sin(lval.real));
+ case EXPONENTIAL:
+ lval = left.evaluate();
+
+ {
+ double val = Math.exp(lval.real);
+
+ return new Dual(val, lval.dual * val);
+ }
+ case LOGARITHM:
+ lval = left.evaluate();
+
+ if (lval.real <= 0) {
+ throw new IllegalArgumentException(
+ "ERROR: Attempted to take non-positive log.");
+ }
+
+ return new Dual(Math.log(lval.real), lval.dual / lval.real);
+ case POWER:
+ lval = left.evaluate();
+
+ if (lval.real == 0) {
+ throw new IllegalArgumentException("ERROR: Raising zero to a power.");
+ }
+
+ {
+ double rl = Math.pow(lval.real, power);
+
+ double lft = Math.pow(lval.real, power - 1);
+
+ return new Dual(rl, power * lft * lval.dual);
+ }
+ case ABSOLUTE:
+ lval = left.evaluate();
+
+ return new Dual(Math.abs(lval.real), lval.dual * Math.signum(lval.real));
+ default:
+ String msg = "ERROR: Unknown expression type %s";
+
+ throw new IllegalArgumentException(String.format(msg, type));
+ }
+ }
+
+ @Override
+ public String toString() {
+ switch (type) {
+ case ABSOLUTE:
+ return String.format("abs(%s)", left.toString());
+ case ADDITION:
+ return String.format("(%s + %s)", left.toString(), right.toString());
+ case CONSTANT:
+ return String.format("%s", number.toString());
+ case COS:
+ return String.format("cos(%s)", left.toString());
+ case DIVISION:
+ return String.format("(%s / %s)", left.toString(), right.toString());
+ case EXPONENTIAL:
+ return String.format("exp(%s)", left.toString());
+ case LOGARITHM:
+ return String.format("log(%s)", left.toString());
+ case MULTIPLICATION:
+ return String.format("(%s * %s)", left.toString(), right.toString());
+ case POWER:
+ return String.format("(%s ^ %d)", left.toString(), power);
+ case SIN:
+ return String.format("sin(%s)", left.toString());
+ case SUBTRACTION:
+ return String.format("(%s - %s)", left.toString(), right.toString());
+ default:
+ return String.format("UNKNOWN_EXPR");
+ }
+ }
+}
\ No newline at end of file |