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 ); } }
@Override protected boolean matchesSafely( AnyValue value ) { return value instanceof NumberValue && ((NumberValue) value).longValue() >= input; } };
/** * 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 ); } }
public static long transformToLong( Object value ) { if ( value == null ) { throw new CypherTypeException( "Expected a numeric value but got null", null ); } if ( value instanceof NumberValue ) { NumberValue number = (NumberValue) value; return number.longValue(); } if ( value instanceof Number ) { Number number = (Number) value; return number.longValue(); } throw new CypherTypeException( String.format( "Expected a numeric value but got %s", value.toString() ), null ); }
public static IntegralValue asIntegralValue( AnyValue value ) { if ( !(value instanceof NumberValue) ) { throw cantCoerce( value, "Integer" ); } return Values.longValue( ((NumberValue) value).longValue() ); }
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 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 ); } }
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 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 ); } } }
public static Value toInteger( AnyValue in ) { if ( in instanceof IntegralValue ) { return (IntegralValue) in; } else if ( in instanceof NumberValue ) { return longValue( ((NumberValue) in).longValue() ); } else if ( in instanceof TextValue ) { return stringToLongValue( (TextValue) in ); } else { throw new ParameterWrongTypeException( "Expected a String or Number, got: " + in.toString(), null ); } }
public static NumberValue abs( AnyValue in ) { if ( in instanceof NumberValue ) { if ( in instanceof IntegralValue ) { return longValue( Math.abs( ((NumberValue) in).longValue() ) ); } else { return doubleValue( Math.abs( ((NumberValue) in).doubleValue() ) ); } } else { throw needsNumbers( "abs()" ); } }
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 ); }
private static AnyValue listAccess( SequenceValue container, AnyValue index ) { NumberValue number = asNumberValue( index ); if ( !(number instanceof IntegralValue) ) { throw new CypherTypeException( format( "Cannot index a list using an non-integer number, got %s", number ), null ); } long idx = number.longValue(); if ( idx > Integer.MAX_VALUE || idx < Integer.MIN_VALUE ) { throw new InvalidArgumentException( format( "Cannot index a list using a value greater than %d or lesser than %d, got %d", Integer.MAX_VALUE, Integer.MIN_VALUE, idx ), null ); } if ( idx < 0 ) { idx = container.length() + idx; } if ( idx >= container.length() || idx < 0 ) { return NO_VALUE; } return container.value( (int) idx ); }
public DurationValue mul( NumberValue number ) { try { if ( number instanceof IntegralValue ) { long factor = number.longValue(); return duration( Math.multiplyExact( months, factor ), Math.multiplyExact( days, factor ), Math.multiplyExact( seconds, factor ), Math.multiplyExact( nanos, factor ) ); } if ( number instanceof FloatingPointValue ) { double factor = number.doubleValue(); return approximate( months * factor, days * factor, seconds * factor, nanos * factor ); } } catch ( ArithmeticException e ) { throw invalidDurationMultiply( this, number, e ); } throw new InvalidValuesArgumentException( "Factor must be either integer of floating point number." ); }
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 ); } }
public static IntegralValue asIntegralValue( AnyValue value ) { if ( !(value instanceof NumberValue) ) { throw cantCoerce( value, "Integer" ); } return Values.longValue( ((NumberValue) value).longValue() ); }
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 ); } }
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 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 ); } } }