/* * Making sure that the user input is in range * @param1 Scanner object for input * @param2 lowerbound integer * @param3 upperbound integer * @param4 String that specifies for which attribute/field input is for * printing purposes * @param5 ValType enum that specifies whether the primitive value is * an int or double * @param6 boolean that specifies whether the input is an Enum value * @param7 boolean that specifies whether to return the value if out of * range (false) or not (true) */ public static Number makeSureValInRange( Scanner input, int lowerbound, int upperbound, String inputFor, ValType valType, boolean enumeration, boolean withinRange) { boolean valid = !withinRange; Number val = 0; while (!valid) { System.out.println(inputString(inputFor, null, StringOption.SELECT, enumeration)); val = valType == ValType.INTEGER ? input.nextInt() : input.nextDouble(); if (val.intValue() < lowerbound || val.intValue() > upperbound) { System.out.println(inputString(inputFor, null, StringOption.INCORRECT, enumeration)); } else { valid = true; } } return val; }
public void saveDisplayObjectType() { DOTPoint newDOTPoint = (DOTPoint) _dotDefinitionDialogFrame.getScratchDisplayObjectType().getCopy(null); final String name = _dotDefinitionDialogFrame.getNameText(); if ((name == null) || (name.length() == 0)) { JOptionPane.showMessageDialog( new JFrame(), "Bitte geben Sie einen Namen an!", "Fehler", JOptionPane.ERROR_MESSAGE); return; } if (!_dotDefinitionDialogFrame.isReviseOnly()) { if (_dotDefinitionDialogFrame.getDotManager().containsDisplayObjectType(name)) { JOptionPane.showMessageDialog( new JFrame(), "Ein Darstellungstyp mit diesem Namen existiert bereits!", "Fehler", JOptionPane.ERROR_MESSAGE); return; } } newDOTPoint.setName(name); newDOTPoint.setInfo(_dotDefinitionDialogFrame.getInfoText()); final Object value = _translationFactorSpinner.getValue(); if (value instanceof Number) { final Number number = (Number) value; newDOTPoint.setTranslationFactor(number.doubleValue()); } newDOTPoint.setJoinByLine(_joinByLineCheckBox.isSelected()); _dotDefinitionDialogFrame.getDotManager().saveDisplayObjectType(newDOTPoint); _dotDefinitionDialogFrame.setDisplayObjectType(newDOTPoint, true); }
protected void prepare( Map stormConf, final TopologyContext context, final IOutputCollector collector) { _rand = new Random(); _collector = collector; _context = context; heartbeatTimeoutMills = getHeartbeatTimeoutMillis(stormConf); _process = new NuShellProcess(_command, this, this); // subprocesses must send their pid first thing Number subpid = _process.launch(stormConf, context); LOG.info("Launched subprocess with pid " + subpid); this.pid = subpid.longValue(); /** * randomizing the initial delay would prevent all shell bolts from heartbeating at the same * time frame */ int initialDelayMillis = random.nextInt(4000) + 1000; BoltHeartbeatTimerTask task = new BoltHeartbeatTimerTask(this); heartBeatExecutorService.scheduleAtFixedRate( task, initialDelayMillis, getHeartbeatPeriodMillis(stormConf), TimeUnit.MILLISECONDS); }
/** {@inheritDoc} */ @Override protected void updateMinMax(Number min, Number max) { // we always use the double values, because that way the response Object class is // consistent regardless of whether we only have 1 value or many that we min/max // // TODO: would be nice to have subclasses for each type of Number ... breaks backcompat if (computeMin) { // nested if to encourage JIT to optimize aware final var? if (null != min) { double minD = min.doubleValue(); if (null == this.min || minD < this.minD) { // Double for result & cached primitive doulbe to minimize unboxing in future comparisons this.min = this.minD = minD; } } } if (computeMax) { // nested if to encourage JIT to optimize aware final var? if (null != max) { double maxD = max.doubleValue(); if (null == this.max || this.maxD < maxD) { // Double for result & cached primitive doulbe to minimize unboxing in future comparisons this.max = this.maxD = maxD; } } } }
private int DomainMin() { double smallest = Double.MAX_VALUE; for (Number d : dates) { if (d.doubleValue() < smallest) smallest = d.doubleValue(); } return (int) (smallest / 86400); }
public Object call(Scope sc, Object pointsInt, Object fo00000o[]) { Number n = (Number) (sc.getThis()); int num = 0; if (pointsInt != null && pointsInt instanceof Number) num = ((Number) pointsInt).intValue(); double mult = Math.pow(10, num); long foo = Math.round(n.doubleValue() * mult); double d = foo; d = d / mult; String s = String.valueOf(d); int idx = s.indexOf("."); if (idx < 0) { if (num > 0) { s += "."; while (num > 0) { s += "0"; num--; } } return new JSString(s); } if (s.length() - idx <= num) { // need more int toAdd = (num + 1) - (s.length() - idx); for (int i = 0; i < toAdd; i++) s += "0"; return new JSString(s); } if (num == 0) return s.substring(0, idx); return new JSString(s.substring(0, idx + 1 + num)); }
/** * Tests if this object is equal to another * * @param a_obj the other object * @return true: this object is equal to the other one * @author Klaus Meffert * @since 2.3 */ public boolean equals(final Object a_obj) { if (a_obj == null) { return false; } if (a_obj == this) { return true; } if (!(a_obj instanceof KeyedValues)) { return false; } final KeyedValues kvs = (KeyedValues) a_obj; final int count = size(); if (count != kvs.size()) { return false; } for (int i = 0; i < count; i++) { final Comparable k1 = getKey(i); final Comparable k2 = kvs.getKey(i); if (!k1.equals(k2)) { return false; } final Number v1 = getValue(i); final Number v2 = kvs.getValue(i); if (v1 == null) { if (v2 != null) { return false; } } else { if (!v1.equals(v2)) { return false; } } } return true; }
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; } }
public Matrix createVector(BitVector selector) { int rows = selector != null ? selector.countOnBits() : frame.size(); Matrix m = new Matrix(rows, 1); for (int i = 0, j = 0; j < frame.size(); j++) { if (selector == null || selector.isOn(j)) { M rowValue = frame.object(j); try { Number numValue = (Number) numericField.get(rowValue); m.set(i, 0, numValue.doubleValue()); } catch (IllegalAccessException e) { e.printStackTrace(); throw new IllegalStateException( String.format( "Couldn't access field %s: %s", numericField.getName(), e.getMessage())); } i++; } } return m; }
private Double FindMaximum() { Double greatest = 0.0; for (Number d : weights) { if (d.doubleValue() > greatest) greatest = d.doubleValue(); } Double bit = 1 - greatest % 1; return greatest + bit; }
private Double FindMinimum() { Double smallest = 1000.0; for (Number d : weights) { if (d.doubleValue() < smallest.doubleValue()) smallest = d.doubleValue(); } Double bit = smallest % 1; return smallest - bit; }
private int DomainMax() { double greatest = 0.0; for (Number d : dates) { if (d.doubleValue() > greatest) greatest = d.doubleValue(); } return (int) (greatest / 86400); }
@Override public long getLong(final String key) { final Number number = this.extractNumber(this.findLastTag(key)); if (number == null) { return 0L; } return number.longValue(); }
@Override public int getInt(final String key) { final Number number = this.extractNumber(this.findLastTag(key)); if (number == null) { return 0; } return number.intValue(); }
@Override public double getDouble(final String key) { final Number number = this.extractNumber(this.findLastTag(key)); if (number == null) { return 0.0; } return number.doubleValue(); }
/** Return a double parsed from the given string, possibly formatted with a "%" sign */ public static double parseDouble(String val) throws NumberFormatException, ParseException { NumberFormat formatPercent = NumberFormat.getPercentInstance(Locale.US); // for zoom factor if (val.indexOf("%") == -1) { // not in percent format ! return Double.parseDouble(val); } // else it's a percent format -> parse it Number n = formatPercent.parse(val); return n.doubleValue(); }
public boolean setDefault(MutableAttributeSet target) { Number old = (Number) target.getAttribute(swingName); if (old == null) old = swingDefault; if (old != null && ((scale == 1f && old.intValue() == rtfDefault) || (Math.round(old.floatValue() * scale) == rtfDefault))) return true; set(target, rtfDefault); return true; }
/** * Looks up the given key in the given map, converting the result into a {@link Float}. First, * {@link #getNumber(Map,Object)} is invoked. If the result is null, then null is returned. * Otherwise, the float value of the resulting {@link Number} is returned. * * @param map the map whose value to look up * @param key the key whose value to look up in that map * @return a {@link Float} or null */ public static Float getFloat(Map map, Object key) { Number answer = getNumber(map, key); if (answer == null) { return null; } else if (answer instanceof Float) { return (Float) answer; } return new Float(answer.floatValue()); }
private Double getPositiveFraction(List<? extends Number> intervals) { long success = 0; long fail = 0; for (Number interval : intervals) { if (interval.doubleValue() < 0.0) fail++; else success++; } return 1.0 * (success) / (success + fail); }
/** @param args the command line arguments */ public static void main(String[] args) { // TODO code application logic here print(); showauthor(); JavaAccessPractice test = JavaAccessPractice.getInstance(); System.out.print(test); System.out.print("Number is:" + Number.returnint(Number.ZERO) + "\n"); System.out.print("Number is:" + Number.returnint(Number.ONE) + "\n"); }
/** * Looks up the given key in the given map, converting the result into a {@link Double}. First, * {@link #getNumber(Map,Object)} is invoked. If the result is null, then null is returned. * Otherwise, the double value of the resulting {@link Number} is returned. * * @param map the map whose value to look up * @param key the key whose value to look up in that map * @return a {@link Double} or null */ public static Double getDouble(Map map, Object key) { Number answer = getNumber(map, key); if (answer == null) { return null; } else if (answer instanceof Double) { return (Double) answer; } return new Double(answer.doubleValue()); }
/** * Looks up the given key in the given map, converting the result into an {@link Integer}. First, * {@link #getNumber(Map,Object)} is invoked. If the result is null, then null is returned. * Otherwise, the integer value of the resulting {@link Number} is returned. * * @param map the map whose value to look up * @param key the key whose value to look up in that map * @return an {@link Integer} or null */ public static Integer getInteger(Map map, Object key) { Number answer = getNumber(map, key); if (answer == null) { return null; } else if (answer instanceof Integer) { return (Integer) answer; } return new Integer(answer.intValue()); }
/** * Looks up the given key in the given map, converting the result into a {@link Long}. First, * {@link #getNumber(Map,Object)} is invoked. If the result is null, then null is returned. * Otherwise, the long value of the resulting {@link Number} is returned. * * @param map the map whose value to look up * @param key the key whose value to look up in that map * @return a {@link Long} or null */ public static Long getLong(Map map, Object key) { Number answer = getNumber(map, key); if (answer == null) { return null; } else if (answer instanceof Long) { return (Long) answer; } return new Long(answer.longValue()); }
/** * Looks up the given key in the given map, converting the result into a {@link Short}. First, * {@link #getNumber(Map,Object)} is invoked. If the result is null, then null is returned. * Otherwise, the short value of the resulting {@link Number} is returned. * * @param map the map whose value to look up * @param key the key whose value to look up in that map * @return a {@link Short} or null */ public static Short getShort(Map map, Object key) { Number answer = getNumber(map, key); if (answer == null) { return null; } else if (answer instanceof Short) { return (Short) answer; } return new Short(answer.shortValue()); }
/** * Looks up the given key in the given map, converting the result into a {@link Byte}. First, * {@link #getNumber(Map,Object)} is invoked. If the result is null, then null is returned. * Otherwise, the byte value of the resulting {@link Number} is returned. * * @param map the map whose value to look up * @param key the key whose value to look up in that map * @return a {@link Byte} or null */ public static Byte getByte(Map map, Object key) { Number answer = getNumber(map, key); if (answer == null) { return null; } else if (answer instanceof Byte) { return (Byte) answer; } return new Byte(answer.byteValue()); }
public String getInvalidValueText(Frame frame, Slot slot, Object value, Collection facetValues) { String result = null; Number n = (Number) CollectionUtilities.getFirstItem(facetValues); if (n != null) { double max = n.doubleValue(); result = getInvalidValueText(max, value); } return result; }
/** * This does not explicitly delete the names because its assumed the recalculation will clean it * up. */ public boolean deleteSystemOfRecordPerson( final SorPerson sorPerson, final boolean mistake, final String terminationTypes) { Assert.notNull(sorPerson, "sorPerson cannot be null."); final String terminationTypeToUse = terminationTypes != null ? terminationTypes : Type.TerminationTypes.UNSPECIFIED.name(); final Person person = this.personRepository.findByInternalId(sorPerson.getPersonId()); Assert.notNull(person, "person cannot be null."); if (mistake) { Set<Role> rolesToDelete = new HashSet<Role>(); for (final SorRole sorRole : sorPerson.getRoles()) { for (final Role role : person.getRoles()) { if (sorRole.getId().equals(role.getSorRoleId())) { rolesToDelete.add(role); } } } for (final Role role : rolesToDelete) { // let sorRoleElector delete the role and add another role if required sorRoleElector.removeCalculatedRole( person, role, this.personRepository.getSoRRecordsForPerson(person)); } final Number number = this.personRepository.getCountOfSoRRecordsForPerson(person); if (number.intValue() == 1) { this.personRepository.deletePerson(person); } this.personRepository.deleteSorPerson(sorPerson); return true; } // we do this explicitly here because once they're gone we can't re-calculate? We might move to // this to the recalculateCalculatedPerson method. final Type terminationReason = this.referenceRepository.findType(Type.DataTypes.TERMINATION, terminationTypeToUse); for (final SorRole sorRole : sorPerson.getRoles()) { for (final Role role : person.getRoles()) { if (!role.isTerminated() && sorRole.getId().equals(role.getSorRoleId())) { role.expireNow(terminationReason, true); } } } this.personRepository.deleteSorPerson(sorPerson); this.personRepository.savePerson(person); Person p = recalculatePersonBiodemInfo(person, sorPerson, RecalculationType.DELETE, mistake); this.personRepository.savePerson(p); return true; }
public float getFloat(Prop<? extends Number> n, float def) { Object x = get(n); if (x instanceof Float[]) return ((Float[]) x)[0].floatValue(); if (x instanceof Boolean) return ((Boolean) x).booleanValue() ? 1 : 0f; if (x instanceof float[]) return ((float[]) x)[0]; Number gotten = (Number) x; if (gotten != null) return gotten.floatValue(); return def; }
private static String getInvalidValueText(double max, Object value) { String result = null; if (value instanceof Number) { Number n = (Number) value; if (n.doubleValue() > max) { result = "The maximum value is " + max; } } return result; }
/** * Overrides the parent implementation to provide a more efficient mechanism for generating * primary keys, while generating the primary key support on the fly. * * @param count the batch size * @param entity the entity requesting primary keys * @param channel open JDBCChannel * @return NSArray of NSDictionary where each dictionary corresponds to a unique primary key value */ public NSArray newPrimaryKeys(int count, EOEntity entity, JDBCChannel channel) { if (isPrimaryKeyGenerationNotSupported(entity)) { return null; } EOAttribute attribute = (EOAttribute) entity.primaryKeyAttributes().lastObject(); String attrName = attribute.name(); boolean isIntType = "i".equals(attribute.valueType()); NSMutableArray results = new NSMutableArray(count); String sequenceName = sequenceNameForEntity(entity); DB2Expression expression = new DB2Expression(entity); boolean succeeded = false; for (int tries = 0; !succeeded && tries < 2; tries++) { while (results.count() < count) { try { StringBuffer sql = new StringBuffer(); sql.append("SELECT "); sql.append("next value for " + sequenceName + " AS KEY"); sql.append(" from sysibm.sysdummy1"); expression.setStatement(sql.toString()); channel.evaluateExpression(expression); try { NSDictionary row; while ((row = channel.fetchRow()) != null) { Enumeration pksEnum = row.allValues().objectEnumerator(); while (pksEnum.hasMoreElements()) { Number pkObj = (Number) pksEnum.nextElement(); Number pk; if (isIntType) { pk = Integer.valueOf(pkObj.intValue()); } else { pk = Long.valueOf(pkObj.longValue()); } results.addObject(new NSDictionary(pk, attrName)); } } } finally { channel.cancelFetch(); } succeeded = true; } catch (JDBCAdaptorException ex) { throw ex; } } } if (results.count() != count) { throw new IllegalStateException( "Unable to generate primary keys from the sequence for " + entity + "."); } return results; }