Creates a new implication.
@param left  the left-hand side operand
@param right the right-hand side operand
@return a new implication
176374
public Formula implication(final Formula left, final Formula right) {
    if (left.type() == FALSE || right.type() == TRUE)
      return this.verum();
    if (left.type() == TRUE)
      return right;
    if (right.type() == FALSE)
      return this.not(left);
    if (left.equals(right))
      return this.verum();
    final Pair<Formula, Formula> key = new Pair<>(left, right);
    Implication implication = this.implications.get(key);
    if (implication == null) {
      implication = new Implication(left, right, this);
      this.implications.put(key, implication);
    }
    return implication;
  }
341872
protected Expression reOrder(Expression left, Expression right, BinaryOperation.Op op) {
        if (right instanceof BinaryOperation) {
            BinaryOperation rightOp = (BinaryOperation) right;
            if (!rightOp.isSealed() && rightOp.getOp().getPriority() == op.getPriority()) {
                replaceLeft(rightOp, left, op);
                return right;
            }
        }
        return new BinaryOperation(op, left, right);
    }
506839
public static Number or(Number left, Number right) {
        return NumberMath.or(left, right);
    }
460544
public AsymmMultiPos<S, String, String> betn(String left, String right) {
		return new AsymmMultiPos<S, String, String>(left, right) {

			@Override protected S result() {
				if (Strs.isEmpty(asymmLR)) {
					return aQueue('S', left, right, pos, position, inclusive, plusminus, filltgt);
				} else { return aQueue('Z', left, right, pos, asymmLR, inclusive, plusminus, filltgt); }
			}
		};
	}
416850
public static int compare(String left, double right) {
	if (Decision.isNumber(left)) {
	    if (left.length() > 9) {
		try {
		    return new BigDecimal(left).compareTo(new BigDecimal(Caster.toString(right)));
		}
		catch (Exception e) {}
	    }
	    return compare(Caster.toDoubleValue(left, Double.NaN), right);
	}
	if (Decision.isBoolean(left)) return compare(Caster.toBooleanValue(left, false), right);

	if (left.length() == 0) return -1;
	char leftFirst = left.charAt(0);
	if (leftFirst >= '0' && leftFirst <= '9') return left.compareToIgnoreCase(Caster.toString(right));
	return leftFirst - '0';
    }
1010640
public static IsBefore isBefore(Expression<Date> left, Expression<Date> right) {
        return new IsBefore(left, right);
    }
831285
public static SMARTSAtom or(IQueryAtom left, IQueryAtom right) {
        return new Disjunction(left.getBuilder(), left, right);
    }
680085
public void composeLeftLeftInv(IntBitRelation left, IntBitRelation right) {
        int i, a, b;
        IntBitSet li, ri;

        for (i = 0; i < line.length; i++) {
            li = left.line[i];
            ri = right.line[i];
            if (li != null && ri != null) {
                for (a = li.first(); a != -1; a = li.next(a)) {
                    for (b = ri.first(); b != -1; b = ri.next(b)) {
                        add(b, a);
                    }
                }
            }
        }
    }
691877
public static Object mult(Object left, Object right) {
        return InfixOpNode.mult(left, right, null);
    }
1172518
private Expression concat( Expression left, char operator, Expression right ) {
        if( left == null ) {
            return right;
        }
        Operation op;
        if( left.getClass() == Operation.class && ((Operation)left).getOperator() == operator ) {
            op = (Operation)left;
        } else if( right != null && right.getClass() == Operation.class && ((Operation)right).getOperator() == operator ) {
            op = (Operation)right;
            op.addLeftOperand( left );
            return op;
        } else {
            op = new Operation( reader, left, operator );
        }
        if( right != null ) {
            op.addOperand( right );
        }
        return op;
    }
1107882
public static <D> Predicate ne(Expression<D> left, Expression<? super D> right) {
        return predicate(Ops.NE, left, right);
    }
153370
public Object multiply(Object left, Object right) {
    if (left == null && right == null) {
      return 0;
    }

    // if either are floating point (double or float) use double
    if (isFloatingPointNumber(left) || isFloatingPointNumber(right)) {
      double l = toDouble(left);
      double r = toDouble(right);
      return new Double(l * r);
    }

    // if either are bigdecimal use that type
    if (left instanceof BigDecimal || right instanceof BigDecimal) {
      BigDecimal l = toBigDecimal(left);
      BigDecimal r = toBigDecimal(right);
      BigDecimal result = l.multiply(r, getMathContext());
      return narrowBigDecimal(left, right, result);
    }

    // otherwise treat as integers
    BigInteger l = toBigInteger(left);
    BigInteger r = toBigInteger(right);
    BigInteger result = l.multiply(r);
    return narrowBigInteger(left, right, result);
  }
89353
public static Number plus(Number left, Number right) {
        return NumberMath.add(left, right);
    }
1091074
public static <D> Predicate in(Expression<D> left, Collection<? extends D> right) {
        if (right.size() == 1) {
            return eqConst(left, right.iterator().next());
        } else {
            return predicate(Ops.IN, left, ConstantImpl.create(right));
        }
    }
542862
public static Add add(Expression<Number> left, Expression<Number> right) {
        return new Add(left, right);
    }
463025
@Deprecated
    public static Criteria create(String left, String operator, String right) {
        Criteria criteria = new Criteria(ValueNode.toValueNode(left));
        criteria.criteriaType = RelationalOperator.fromString(operator);
        criteria.right = ValueNode.toValueNode(right);
        return criteria;
    }
634128
public static Object sub(Object left, Object right) {
        return InfixOpNode.sub(left, right, null);
    }