public void recomputeSize() { if (ineq != null) { size = 1; } else size = 0; if (left != null) { left.recomputeSize(); size += left.size; } if (right != null) { right.recomputeSize(); size += right.size; } }
public boolean updateCoef() { if (ineq != null) { ineq.updateCoef(); // Application.debug(ineq.getType()); return ineq.getType() != Inequality.INEQUALITY_INVALID; } if (left == null && right == null) return false; boolean b = true; if (left != null) b &= left.updateCoef(); if (right != null) b &= right.updateCoef(); // Application.debug("tree" + b); return b; }
public double[] getZeros(Set<Double> zeros) { if (ineq != null) { GeoPoint[] zeroPoints = ineq.getZeros(); for (int i = 0; i < zeroPoints.length; i++) { zeros.add(zeroPoints[i].getX()); } } if (left != null) { left.getZeros(zeros); } if (right != null) { right.getZeros(zeros); } return null; }
private boolean initIneqs( ExpressionNode fe, FunctionalNVar functional, IneqTree tree, boolean negate) { int op = fe.getOperation(); ExpressionNode leftTree = fe.getLeftTree(); ExpressionNode rightTree = fe.getRightTree(); if (op == ExpressionNode.GREATER || op == ExpressionNode.GREATER_EQUAL || op == ExpressionNode.LESS || op == ExpressionNode.LESS_EQUAL) { Inequality newIneq = new Inequality( kernel, leftTree, rightTree, adjustOp(op, negate), getFunction().getFunctionVariables(), functional); if (newIneq.getType() != Inequality.INEQUALITY_INVALID) { if (newIneq.getType() != Inequality.INEQUALITY_1VAR_X && newIneq.getType() != Inequality.INEQUALITY_1VAR_Y) newIneq.getBorder().setInverseFill(newIneq.isAboveBorder()); tree.setIneq(newIneq); } return newIneq.getType() != Inequality.INEQUALITY_INVALID; } else if (op == ExpressionNode.AND || op == ExpressionNode.OR || op == ExpressionNode.EQUAL_BOOLEAN || op == ExpressionNode.NOT_EQUAL) { tree.operation = adjustOp(op, negate); tree.left = new IneqTree(); tree.right = new IneqTree(); return initIneqs(leftTree, functional, tree.left, negate) && initIneqs(rightTree, functional, tree.right, negate); } else if (op == ExpressionNode.NOT) { return initIneqs(leftTree, functional, tree, !negate); } else if (op == ExpressionNode.FUNCTION_NVAR) { FunctionalNVar nv = (FunctionalNVar) leftTree.getLeft(); IneqTree otherTree = nv.getIneqs(); if (otherTree == null || otherTree.getSize() == 0) { return false; } tree.left = otherTree.left; tree.right = otherTree.right; tree.operation = otherTree.operation; tree.ineq = otherTree.ineq; return true; } else return false; }
/** * updates list of inequalities * * @return true iff all inequalities are drawable */ public boolean updateIneqs() { if (ineqs == null) return false; return ineqs.updateCoef(); }
/** * initializes inequalities * * @param fe expression node * @param functional function to which ineqs are associated * @return true if the functions consists of inequalities */ public boolean initIneqs(ExpressionNode fe, FunctionalNVar functional) { if (ineqs == null || fe == getExpression()) ineqs = new IneqTree(); boolean b = initIneqs(fe, functional, ineqs, false); ineqs.recomputeSize(); return b; }
public Inequality get(int i) { if (ineq != null) return ineq; if (i < left.getSize()) return left.get(i); return right.get(i - left.getSize()); }