Example #1
0
 public void matrixTransform(
     double a00,
     double a01,
     double a02,
     double a10,
     double a11,
     double a12,
     double a20,
     double a21,
     double a22) {
   ExpressionNode dummy = new ExpressionNode();
   expression = expression.replaceAndWrap(fVars[0], dummy);
   double[][] b = MyMath.adjoint(a00, a01, a02, a10, a11, a12, a20, a21, a22);
   MyDouble[][] mbTrans = new MyDouble[3][3];
   for (int i = 0; i < 3; i++)
     for (int j = 0; j < 3; j++) mbTrans[i][j] = new MyDouble(kernel, b[j][i]);
   ExpressionNode newZ =
       new ExpressionNode(kernel, mbTrans[2][0], ExpressionNode.MULTIPLY, fVars[0])
           .plus(new ExpressionNode(kernel, mbTrans[2][1], ExpressionNode.MULTIPLY, fVars[1]))
           .plus(mbTrans[2][2]);
   ExpressionNode newX =
       new ExpressionNode(kernel, mbTrans[0][0], ExpressionNode.MULTIPLY, fVars[0])
           .plus(new ExpressionNode(kernel, mbTrans[0][1], ExpressionNode.MULTIPLY, fVars[1]))
           .plus(mbTrans[0][2]);
   ExpressionNode newY =
       new ExpressionNode(kernel, mbTrans[1][0], ExpressionNode.MULTIPLY, fVars[0])
           .plus(new ExpressionNode(kernel, mbTrans[1][1], ExpressionNode.MULTIPLY, fVars[1]))
           .plus(mbTrans[1][2]);
   expression = expression.replaceAndWrap(fVars[1], newY.divide(newZ));
   expression = expression.replaceAndWrap(dummy, newX.divide(newZ));
   this.initIneqs(expression, this);
 }
Example #2
0
  // replace every x in tree by (x - vx)
  // i.e. replace fVar with (fvar - vx)
  private void translateX(ExpressionNode en, double vx, int varNo) {
    ExpressionValue left = en.getLeft();
    ExpressionValue right = en.getRight();

    // left tree
    if (left == fVars[varNo]) {
      try { // is there a constant number to the right?
        MyDouble num = (MyDouble) right;
        double temp;
        switch (en.getOperation()) {
          case ExpressionNode.PLUS:
            temp = num.getDouble() - vx;
            if (Kernel.isZero(temp)) {
              expression = expression.replaceAndWrap(en, fVars[varNo]);
            } else if (temp < 0) {
              en.setOperation(ExpressionNode.MINUS);
              num.set(-temp);
            } else {
              num.set(temp);
            }
            return;

          case ExpressionNode.MINUS:
            temp = num.getDouble() + vx;
            if (Kernel.isZero(temp)) {
              expression = expression.replaceAndWrap(en, fVars[varNo]);
            } else if (temp < 0) {
              en.setOperation(ExpressionNode.PLUS);
              num.set(-temp);
            } else {
              num.set(temp);
            }
            return;

          default:
            en.setLeft(shiftXnode(vx, varNo));
        }
      } catch (Exception e) {
        en.setLeft(shiftXnode(vx, varNo));
      }
    } else if (left instanceof ExpressionNode) {
      translateX((ExpressionNode) left, vx, varNo);
    }

    // right tree
    if (right == fVars[varNo]) {
      en.setRight(shiftXnode(vx, varNo));
    } else if (right instanceof ExpressionNode) {
      translateX((ExpressionNode) right, vx, varNo);
    }
  }
Example #3
0
  public void matrixTransform(double a00, double a01, double a10, double a11) {
    ExpressionNode dummy = new ExpressionNode();
    expression.replaceAndWrap(fVars[0], dummy);
    MyDouble ma00 = new MyDouble(kernel, a00);
    MyDouble ma01 = new MyDouble(kernel, a01);
    MyDouble ma10 = new MyDouble(kernel, a10);
    MyDouble ma11 = new MyDouble(kernel, a11);

    ExpressionNode newX =
        new ExpressionNode(kernel, ma00, ExpressionNode.MULTIPLY, fVars[0])
            .plus(new ExpressionNode(kernel, ma01, ExpressionNode.MULTIPLY, fVars[1]));
    ExpressionNode newY =
        new ExpressionNode(kernel, ma10, ExpressionNode.MULTIPLY, fVars[0])
            .plus(new ExpressionNode(kernel, ma11, ExpressionNode.MULTIPLY, fVars[1]));
    expression = expression.replaceAndWrap(fVars[1], newY);
    expression = expression.replaceAndWrap(dummy, newX);
    this.initIneqs(expression, this);
  }
Example #4
0
 public ExpressionValue replace(ExpressionValue oldOb, ExpressionValue newOb) {
   expression = expression.replaceAndWrap(oldOb, newOb);
   return this;
 }