Performs a division modulus operation.  Called by the '%' operator.

@param left  a Number
@param right another Number to mod
@return the modulus result
@since 1.0
165212
public static Number mod(Number left, Number right) {
        return NumberMath.mod(left, right);
    }
993863
public boolean greaterThan(Object left, Object right) {
    if ((left == right) || left == null || right == null) {
      return false;
    }
    else {
      return compare(left, right, ">") > 0;
    }
  }
430030
public BigDecimal remainder() {
	    BigDecimal out = toBigDecimal();
		BigDecimal fraction = out.remainder(BigDecimal.ONE);
		return fraction;
	}
864875
public Matrix3d mulLocal(Matrix3dc left, Matrix3d dest) {
        double nm00 = left.m00() * m00 + left.m10() * m01 + left.m20() * m02;
        double nm01 = left.m01() * m00 + left.m11() * m01 + left.m20() * m02;
        double nm10 = left.m00() * m10 + left.m10() * m11 + left.m20() * m12;
        double nm11 = left.m01() * m10 + left.m11() * m11 + left.m20() * m12;
        double nm20 = left.m00() * m20 + left.m10() * m21 + left.m20() * m22;
        double nm21 = left.m01() * m20 + left.m11() * m21 + left.m21() * m22;
        dest.m00 = nm00;
        dest.m01 = nm01;
        dest.m10 = nm10;
        dest.m11 = nm11;
        dest.m20 = nm20;
        dest.m21 = nm21;
        return dest;
    }
478323
@NonNull
  public static Term multiply(@NonNull Term left, @NonNull Term right) {
    return new BinaryArithmeticTerm(ArithmeticOperator.PRODUCT, left, right);
  }
640681
public static ExpressionArithmeticOp add(Expression left, Expression right) {
		return new ExpressionArithmeticOp(ArithmeticOperation.ADD, left, right);
	}
506839
public static Number or(Number left, Number right) {
        return NumberMath.or(left, right);
    }
1163526
public static String flatten(String left, String right) {
		return left == null || left.isEmpty() ? right : left + "." + right;
	}
1063273
@Pure
	@Inline(value="($1 % $2)", constantExpression=true)
	public static double operator_modulo(long a, double b) {
		return a % b;
	}
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;
  }
1006438
public static ExprBoolean toExprBoolean(Expression left, Expression right, int operation) {
	return new OpDecision(left, right, operation);
    }
1127170
public S betns(String left, String right) {
		return betn(left, right).late();
	}
549268
public static <A extends Number & Comparable<?>> NumberExpression<A> min(Expression<A> left, Expression<A> right) {
        return NumberExpression.min(left, right);
    }
1180374
protected function numericFactors($leftOperand, $rightOperand)
    {
        if ($this->isNumeric($rightOperand) && $rightOperand->getValue() == 0) {
            throw new DivisionByZeroException();
        }
        if ($this->isNumeric($rightOperand) && $rightOperand->getValue() == 1)
        {
            return $leftOperand;
        }
        if ($this->isNumeric($leftOperand) && $leftOperand->getValue() == 0)
        {
            return new IntegerNode(0);
        }

        if (!$this->isNumeric($leftOperand) || !$this->isNumeric($rightOperand)) {
            return null;
        }
        $type = $this->resultingType($leftOperand, $rightOperand);

        switch($type) {
            case Node::NumericFloat:
            return new NumberNode($leftOperand->getValue() / $rightOperand->getValue());

            case Node::NumericRational:
            case Node::NumericInteger:
            $p = $leftOperand->getNumerator() * $rightOperand->getDenominator();
            $q = $leftOperand->getDenominator() * $rightOperand->getNumerator();
            return new RationalNode($p, $q);
        }

        return null;
    }
1370315
public Operation.Info create( Symbol op , Variable left , Variable right ) {
        switch( op ) {
            case PLUS:
                return Operation.add(left, right, managerTemp);

            case MINUS:
                return Operation.subtract(left, right, managerTemp);

            case TIMES:
                return Operation.multiply(left, right, managerTemp);

            case RDIVIDE:
                return Operation.divide(left, right, managerTemp);

            case LDIVIDE:
                return Operation.divide(right, left, managerTemp);

            case POWER:
                return Operation.pow(left, right, managerTemp);

            case ELEMENT_DIVIDE:
                return Operation.elementDivision(left, right, managerTemp);

            case ELEMENT_TIMES:
                return Operation.elementMult(left, right, managerTemp);

            case ELEMENT_POWER:
                return Operation.elementPow(left, right, managerTemp);

            default:
                throw new RuntimeException("Unknown operation " + op);
        }
    }
312083
private function MultiplicationNeedsCdot($left, $right)
    {
        if ($left instanceof FunctionNode) {
            return true;
        }

        if ($this->isNumeric($right)) {
            return true;
        }

        if ($right instanceof ExpressionNode && $this->isNumeric($right->getLeft())) {
            return true;
        }

        return false;
    }
717423
public static <A extends Number & Comparable<?>> NumberExpression<A> min(Expression<A> left, Expression<A> right) {
        return Expressions.numberOperation(left.getType(), MathOps.MIN, left, right);
    }