public static AnyValue modulo( AnyValue lhs, AnyValue rhs ) { if ( lhs instanceof NumberValue && rhs instanceof NumberValue ) { if ( lhs instanceof FloatingPointValue || rhs instanceof FloatingPointValue ) { return doubleValue( ((NumberValue) lhs).doubleValue() % ((NumberValue) rhs).doubleValue() ); } else { return longValue( ((NumberValue) lhs).longValue() % ((NumberValue) rhs).longValue() ); } } throw new CypherTypeException( String.format( "Cannot calculate modulus of `%s` and `%s`", lhs.getTypeName(), rhs.getTypeName() ), null ); }
public NumberValue minus( NumberValue numberValue ) { if ( numberValue instanceof IntegralValue ) { return minus( numberValue.longValue() ); } else if ( numberValue instanceof FloatingPointValue ) { return minus( numberValue.doubleValue() ); } else { throw new IllegalArgumentException( "Cannot subtract " + numberValue ); } }
public NumberValue plus( NumberValue numberValue ) { if ( numberValue instanceof IntegralValue ) { return plus( numberValue.longValue() ); } else if ( numberValue instanceof FloatingPointValue ) { return plus( numberValue.doubleValue() ); } else { throw new IllegalArgumentException( "Cannot add " + numberValue ); } }
public NumberValue times( NumberValue numberValue ) { if ( numberValue instanceof IntegralValue ) { return times( numberValue.longValue() ); } else if ( numberValue instanceof FloatingPointValue ) { return times( numberValue.doubleValue() ); } else { throw new IllegalArgumentException( "Cannot multiply with " + numberValue ); } }
@Override protected boolean matchesSafely( AnyValue value ) { return value instanceof NumberValue && ((NumberValue) value).longValue() >= input; } };
public static DoubleValue atan2( AnyValue y, AnyValue x ) { if ( y instanceof NumberValue && x instanceof NumberValue ) { return doubleValue( Math.atan2( ((NumberValue) y).doubleValue(), ((NumberValue) x).doubleValue() ) ); } else { throw needsNumbers( "atan2()" ); } }
/** * Overflow safe addition of two number values. * * Will not overflow but instead widen the type as necessary. * @param a left-hand operand * @param b right-hand operand * @return a + b */ public static NumberValue overflowSafeAdd( NumberValue a, NumberValue b ) { if ( a instanceof IntegralValue && b instanceof IntegralValue ) { return overflowSafeAdd( a.longValue(), b.longValue() ); } else { return a.plus( b ); } }
@Override public Number mapNumber( NumberValue value ) { return value.asObject(); }
public NumberValue divideBy( NumberValue numberValue ) { if ( numberValue instanceof IntegralValue ) { return dividedBy( numberValue.longValue() ); } else if ( numberValue instanceof FloatingPointValue ) { return dividedBy( numberValue.doubleValue() ); } else { throw new IllegalArgumentException( "Cannot divide by " + numberValue ); } } }
@Test void shouldAddSimpleIntegers() { NumberValue[] integers = new NumberValue[]{byteValue( (byte) 42 ), shortValue( (short) 42 ), intValue( 42 ), longValue( 42 )}; for ( NumberValue a : integers ) { for ( NumberValue b : integers ) { assertThat( a.plus( b ), equalTo( longValue( 84 ) ) ); assertThat( b.plus( a ), equalTo( longValue( 84 ) ) ); } } }
public static AnyValue multiply( AnyValue lhs, AnyValue rhs ) { if ( lhs instanceof NumberValue && rhs instanceof NumberValue ) { return ((NumberValue) lhs).times( (NumberValue) rhs ); } // Temporal values if ( lhs instanceof DurationValue ) { if ( rhs instanceof NumberValue ) { return ((DurationValue) lhs).mul( (NumberValue) rhs ); } } if ( rhs instanceof DurationValue ) { if ( lhs instanceof NumberValue ) { return ((DurationValue) rhs).mul( (NumberValue) lhs ); } } throw new CypherTypeException( String.format( "Cannot multiply `%s` and `%s`", lhs.getTypeName(), rhs.getTypeName() ), null ); }
public static AnyValue subtract( AnyValue lhs, AnyValue rhs ) { //numbers if ( lhs instanceof NumberValue && rhs instanceof NumberValue ) { return ((NumberValue) lhs).minus( (NumberValue) rhs ); } // Temporal values if ( lhs instanceof TemporalValue ) { if ( rhs instanceof DurationValue ) { return ((TemporalValue) lhs).minus( (DurationValue) rhs ); } } if ( lhs instanceof DurationValue ) { if ( rhs instanceof DurationValue ) { return ((DurationValue) lhs).sub( (DurationValue) rhs ); } } throw new CypherTypeException( String.format( "Cannot subtract `%s` from `%s`", rhs.getTypeName(), lhs.getTypeName() ), null ); }
public static AnyValue divide( AnyValue lhs, AnyValue rhs ) { if ( lhs instanceof NumberValue && rhs instanceof NumberValue ) { return ((NumberValue) lhs).divideBy( (NumberValue) rhs ); } // Temporal values if ( lhs instanceof DurationValue ) { if ( rhs instanceof NumberValue ) { return ((DurationValue) lhs).div( (NumberValue) rhs ); } } throw new CypherTypeException( String.format( "Cannot divide `%s` by `%s`", lhs.getTypeName(), rhs.getTypeName() ), null ); }
@Override int unsafeCompareTo( Value otherValue ) { if ( otherValue instanceof IntegralValue ) { return compareTo( (IntegralValue) otherValue ); } else if ( otherValue instanceof FloatingPointValue ) { return compareTo( (FloatingPointValue) otherValue ); } else { throw new IllegalArgumentException( "Cannot compare different values" ); } }
public NumberValue times( NumberValue numberValue ) { if ( numberValue instanceof IntegralValue ) { return times( numberValue.longValue() ); } else if ( numberValue instanceof FloatingPointValue ) { return times( numberValue.doubleValue() ); } else { throw new IllegalArgumentException( "Cannot multiply with " + numberValue ); } }
private static long asLong( AnyValue value ) { if ( value instanceof NumberValue ) { return ((NumberValue) value).longValue(); } else { throw new CypherTypeException( "Expected a numeric value but got: " + value.toString(), null ); } }