public static void main(String[] args) { Number value1 = new Solution().getValueByIndex(5); // -1.0, class java.lang.Double expected Number value2 = new Solution().getValueByIndex(2); // 3, class java.lang.Integer expected System.out.println(value1 + ", " + value1.getClass().toString()); System.out.println(value2 + ", " + value2.getClass().toString()); }
public static RangeLookupTable getRangeLookupTable( List<Range> classificationRanges, final int[] outputPixelValues, final Number noDataValue, final Class<? extends Number> clazz) { final RangeLookupTable.Builder rltBuilder = new RangeLookupTable.Builder(); final int size = classificationRanges.size(); final boolean useCustomOutputPixelValues = outputPixelValues != null && outputPixelValues.length == size; Class<? extends Number> widestClass = noDataValue.getClass(); for (int i = 0; i < size; i++) { final Range range = classificationRanges.get(i); final Class<? extends Number> rangeClass = range.getMin().getClass(); if (widestClass != rangeClass) { widestClass = ClassChanger.getWidestClass(widestClass, rangeClass); } final int reference = useCustomOutputPixelValues ? outputPixelValues[i] : i + 1; rltBuilder.add(range, convert(reference, noDataValue.getClass())); } // Add the largest range that contains the no data value rltBuilder.add( new Range(getClassMinimum(widestClass), true, getClassMaximum(widestClass), true), noDataValue); return rltBuilder.build(); }
/** * Reads a Number * * @return Number Number */ @SuppressWarnings({"unchecked", "rawtypes"}) @Override public Number readNumber(Type target) { log.debug("readNumber - target: {}", target); Number v; if (currentDataType == AMF3.TYPE_NUMBER) { v = buf.getDouble(); } else { // we are decoding an int v = readAMF3Integer(); } log.debug("readNumber - value: {}", v); if (target instanceof Class && Number.class.isAssignableFrom((Class<?>) target)) { Class cls = (Class) target; if (!cls.isAssignableFrom(v.getClass())) { String value = v.toString(); log.debug("readNumber - value class: {} str: {}", v.getClass(), value); if (value.indexOf(".") > 0) { if (Float.class == v.getClass()) { v = (Number) convertUtilsBean.convert(value, Float.class); } else { v = (Number) convertUtilsBean.convert(value, Double.class); } } else { v = (Number) convertUtilsBean.convert(value, cls); } } } return v; }
@Override public int compare(Pair<V, Number> pairOne, Pair<V, Number> pairTwo) { Number leftSide = pairOne.getRight(); Number rightSide = pairTwo.getRight(); if (leftSide.getClass() == Double.class) { Double left = (Double) leftSide; Double right = (Double) rightSide; if (left > right) { return 1; } else if (right > left) { return -1; } } else if (leftSide.getClass() == Integer.class) { Integer left = (Integer) leftSide; Integer right = (Integer) rightSide; if (left > right) { return 1; } else if (right > left) { return -1; } } return 0; }
@Override protected VMRelationalOperator createOperator(Number opOne, Number opTwo) { throw new VMParsingException( "Unsupported operOr types " + opOne.getClass().getName() + ", " + opTwo.getClass().getName()); }
public static RangeLookupTable getRangeLookupTable( final List<Range> classificationRanges, final int[] outputPixelValues, final Number noDataValue) { return getRangeLookupTable( classificationRanges, outputPixelValues, noDataValue, noDataValue.getClass()); }
/** * Accepts a number as input and returns its value in byte form in LSB aligned form example: input * = 5000 [1001110001000] bytes = 19, -120 [00010011] [10001000] * * @param Number * @return byte[] */ public static byte[] toByteArray(Number input) { Class<? extends Number> dataType = input.getClass(); short size = 0; long longValue = input.longValue(); if (dataType == Byte.class || dataType == byte.class) { size = Byte.SIZE; } else if (dataType == Short.class || dataType == short.class) { size = Short.SIZE; } else if (dataType == Integer.class || dataType == int.class) { size = Integer.SIZE; } else if (dataType == Long.class || dataType == long.class) { size = Long.SIZE; } else { throw new IllegalArgumentException("Parameter must one of the following: Short/Int/Long\n"); } int length = size / NetUtils.NumBitsInAByte; byte bytes[] = new byte[length]; // Getting the bytes from input value for (int i = 0; i < length; i++) { bytes[i] = (byte) ((longValue >> (NetUtils.NumBitsInAByte * (length - i - 1))) & ByteMask); } return bytes; }
@SuppressWarnings("boxing") private void cipEqu(Number actual, Number expected, int flags) { Number res = OverloadedNumberUtil.addFallbackType(actual, flags); assertEquals(expected.getClass(), res.getClass()); assertEquals(expected, res); // Some number types wrap the number with multiple types and equals() only compares one of them. // So we try to // catch any inconsistency: assertEquals(expected.byteValue(), res.byteValue()); assertEquals(expected.shortValue(), res.shortValue()); assertEquals(expected.intValue(), res.intValue()); assertEquals(expected.longValue(), res.longValue()); assertEquals(expected.floatValue(), res.floatValue()); assertEquals(expected.doubleValue(), res.doubleValue()); }
private static Object getProperValue(Number number, Class<?> expectedClass) { Class<?> klazz = ClassUtils.wrapperToPrimitive(number.getClass()); Object value = null; // Dexlib will only ever make byte (t), int, long (l), or short (s) if (klazz == byte.class) { value = number.byteValue(); if (expectedClass == boolean.class) { value = (byte) value == 1; } } else if (klazz == short.class) { value = number.shortValue(); if (expectedClass == char.class) { value = (char) number.shortValue(); } } else if (klazz == int.class) { if (expectedClass == int.class) { value = number.intValue(); } else if (expectedClass == float.class) { value = Float.intBitsToFloat(number.intValue()); } } else if (klazz == long.class) { value = number.longValue(); if (expectedClass == long.class) { value = number.longValue(); } else if (expectedClass == double.class) { value = Double.longBitsToDouble(number.longValue()); } } return value; }
private AnnotationMirror createNumberAnnotationMirror(List<Number> values) { if (values.isEmpty()) { return UNKNOWNVAL; } Number first = values.get(0); if (first instanceof Integer || first instanceof Short || first instanceof Long || first instanceof Byte) { List<Long> intValues = new ArrayList<>(); for (Number number : values) { intValues.add(number.longValue()); } return createIntValAnnotation(intValues); } if (first instanceof Double || first instanceof Float) { List<Double> intValues = new ArrayList<>(); for (Number number : values) { intValues.add(number.doubleValue()); } return createDoubleValAnnotation(intValues); } throw new UnsupportedOperationException( "ValueAnnotatedTypeFactory: unexpected class: " + first.getClass()); }
// todo - does this implementation of Number comparison hold? private int compare(Number number1, Number number2) { if (!number2.getClass().equals(number1.getClass())) { throw new IllegalStateException(); } if (number1 instanceof Comparable) { return ((Comparable) number1).compareTo(number2); } if (number1.doubleValue() < number2.doubleValue()) { return -1; } if (number1.doubleValue() > number2.doubleValue()) { return 1; } return 0; }
@Override public Future<V> addAndGetAsync(K key, Number value) { return commandExecutor.writeAsync( getName(), StringCodec.INSTANCE, new RedisCommand<Object>("HINCRBYFLOAT", new NumberConvertor(value.getClass())), getName(), key, new BigDecimal(value.toString()).toPlainString()); }
private static boolean _equalsForNumbers(Number a, Number b) { if ((a == null) || (b == null)) return (a == b); Class<?> ac = a.getClass(); Class<?> bc = b.getClass(); if (ac == bc) return a.equals(b); if ((ac == Long.class) || (ac == Integer.class) || (ac == Short.class) || (ac == Byte.class)) return _equalsForLong(a.longValue(), b, bc); if ((ac == Double.class) || (ac == Float.class)) return _equalsForDouble(a.doubleValue(), b, bc); if (ac == BigInteger.class) return _equalsForBigInteger((BigInteger) a, b, bc); if (ac == BigDecimal.class) return _equalsForBigDecimal((BigDecimal) a, b, bc); return a.equals(b); }
/** * Create a scalar numeric-valued Attribute. * * @param name name of Attribute * @param val value of Attribute */ public Attribute(String name, Number val) { this.name = name; int[] shape = new int[1]; shape[0] = 1; DataType dt = DataType.getType(val.getClass()); Array vala = Array.factory(dt.getPrimitiveClassType(), shape); Index ima = vala.getIndex(); vala.setDouble(ima.set0(0), val.doubleValue()); setValues(vala); }
/** * Called when setting a DECIMAL value internally or from through a procedure or function. Handles * long in addition to BigDecimal to handle identity being stored as a long but returned as a * DECIMAL. */ public void setValue(Number theValue) throws StandardException { if (SanityManager.ASSERT) { if (theValue != null && !(theValue instanceof java.math.BigDecimal) && !(theValue instanceof java.lang.Long)) SanityManager.THROWASSERT("SQLDecimal.setValue(Number) passed a " + theValue.getClass()); } if (theValue instanceof BigDecimal || theValue == null) setCoreValue((BigDecimal) theValue); else setValue(theValue.longValue()); }
public void setStep(Number step) { Number oldValue = this.step; this.step = step; if (this.step.getClass() == oldValue.getClass()) { this.getModelAsXModel().setStepSize(step); this.notificarAlteracao(PROP_STEP, oldValue, this.step); } else { this.notificarAlteracao(PROP_STEP, oldValue, this.step); this.setModel(this.alterarModel(step)); } }
private void serialize(YAMLGenerator yaml, JsonElement e) throws IOException { switch (e.type()) { case object: yaml.writeStartObject(); e.asObject() .forEach( (k, v) -> { try { yaml.writeFieldName(k); serialize(yaml, v); } catch (IOException e1) { throw new IllegalStateException(e1); } }); yaml.writeEndObject(); break; case array: yaml.writeStartArray(); e.asArray() .forEach( element -> { try { serialize(yaml, element); } catch (IOException e1) { throw new IllegalStateException(e1); } }); yaml.writeEndArray(); break; case string: yaml.writeString(e.asString()); break; case bool: yaml.writeBoolean(e.asBoolean()); break; case number: Number number = e.asNumber(); Class<? extends Number> clazz = number.getClass(); if (clazz.isAssignableFrom(Double.class) || clazz.isAssignableFrom(Float.class)) { yaml.writeNumber(number.doubleValue()); } else { yaml.writeNumber(number.longValue()); } break; case nullValue: yaml.writeNull(); break; default: break; } }
@SuppressWarnings("rawtypes") static boolean eqNotNull(Number a, Number b) { Class clazzA = a.getClass(); boolean isIntA = isInt(clazzA); Class clazzB = a.getClass(); boolean isIntB = isInt(clazzB); if (isIntA && isIntB) { return a.longValue() == b.longValue(); } boolean isDoubleA = isDouble(clazzA); boolean isDoubleB = isDouble(clazzB); if ((isDoubleA && isDoubleB) || (isDoubleA && isIntA) || (isDoubleB && isIntA)) { return a.doubleValue() == b.doubleValue(); } return false; }
/** * Coerces the value to be a number of the specified type; needed because all numbers come back * from the datastore as Long and this screws up any type that expects something smaller. Also * does toString just for the hell of it. */ Object coerceNumber(Number value, Class<?> type) { if ((type == Byte.class) || (type == Byte.TYPE)) return value.byteValue(); else if ((type == Short.class) || (type == Short.TYPE)) return value.shortValue(); else if ((type == Integer.class) || (type == Integer.TYPE)) return value.intValue(); else if ((type == Long.class) || (type == Long.TYPE)) return value.longValue(); else if ((type == Float.class) || (type == Float.TYPE)) return value.floatValue(); else if ((type == Double.class) || (type == Double.TYPE)) return value.doubleValue(); else if (type == String.class) return value.toString(); else throw new IllegalArgumentException( "Don't know how to convert " + value.getClass() + " to " + type); }
protected void createNumberField(String name, boolean typify, Number value) { if (value == null) { return; } String valueString = String.valueOf(value); createSortableNumericField(name, typify, valueString, value.getClass()); createField(name, valueString); }
@Override @SuppressWarnings({"unchecked"}) public Expression<Number> quot(Number number, Expression<? extends Number> expression) { if (expression == null || number == null) { throw new IllegalArgumentException("arguments to quot() cannot be null"); } final Class resultType = BinaryArithmeticOperation.determineResultType( number.getClass(), expression.getJavaType(), true); return new BinaryArithmeticOperation<Number>( this, resultType, BinaryArithmeticOperation.Operation.DIVIDE, number, expression); }
@Override public NumericValue<? extends Number> multiply(NumericValue<? extends Number> other) { Number otherNumber = other.getValue(); if (otherNumber instanceof Integer) { return new IntegerValue(value * otherNumber.intValue()); } if (otherNumber instanceof Double) { return new DoubleValue(value * otherNumber.doubleValue()); } if (otherNumber instanceof Long) { return new LongValue(value * otherNumber.longValue()); } throw new AssertionError("The type " + otherNumber.getClass() + " was not expected"); }
public void testDefaultConstructor() throws Exception { MapSpecification.Builder<Number, Integer, Number> builder = new MapSpecification.Builder<Number, Integer, Number>() .setJobName("bla") .setInput(new Input1()) .setMapper(new MapOnlyMapper1()) .setOutput(new Output1()); MapSpecification<Number, Integer, Number> spec = builder.build(); Number result = InProcessMap.runMap(spec).getOutputResult(); assertEquals(Integer.class, result.getClass()); assertEquals(15, result.intValue()); MapOnlyMapper<Number, Integer> mapper = MapOnlyMapper.forMapper(new Mapper1()); builder = new MapSpecification.Builder<Number, Integer, Number>() .setJobName("bla") .setInput(new Input1()) .setMapper(mapper) .setOutput(new Output1()); spec = builder.build(); result = InProcessMap.runMap(spec).getOutputResult(); assertEquals(Integer.class, result.getClass()); assertEquals(15, result.intValue()); }
protected void putNumber(String name, Number n) { if (n instanceof Integer || n instanceof Short || n instanceof Byte || n instanceof AtomicInteger) { _put(NUMBER_INT, name); _buf.writeInt(n.intValue()); } else if (n instanceof Long || n instanceof AtomicLong) { _put(NUMBER_LONG, name); _buf.writeLong(n.longValue()); } else if (n instanceof Float || n instanceof Double) { _put(NUMBER, name); _buf.writeDouble(n.doubleValue()); } else { throw new IllegalArgumentException("can't serialize " + n.getClass()); } }
private XSpinnerNumberModel alterarModel(Number newStep) { XSpinnerNumberModel newModel = null; if (newStep instanceof Integer) { newModel = new XSpinnerNumberModel.IntXSpinnerNumberModel(); newModel.setExtendedStep(this.getModelAsXModel().getExtendedStep().intValue()); newModel.setMaximum( (Comparable) (((Number) this.getModelAsXModel().getMaximum()).intValue())); newModel.setMinimum( (Comparable) (((Number) this.getModelAsXModel().getMinimum()).intValue())); newModel.setValue(((Number) this.getModelAsXModel().getMinimum()).intValue()); } else if (newStep instanceof Double) { newModel = new XSpinnerNumberModel.DoubleXSpinnerNumberModel(); newModel.setExtendedStep(this.getModelAsXModel().getExtendedStep().doubleValue()); newModel.setMaximum( (Comparable) (((Number) this.getModelAsXModel().getMaximum()).doubleValue())); newModel.setMinimum( (Comparable) (((Number) this.getModelAsXModel().getMinimum()).doubleValue())); newModel.setValue(((Number) this.getModelAsXModel().getMinimum()).doubleValue()); } else if (newStep instanceof BigDecimal) { newModel = new XSpinnerNumberModel.BigDecimalXSpinnerNumberModel(); newModel.setExtendedStep( new BigDecimal(this.getModelAsXModel().getExtendedStep().doubleValue())); newModel.setMaximum( (Comparable) (new BigDecimal(((Number) this.getModelAsXModel().getMaximum()).doubleValue()))); newModel.setMinimum( (Comparable) (new BigDecimal(((Number) this.getModelAsXModel().getMinimum()).doubleValue()))); newModel.setValue( new BigDecimal(((Number) this.getModelAsXModel().getMinimum()).doubleValue())); } else { throw new IllegalArgumentException( "Tipo sem NumberModel adequado:" + newStep.getClass().getName()); } newModel.setStepSize(newStep); this.extendedStep = newModel.getExtendedStep(); this.maximum = (Number) newModel.getMaximum(); this.minimum = (Number) newModel.getMinimum(); this.setValue(newModel.getValue()); return newModel; }
/** * Accepts a number as input and returns its value in byte form in MSB aligned form example: input * = 5000 [1001110001000] bytes = -114, 64 [10011100] [01000000] * * @param Number input * @param int numBits - the number of bits to be returned * @return byte[] */ public static byte[] toByteArray(Number input, int numBits) { Class<? extends Number> dataType = input.getClass(); short size = 0; long longValue = input.longValue(); if (dataType == Short.class) { size = Short.SIZE; } else if (dataType == Integer.class) { size = Integer.SIZE; } else if (dataType == Long.class) { size = Long.SIZE; } else { throw new IllegalArgumentException("Parameter must one of the following: Short/Int/Long\n"); } int length = size / NetUtils.NumBitsInAByte; byte bytes[] = new byte[length]; byte[] inputbytes = new byte[length]; byte shiftedBytes[]; // Getting the bytes from input value for (int i = 0; i < length; i++) { bytes[i] = (byte) ((longValue >> (NetUtils.NumBitsInAByte * (length - i - 1))) & ByteMask); } if ((bytes[0] == 0 && dataType == Long.class) || (bytes[0] == 0 && dataType == Integer.class)) { int index = 0; for (index = 0; index < length; ++index) { if (bytes[index] != 0) { bytes[0] = bytes[index]; break; } } System.arraycopy(bytes, index, inputbytes, 0, length - index); Arrays.fill(bytes, length - index + 1, length - 1, (byte) 0); } else { System.arraycopy(bytes, 0, inputbytes, 0, length); } shiftedBytes = shiftBitsToMSB(inputbytes, numBits); return shiftedBytes; }
private String convertNumber(Number number) { if (Integer.class.isInstance(number)) { return NumericUtils.intToPrefixCoded(number.intValue()); } else if (Double.class.isInstance(number)) { return NumericUtils.doubleToPrefixCoded(number.doubleValue()); } else if (Long.class.isInstance(number)) { return NumericUtils.longToPrefixCoded(number.longValue()); } else if (Float.class.isInstance(number)) { return NumericUtils.floatToPrefixCoded(number.floatValue()); } else if (Byte.class.isInstance(number)) { return NumericUtils.intToPrefixCoded(number.intValue()); } else if (Short.class.isInstance(number)) { return NumericUtils.intToPrefixCoded(number.intValue()); } else if (BigDecimal.class.isInstance(number)) { return NumericUtils.doubleToPrefixCoded(number.doubleValue()); } else if (BigInteger.class.isInstance(number)) { return NumericUtils.longToPrefixCoded(number.longValue()); } else { throw new IllegalArgumentException("Unsupported numeric type " + number.getClass().getName()); } }
@Override public long hash(Number v) { // have to use a bit of reflection to ensure good hash values since // we don't have truely type specific stats if (v instanceof Long) { return hasher.hashLong(v.longValue()).asLong(); } else if (v instanceof Integer) { return hasher.hashInt(v.intValue()).asLong(); } else if (v instanceof Double) { return hasher.hashLong(Double.doubleToRawLongBits(v.doubleValue())).asLong(); } else if (v instanceof Float) { return hasher.hashInt(Float.floatToRawIntBits(v.floatValue())).asLong(); } else if (v instanceof Byte) { return hasher.newHasher().putByte(v.byteValue()).hash().asLong(); } else if (v instanceof Short) { return hasher.newHasher().putShort(v.shortValue()).hash().asLong(); } // else... throw new SolrException( SolrException.ErrorCode.SERVER_ERROR, "Unsupported Numeric Type (" + v.getClass() + ") for hashing: " + statsField); }
public static NumericConverter resolveConverter(Number value) { Class type = value.getClass(); if (Double.class == type) { return DOUBLE; } if (Long.class == type) { return LONG; } if (Float.class == type) { return FLOAT; } if (Integer.class == type) { return INTEGER; } if (Short.class == type) { return SHORT; } if (Byte.class == type) { return BYTE; } return DOUBLE; }
/** * Check whether value represents a whole number * * @param value * @return */ private static boolean isInt(Number value) { if (value instanceof Long || value instanceof Integer || value instanceof Short || value instanceof Byte || value instanceof BigInteger) { return true; } final BigDecimal bigDecimalValue; if (value instanceof Double || value instanceof Float) { bigDecimalValue = new BigDecimal(value.toString()); } else if (value instanceof BigDecimal) { bigDecimalValue = (BigDecimal) value; } else { throw new IllegalArgumentException("Unexpected dataType: " + value.getClass().getName()); } try { bigDecimalValue.longValueExact(); return true; } catch (ArithmeticException e) { return false; } }