Performs the {@code -} operator on the two values.
186373
public static SoyValue minus(SoyValue operand0, SoyValue operand1) {
    if (operand0 instanceof IntegerData && operand1 instanceof IntegerData) {
      return IntegerData.forValue(operand0.longValue() - operand1.longValue());
    } else {
      return FloatData.forValue(operand0.numberValue() - operand1.numberValue());
    }
  }
327546
@Pure /* not guaranteed pure , since toString() is invoked on the argument a*/
	@Inline("($1 + $2)")
	public static String operator_plus(Object a, String b) {
		return a + b;
	}
645929
protected final CALC operator(Class<? extends Operator> operator, Object value) {
        Num tmp = null;
        if (value instanceof Num)
            tmp = (Num)value;
        else
            tmp = new Num(value);
        
        infix.add(CacheExtension.getOperator(operator));
        infix.add(tmp);
        return getThis();
    }
1028219
public static Value<Boolean> and (Value<Boolean>... values)
    {
        return and(Arrays.asList(values));
    }
129808
public Expression<Double> neq(double value) {
		String valueString = "'" + value + "'";
		return new Expression<Double>(this, Operation.neq, valueString);
	}
804277
@Pure
	@Inline(value="($1 > $2)", constantExpression=true)
	public static boolean operator_greaterThan(long a, double b) {
		return a > b;
	}
268036
@SuppressWarnings("unchecked")
    @InternalFunction(operator=">", precedence=10)
    public Boolean gt(Object value, Object value2)
    {
        if (value2 != null && value2 instanceof Comparable)
        {
            @SuppressWarnings("rawtypes")
			final int ret = ((Comparable)value2).compareTo(value);
            return (ret > 0); 
        }
        return null;
    }
805573
@Pure
	@Inline(value = "($1.longValue() - $2)", constantExpression = true)
	public static long operator_minus(AtomicLong left, long right) {
		return left.longValue() - right;
	}
1172250
@Pure
	@Inline(value="($1 - $2)", constantExpression=true)
	public static long operator_minus(short a, long b) {
		return a - b;
	}
1075532
public void multiply(double val) {
        for (int c = 0; c < this.values.length; c++) {
            multiplyValue(c, val);
        }
    }
1001666
@Pure
	@Inline(value="new $3($1, $2)", imported=IntegerRange.class, statementExpression=false)
	public static IntegerRange operator_upTo(final int a, final int b) {
		return new IntegerRange(a, b);
	}
1165499
def Operate(self, values):
    """"""
    for val in values:
      try:
        if self.Operation(val, self.right_operand):
          return True
      except (TypeError, ValueError):
        pass

    return False
249973
static public BooleanExpression OR(Collection<? extends BooleanExpression> operands){
		BooleanExpression result = new BooleanExpression(OPERATOR_OR);
		result.addOperand(operands);
		return result;
	}
979112
private static Element execute(SourceRange sourceRange, Property a,
			Property b) {

		assert (a != null);
		assert (b != null);

		Element result = null;

		if ((a instanceof LongProperty) && (b instanceof LongProperty)) {

			long l1 = ((Long) a.getValue()).longValue();
			long l2 = ((Long) b.getValue()).longValue();

			result = LongProperty.getInstance(l1 + l2);

		} else if ((a instanceof NumberProperty)
				&& (b instanceof NumberProperty)) {

			double d1 = ((NumberProperty) a).doubleValue();
			double d2 = ((NumberProperty) b).doubleValue();

			result = DoubleProperty.getInstance(d1 + d2);

		} else if ((a instanceof StringProperty)
				&& (b instanceof StringProperty)) {

			String s1 = (String) a.getValue();
			String s2 = (String) b.getValue();

			result = StringProperty.getInstance(s1 + s2);

		} else {
			throw new EvaluationException(MessageUtils
					.format(MSG_MISMATCHED_ARGS_ADD), sourceRange);
		}

		return result;
	}
411190
@Pure
	@Inline(value="($1 && $2)", constantExpression=true)
	public static boolean operator_and(boolean a, boolean b) {
		return a && b;
	}
561850
def _operator_handling(self, cursor):
        """"""
        values = self._literal_handling(cursor)
        retval = ''.join([str(val) for val in values])
        return retval
564276
private static void evaluateSubexpression(final Deque<String> operators, final Deque<String> values) {
        String operator = operators.pop();
        while (!(operator).equals(SeparatorToken.OPEN_PARENTHESIS.toString())) {
            values.push(getBooleanResultAsString(operator,
                    values.pop(),
                    values.pop()));
            operator = operators.pop();
        }
    }