@Override public TypedValue getValueInternal(ExpressionState state) throws EvaluationException { SpelNodeImpl leftOp = getLeftOperand(); SpelNodeImpl rightOp = getRightOperand(); Object operandOne = leftOp.getValueInternal(state).getValue(); Object operandTwo = rightOp.getValueInternal(state).getValue(); if (operandOne instanceof Number && operandTwo instanceof Number) { Number op1 = (Number) operandOne; Number op2 = (Number) operandTwo; if (op1 instanceof Double || op2 instanceof Double) { return new TypedValue(Math.pow(op1.doubleValue(), op2.doubleValue())); } else if (op1 instanceof Long || op2 instanceof Long) { double d = Math.pow(op1.longValue(), op2.longValue()); return new TypedValue((long) d); } else { double d = Math.pow(op1.longValue(), op2.longValue()); if (d > Integer.MAX_VALUE) { return new TypedValue((long) d); } else { return new TypedValue((int) d); } } } return state.operate(Operation.POWER, operandOne, operandTwo); }
/** * 获取shardKey所在的表名 * * @return */ public String getTableName(String table, Number shardKey) { if (orMapping.getShardCount() <= 1 || shardKey == null || shardKey.longValue() <= 0) { return table; } return table + calShardNum(shardKey.longValue()); }
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 String saveTxn(TransactionVO currentTransaction) throws ParseException { insertTransaction = new SimpleJdbcInsert(getDataSource()) .withTableName("transaction") .usingGeneratedKeyColumns("id"); SqlParameterSource parameters = new MapSqlParameterSource() .addValue("dateReported", getMySQLSaveDate(currentTransaction.getDateReported())) .addValue("customerId", currentTransaction.getCustomerId()) .addValue("productCategory", currentTransaction.getProductCategory()) .addValue("makeId", currentTransaction.getMakeId()) .addValue("modelId", currentTransaction.getModelId()) .addValue("serialNo", currentTransaction.getSerialNo()) .addValue("accessories", currentTransaction.getAccessories()) .addValue("complaintReported", currentTransaction.getComplaintReported()) .addValue("complaintDiagnosed", currentTransaction.getComplaintDiagonsed()) .addValue("engineerRemarks", currentTransaction.getEnggRemark()) .addValue("repairAction", currentTransaction.getRepairAction()) .addValue("note", currentTransaction.getNotes()) .addValue("status", currentTransaction.getStatus()) .addValue("createdOn", currentTransaction.getCreatedOn()) .addValue("modifiedOn", currentTransaction.getModifiedOn()) .addValue("createdBy", currentTransaction.getCreatedBy()) .addValue("modifiedBy", currentTransaction.getModifiedBy()); Number newId = insertTransaction.executeAndReturnKey(parameters); LOG.info(" the queryForInt resulted in " + newId.longValue()); currentTransaction.setId(newId.longValue()); // update the tag No String tagNo = "WON2N" + newId.longValue(); String query = "update transaction set TagNo = '" + tagNo + "' where id =" + newId.longValue(); getJdbcTemplate().update(query); return tagNo; }
static boolean equals(Object o1, Object o2) { if (o1 == o2) return true; if (o1 instanceof JsonObject) { return objectEquals(((JsonObject) o1).map, o2); } if (o1 instanceof Map<?, ?>) { return objectEquals((Map<?, ?>) o1, o2); } if (o1 instanceof JsonArray) { return JsonArray.arrayEquals(((JsonArray) o1).getList(), o2); } if (o1 instanceof List<?>) { return JsonArray.arrayEquals((List<?>) o1, o2); } if (o1 instanceof Number && o2 instanceof Number && o1.getClass() != o2.getClass()) { Number n1 = (Number) o1; Number n2 = (Number) o2; if (o1 instanceof Float || o1 instanceof Double || o2 instanceof Float || o2 instanceof Double) { return n1.doubleValue() == n2.doubleValue(); } else { return n1.longValue() == n2.longValue(); } } return o1.equals(o2); }
/** * This method is invoked when the builtin is called in a rule body. * * @param args the array of argument values for the builtin, this is an array of Nodes, some of * which may be Node_RuleVariables. * @param length the length of the argument list, may be less than the length of the args array * for some rule engines * @param context an execution context giving access to other relevant data * @return return true if the buildin predicate is deemed to have succeeded in the current * environment */ public boolean bodyCall(Node[] args, int length, RuleContext context) { checkArgs(length, context); BindingEnvironment env = context.getEnv(); Node n1 = getArg(0, args, context); Node n2 = getArg(1, args, context); if (n1.isLiteral() && n2.isLiteral()) { Object v1 = n1.getLiteralValue(); Object v2 = n2.getLiteralValue(); Node sum = null; if (v1 instanceof Number && v2 instanceof Number) { Number nv1 = (Number) v1; Number nv2 = (Number) v2; if (v1 instanceof Float || v1 instanceof Double || v2 instanceof Float || v2 instanceof Double) { sum = Util.makeDoubleNode(nv1.doubleValue() - nv2.doubleValue()); } else { sum = Util.makeLongNode(nv1.longValue() - nv2.longValue()); } return env.bind(args[2], sum); } } // Doesn't (yet) handle partially bound cases return false; }
public void importarPendientes(Long sucursalId) { String sql = "select * from sx_clientes_log where tx_importado is null"; JdbcTemplate template = ReplicaServices.getInstance().getJdbcTemplate(sucursalId); List<Map<String, Object>> rows = template.queryForList(sql); for (Map<String, Object> row : rows) { System.out.println("Importando: " + row); try { Number cliente_id = (Number) row.get("CLIENTE_ID"); HibernateTemplate source = ReplicaServices.getInstance().getHibernateTemplate(sucursalId); List<Cliente> clientes = source.find( "from Cliente c " + " left join fetch c.direcciones d" + " left join fetch c.telefonos t" + " where c.id=?", cliente_id.longValue()); Cliente c = clientes.get(0); Services.getInstance().getHibernateTemplate().replicate(c, ReplicationMode.IGNORE); } catch (Exception e) { logger.error("Error importando cliente: " + row, e); } try { Number id = (Number) row.get("ID"); String update = "UPDATE SX_CLIENTES_LOG SET TX_IMPORTADO=NOW() WHERE ID=?"; template.update(update, new Object[] {id.longValue()}); } catch (Exception e) { logger.error("Error actualizando importado: " + row); } } }
private static Object toType(Number val, int returnType) { switch (returnType) { case DataTypes.W_DOUBLE: case DataTypes.DOUBLE: return val.doubleValue(); case DataTypes.W_FLOAT: case DataTypes.FLOAT: return val.floatValue(); case DataTypes.INTEGER: case DataTypes.W_INTEGER: return val.intValue(); case DataTypes.W_LONG: case DataTypes.LONG: return val.longValue(); case DataTypes.W_SHORT: case DataTypes.SHORT: return val.shortValue(); case DataTypes.BIG_DECIMAL: return new BigDecimal(val.doubleValue()); case DataTypes.BIG_INTEGER: return BigInteger.valueOf(val.longValue()); case DataTypes.STRING: return val.doubleValue(); } throw new RuntimeException("internal error: " + returnType); }
/** @return The hashing values for the user source that were stored in the backup */ public Hashing getHashing() { prisms.util.LongList mults = new prisms.util.LongList(); prisms.util.LongList mods = new prisms.util.LongList(); try { if (!"hashing".equals(theJsonReader.getNextProperty())) return null; JsonSerialReader.StructState rootState = theJsonReader.startObject(); try { if (!"multiples".equals(theJsonReader.getNextProperty())) return null; theJsonReader.startArray(); Number num; do { num = theJsonReader.parseNumber(); if (num != null) mults.add(num.longValue()); } while (num != null); theJsonReader.endArray(null); if (!"modulos".equals(theJsonReader.getNextProperty())) return null; theJsonReader.startArray(); do { num = theJsonReader.parseNumber(); if (num != null) mods.add(num.longValue()); } while (num != null); theJsonReader.endArray(null); } finally { theJsonReader.endObject(rootState); } } catch (Exception e) { log.error("Could not read JSON backup data", e); return null; } Hashing ret = new Hashing(); ret.setPrimaryHashing(mults.toArray(), mods.toArray()); return ret; }
public static int compare(Number param, Number threshold) throws Throwable { try { int eval = 0; if (threshold instanceof Double) { eval = Double.compare(param.doubleValue(), threshold.doubleValue()); } else if (threshold instanceof Float) { eval = Float.compare(param.floatValue(), threshold.floatValue()); } else if (threshold instanceof Long) { eval = (Long.valueOf(param.longValue())).compareTo(Long.valueOf(threshold.longValue())); } else if (threshold instanceof Integer) { eval = param.intValue() > threshold.intValue() ? 1 : -1; } return eval; } catch (VirtualMachineError err) { SystemFailure.initiateFailure(err); // If this ever returns, rethrow the error. We're poisoned // now, so don't let this thread continue. throw err; } catch (Throwable e) { // Whenever you catch Error or Throwable, you must also // catch VirtualMachineError (see above). However, there is // _still_ a possibility that you are dealing with a cascading // error condition, so you also need to check to see if the JVM // is still usable: SystemFailure.checkFailure(); throw e; } }
private Number incrValue(int dir) { Number newValue; if ((value instanceof Float) || (value instanceof Double)) { double v = value.doubleValue() + (stepSize.doubleValue() * (double) dir); if (value instanceof Double) { newValue = new Double(v); } else { newValue = new Float(v); } } else { long v = value.longValue() + (stepSize.longValue() * (long) dir); if (value instanceof Long) { newValue = new Long(v); } else if (value instanceof Integer) { newValue = new Integer((int) v); } else if (value instanceof Short) { newValue = new Short((short) v); } else { newValue = new Byte((byte) v); } } if ((maximum != null) && (maximum.compareTo(newValue) < 0)) { return null; } if ((minimum != null) && (minimum.compareTo(newValue) > 0)) { return null; } else { return newValue; } }
/** * Expression may return number value which is not directly compatible with feature type (e.g. * Double when Integer is expected), or EEnumLiteral meta-object when literal instance is expected * * @generated */ public static Object performCast(Object value, EDataType targetType) { if (targetType instanceof EEnum) { if (value instanceof EEnumLiteral) { EEnumLiteral literal = (EEnumLiteral) value; return (literal.getInstance() != null) ? literal.getInstance() : literal; } } if (false == value instanceof Number || targetType == null || targetType.getInstanceClass() == null) { return value; } Class<?> targetClass = targetType.getInstanceClass(); Number num = (Number) value; Class<?> valClass = value.getClass(); Class<?> targetWrapperClass = targetClass; if (targetClass.isPrimitive()) { targetWrapperClass = EcoreUtil.wrapperClassFor(targetClass); } if (valClass.equals(targetWrapperClass)) { return value; } if (Number.class.isAssignableFrom(targetWrapperClass)) { if (targetWrapperClass.equals(Byte.class)) return new Byte(num.byteValue()); if (targetWrapperClass.equals(Integer.class)) return new Integer(num.intValue()); if (targetWrapperClass.equals(Short.class)) return new Short(num.shortValue()); if (targetWrapperClass.equals(Long.class)) return new Long(num.longValue()); if (targetWrapperClass.equals(BigInteger.class)) return BigInteger.valueOf(num.longValue()); if (targetWrapperClass.equals(Float.class)) return new Float(num.floatValue()); if (targetWrapperClass.equals(Double.class)) return new Double(num.doubleValue()); if (targetWrapperClass.equals(BigDecimal.class)) return new BigDecimal(num.doubleValue()); } return value; }
@Override public void update(Object[] accRow, Object val) { if (val != null) { Number value = (Number) val; if (fieldType == Double.class || fieldType == Float.class) { ((DoubleSum) accRow[outPos]).update(value.doubleValue()); } else if (fieldType == Integer.class || fieldType == Byte.class || fieldType == Short.class) { value = value.longValue(); Number sum = (Number) accRow[outPos]; if (sum != null) { if (fieldType == Long.class) { value = sum.longValue() + value.longValue(); } else if (fieldType == BigInteger.class) { value = ((BigInteger) sum).add((BigInteger) value); } else if (fieldType == BigDecimal.class) { value = ((BigDecimal) sum).add((BigDecimal) value); } else { // byte, short, int value = sum.intValue() + value.intValue(); } } accRow[outPos] = value; } } }
/** * Constructs a new <code>LongRange</code> with the specified minimum and maximum numbers (both * inclusive). * * <p>The arguments may be passed in the order (min,max) or (max,min). The getMinimum and * getMaximum methods will return the correct values. * * @param number1 first number that defines the edge of the range, inclusive * @param number2 second number that defines the edge of the range, inclusive * @throws IllegalArgumentException if either number is <code>null</code> */ public LongRange(Number number1, Number number2) { super(); if (number1 == null || number2 == null) { throw new IllegalArgumentException("The numbers must not be null"); } long number1val = number1.longValue(); long number2val = number2.longValue(); if (number2val < number1val) { this.min = number2val; this.max = number1val; if (number2 instanceof Long) { this.minObject = (Long) number2; } if (number1 instanceof Long) { this.maxObject = (Long) number1; } } else { this.min = number1val; this.max = number2val; if (number1 instanceof Long) { this.minObject = (Long) number1; } if (number2 instanceof Long) { this.maxObject = (Long) number2; } } }
public long getNextSequence(TypeDescriptor typeDescriptor, Session session) { // check if there is an id in the cache ConcurrentLinkedQueue cachedIds = (ConcurrentLinkedQueue) this.typeDescriptorToIdCache.get(typeDescriptor); if (null == cachedIds) { typeDescriptorToIdCache.putIfAbsent(typeDescriptor, new ConcurrentLinkedQueue()); cachedIds = (ConcurrentLinkedQueue) this.typeDescriptorToIdCache.get(typeDescriptor); } Number cachedId = (Number) cachedIds.poll(); if (cachedId == null) { synchronized (cachedIds) { cachedId = (Number) cachedIds.poll(); if (cachedId == null) { List newIds = this.getNextSequenceImpl(typeDescriptor, session); Assert.condition(0 < newIds.size()); // reserve first for own use cachedId = (Number) newIds.remove(0); cachedIds.addAll(newIds); } } } if (trace.isDebugEnabled()) { trace.debug("returning unique ID: " + cachedId.longValue()); } return cachedId.longValue(); }
public Number compute(Number d1, Number d2) { long d2Long = d2.longValue(); if (d2Long == 0) { return null; } return d1.longValue() / d2Long; }
@Override public JSONRPC2Response process(final Map<String, Object> params) { try { final Number tid = HandlerUtils.<Number>fetchField(MonitoringHandler.TENANT, params, true, null); final Number dpid = HandlerUtils.<Number>fetchField(MonitoringHandler.VDPID, params, false, -1); final OVXMap map = OVXMap.getInstance(); final LinkedList<Map<String, Object>> flows = new LinkedList<Map<String, Object>>(); if (dpid.longValue() == -1) { HashMap<String, Object> res = new HashMap<String, Object>(); for (OVXSwitch vsw : map.getVirtualNetwork(tid.intValue()).getSwitches()) { flows.clear(); final Collection<OVXFlowMod> fms = vsw.getFlowTable().getFlowTable(); for (final OVXFlowMod flow : fms) { final Map<String, Object> entry = flow.toMap(); flows.add(entry); } res.put(vsw.getSwitchName(), flows.clone()); } this.resp = new JSONRPC2Response(res, 0); } else { final OVXSwitch vsw = map.getVirtualNetwork(tid.intValue()).getSwitch(dpid.longValue()); final Collection<OVXFlowMod> fms = vsw.getFlowTable().getFlowTable(); for (final OVXFlowMod flow : fms) { final Map<String, Object> entry = flow.toMap(); flows.add(entry); } this.resp = new JSONRPC2Response(flows, 0); } } catch (ClassCastException | MissingRequiredField e) { this.resp = new JSONRPC2Response( new JSONRPC2Error( JSONRPC2Error.INVALID_PARAMS.getCode(), this.cmdName() + ": Unable to fetch virtual topology : " + e.getMessage()), 0); } catch (final InvalidDPIDException e) { this.resp = new JSONRPC2Response( new JSONRPC2Error( JSONRPC2Error.INVALID_PARAMS.getCode(), this.cmdName() + ": Unable to fetch virtual topology : " + e.getMessage()), 0); } catch (NetworkMappingException e) { this.resp = new JSONRPC2Response( new JSONRPC2Error( JSONRPC2Error.INVALID_PARAMS.getCode(), this.cmdName() + ": Unable to fetch virtual topology : " + e.getMessage()), 0); } return this.resp; }
public static Number OR(Number a, Number b) { if (a.longValue() > 0) { return a; } if (b.longValue() > 0) { return b; } return a; }
public static Object virtual_calculateCompileTimeConstantValue_1587718783752756055( SNode thisNode, Object leftValue, Object rightValue) { if (leftValue instanceof Number && rightValue instanceof Number) { Number a = (Number) leftValue; Number b = (Number) rightValue; if (BinaryOperation_Behavior.call_bothShouldBeWidenedTo_6205351058571053912( MetaAdapterFactory.getConcept( 0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xfbdeb6fecfL, "jetbrains.mps.baseLanguage.structure.BinaryOperation"), Double.class, a, b)) { return a.doubleValue() < b.doubleValue(); } if (BinaryOperation_Behavior.call_bothShouldBeWidenedTo_6205351058571053912( MetaAdapterFactory.getConcept( 0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xfbdeb6fecfL, "jetbrains.mps.baseLanguage.structure.BinaryOperation"), Float.class, a, b)) { return a.floatValue() < b.floatValue(); } if (BinaryOperation_Behavior.call_bothShouldBeWidenedTo_6205351058571053912( MetaAdapterFactory.getConcept( 0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xfbdeb6fecfL, "jetbrains.mps.baseLanguage.structure.BinaryOperation"), Long.class, a, b)) { return a.longValue() < b.longValue(); } if (BinaryOperation_Behavior.call_bothShouldBeWidenedTo_6205351058571053912( MetaAdapterFactory.getConcept( 0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xfbdeb6fecfL, "jetbrains.mps.baseLanguage.structure.BinaryOperation"), Integer.class, a, b)) { return a.intValue() < b.intValue(); } } else if (leftValue instanceof Character && rightValue instanceof Character) { return ((Character) leftValue).charValue() < ((Character) rightValue).charValue(); } return null; }
@Override boolean compare(Object queryValue, Object storedValue) { List<Integer> queryList = typecast(command + " clause", queryValue, List.class); enforce(queryList.size() == 2, command + " clause must be a List of size 2"); Number modulus = queryList.get(0); Number expectedValue = queryList.get(1); return (storedValue != null) && (typecast("value", storedValue, Number.class).longValue()) % modulus.longValue() == expectedValue.longValue(); }
protected Number subtractNumbers(Number nOne, Number nTwo) { assert nOne != null; assert nTwo != null; if (nOne instanceof Double || nTwo instanceof Double) { return Double.valueOf(nOne.doubleValue() - nTwo.doubleValue()); } else if (nOne instanceof Long || nTwo instanceof Long) { return Long.valueOf(nOne.longValue() - nTwo.longValue()); } else { return Integer.valueOf(nOne.intValue() - nTwo.intValue()); } }
@SuppressWarnings("unchecked") @Override public Function<Object[], ?> visit(UnaryExpression e) { final Function<Object[], ?> first = e.getFirst().accept(this); switch (e.getExpressionType()) { case ExpressionType.ArrayLength: return t -> Array.getLength(first.apply(t)); case ExpressionType.BitwiseNot: return (Function<Object[], ?>) bitwiseNot((Function<Object[], Number>) first); case ExpressionType.Convert: final Class<?> to = e.getResultType(); if (to.isPrimitive() || Number.class.isAssignableFrom(to)) return t -> { Object source = first.apply(t); if (source instanceof Number) { Number result = (Number) source; if (to.isPrimitive()) { if (to == Integer.TYPE) return result.intValue(); if (to == Long.TYPE) return result.longValue(); if (to == Float.TYPE) return result.floatValue(); if (to == Double.TYPE) return result.doubleValue(); if (to == Byte.TYPE) return result.byteValue(); if (to == Character.TYPE) return (char) result.intValue(); if (to == Short.TYPE) return result.shortValue(); } else if (result != null) { if (to == BigInteger.class) return BigInteger.valueOf(result.longValue()); if (to == BigDecimal.class) return BigDecimal.valueOf(result.doubleValue()); } } if (source instanceof Character) { if (to == Integer.TYPE) return (int) (char) source; if (to == Long.TYPE) return (long) (char) source; if (to == Float.TYPE) return (float) (char) source; if (to == Double.TYPE) return (double) (char) source; } return to.cast(source); }; return first; case ExpressionType.IsNull: return first.andThen(r -> r == null); case ExpressionType.LogicalNot: return normalize(not((Function<Object[], Boolean>) first)); case ExpressionType.Negate: return (Function<Object[], ?>) negate((Function<Object[], Number>) first); case ExpressionType.Quote: return constant(first); // case ExpressionType.UnaryPlus: // return abs((Function<? extends Number, Object[]>) first); default: throw new IllegalArgumentException(ExpressionType.toString(e.getExpressionType())); } }
private long updateTimeSinceStart(List<CompletableFuture<Map<String, Number>>> responseList) throws Exception { long timeSinceStartMax = 0; for (Future<Map<String, Number>> f : responseList) { Map<String, Number> m = f.get(); Number timeSinceStart = m.get(TIME_SINCE_START); if (timeSinceStart.longValue() > timeSinceStartMax) { timeSinceStartMax = timeSinceStart.longValue(); } } return timeSinceStartMax; }
public Number add(Number x) { if (x instanceof Integer) { return set(Integer.valueOf(number.intValue() + x.intValue())); } if (x instanceof Long) { return set(Long.valueOf(number.longValue() + x.longValue())); } if (x instanceof Double) { return set(Double.valueOf(number.doubleValue() + x.doubleValue())); } return number; }
/** * @param lhs * @param rhs * @return */ protected Number divide(Number lhs, Number rhs) { Number result = null; if (isFloat(lhs) || isFloat(rhs)) { result = lhs.doubleValue() / rhs.doubleValue(); } else { if (isLong(lhs) || isLong(rhs)) { result = lhs.longValue() / lhs.longValue(); } else { result = lhs.intValue() / rhs.intValue(); } } return result; }
@Override public Number evaluate(Object... na) { if (!(na[0] instanceof Number) || !(na[1] instanceof Number)) return null; Number na1 = (Number) na[0]; Number na2 = (Number) na[1]; if (na1 instanceof Double || na2 instanceof Double) return na1.doubleValue() % na2.doubleValue(); else if (na1 instanceof Float || na2 instanceof Float) return na1.floatValue() % na2.floatValue(); else if (na1 instanceof Long || na2 instanceof Long) return na1.longValue() % na2.longValue(); else if (na1 instanceof Integer || na2 instanceof Integer) return na1.intValue() % na2.intValue(); return na1.byteValue() % na2.byteValue(); }
public Object calculate() { Number lval = (Number) calculateItem(this.left); Number rval = (Number) calculateItem(this.right); if (rval instanceof Double || lval instanceof Double) { return lval.doubleValue() <= rval.doubleValue(); } if (rval instanceof Float || lval instanceof Float) { return lval.floatValue() <= rval.floatValue(); } if (rval instanceof Long || lval instanceof Long) { return lval.longValue() <= rval.longValue(); } return lval.intValue() <= rval.intValue(); }
@Override // TODO: recursive expressions as operands public boolean process( ProvaReagent prova, ProvaDerivationNode node, ProvaGoal goal, List<ProvaLiteral> newLiterals, ProvaRule query) { ProvaLiteral literal = goal.getGoal(); List<ProvaVariable> variables = query.getVariables(); ProvaList terms = (ProvaList) literal.getTerms().cloneWithVariables(variables); ProvaObject[] data = terms.getFixed(); if (data.length != 3) return false; ProvaObject lt = data[0]; if (lt instanceof ProvaVariablePtr) { ProvaVariablePtr varPtr = (ProvaVariablePtr) lt; lt = variables.get(varPtr.getIndex()).getRecursivelyAssigned(); } if (!((lt instanceof ProvaVariable) || (lt instanceof ProvaConstant))) return false; ProvaObject a1 = data[1]; if (a1 instanceof ProvaVariablePtr) { ProvaVariablePtr varPtr = (ProvaVariablePtr) a1; a1 = variables.get(varPtr.getIndex()).getRecursivelyAssigned(); } if (!(a1 instanceof ProvaConstant)) return false; Object oa1 = ((ProvaConstant) a1).getObject(); if (!(oa1 instanceof Number)) return false; ProvaObject a2 = data[2]; if (a2 instanceof ProvaVariablePtr) { ProvaVariablePtr varPtr = (ProvaVariablePtr) a2; a2 = variables.get(varPtr.getIndex()).getRecursivelyAssigned(); } if (!(a2 instanceof ProvaConstant)) return false; Object oa2 = ((ProvaConstant) a2).getObject(); if (!(oa2 instanceof Number)) return false; Number na1 = (Number) oa1; Number na2 = (Number) oa2; Number result; if (na1 instanceof Double || na2 instanceof Double) result = na1.doubleValue() * na2.doubleValue(); else if (na1 instanceof Float || na2 instanceof Float) result = na1.floatValue() * na2.floatValue(); else if (na1 instanceof Long || na2 instanceof Long) result = na1.longValue() * na2.longValue(); else if (na1 instanceof Integer || na2 instanceof Integer) result = na1.intValue() * na2.intValue(); else result = na1.byteValue() * na2.byteValue(); if (lt instanceof ProvaConstant) return ((ProvaConstant) lt).getObject() == result; ((ProvaVariable) lt).setAssigned(ProvaConstantImpl.create(result)); return true; }
/** Return the string for the object passed in. */ protected String doGetString(Object value) { if (value instanceof Number) { Number num = (Number) value; switch (fNumberType) { case BYTE: if (num.byteValue() == Byte.MAX_VALUE) return sMaxValue; else if (num.byteValue() == Byte.MIN_VALUE) return sMinValue; else break; case DOUBLE: if (num.doubleValue() == Double.MAX_VALUE) return sMaxValue; else if (num.doubleValue() == Double.MIN_VALUE) return sMinValue; case FLOAT: if (fNumberType == FLOAT) { if (num.floatValue() == Float.MAX_VALUE) return sMaxValue; else if (num.floatValue() == Float.MIN_VALUE) return sMinValue; } // The formatter doesn't handle big/small floats. (i.e. more than the MIN digits we set). // It doesn't go to scientific notation as necessary. The only way to test this is to // roundtrip the number. If they come up to be the same, then it is ok. Else format using // toString. String result = fFormatter.format(value); try { Number roundTrip = fFormatter.parse(result); if (roundTrip.doubleValue() != num.doubleValue()) result = value.toString(); } catch (ParseException e) { result = value.toString(); } return result; case INTEGER: if (num.intValue() == Integer.MAX_VALUE) return sMaxValue; else if (num.intValue() == Integer.MIN_VALUE) return sMinValue; else break; case LONG: if (num.longValue() == Long.MAX_VALUE) return sMaxValue; else if (num.longValue() == Long.MIN_VALUE) return sMinValue; else break; case SHORT: if (num.shortValue() == Short.MAX_VALUE) return sMaxValue; else if (num.shortValue() == Short.MIN_VALUE) return sMinValue; else break; default: break; } return fFormatter.format(value); } else { return null; // Invalid or null. No string to display. } }
public static boolean greatThan(Number num1, Number num2) { if (num1 == null || num2 == null) { return false; } if (num1 instanceof Long && num2 instanceof Long) { return num1.longValue() > num2.longValue(); } else if (num1 instanceof Long && num2 instanceof Integer) { return num1.longValue() > num2.intValue(); } else if (num1 instanceof Integer && num2 instanceof Long) { return num1.intValue() > num2.longValue(); } else if (num1 instanceof Integer && num2 instanceof Integer) { return num1.intValue() > num2.intValue(); } return false; }