@Override public int hashCode() { final int prime = 823; int hashCode = super.hashCode(); hashCode += prime * Double.valueOf(getMultiplier()).hashCode(); hashCode += prime * getScale(); hashCode += prime * Double.valueOf(getExponent()).hashCode(); hashCode += prime * Double.valueOf(getOffset()).hashCode(); if (isSetKind()) { hashCode += prime * getKind().hashCode(); } return hashCode; }
/** * Creates a Unit instance from a given Unit. * * @param unit */ public Unit(Unit unit) { super(unit); exponent = unit.exponent != null ? Double.valueOf(unit.getExponent()) : null; multiplier = unit.multiplier != null ? new Double(unit.getMultiplier()) : null; offset = unit.offset != null ? new Double(unit.getOffset()) : null; scale = unit.scale != null ? Integer.valueOf(unit.getScale()) : null; kind = unit.isSetKind() ? unit.getKind() : Kind.INVALID; isSetExponent = unit.isSetExponent; isSetMultiplier = unit.isSetMultiplier; isSetOffset = unit.isSetOffset; isSetScale = unit.isSetScale; }
/** * Produces a text formula representation of this unit. */ public String printUnit() { StringBuffer times = new StringBuffer(); if (getMultiplier() != 0d) { if (getMultiplier() != 1d) { times.append(StringTools.toString(getMultiplier())); } StringBuffer pow = new StringBuffer(); pow.append(kind != null ? kind.getSymbol() : "undefined"); String prefix = getPrefix(); if ((prefix.length() > 0) && !prefix.startsWith("10")) { pow.insert(0, prefix); } else if (getScale() != 0) { pow = FormulaCompiler.times(FormulaCompiler.pow(Integer.valueOf(10), getScale()), pow); } times = FormulaCompiler.times(times, pow); } if ((offset != null) && (offset.doubleValue() != 0d)) { times = FormulaCompiler.sum(StringTools.toString(offset.doubleValue()), times); } return FormulaCompiler.pow(times, StringTools.toString(getExponent())).toString(); }
/** * <p> * Predicate returning true or false depending on whether two Unit objects * are identical. * </p> * <p> * Two Unit objects are considered to be identical if they match in all * attributes. (Contrast this to the method areEquivalent(Unit unit1, Unit * unit2), which compares Unit objects only with respect to certain * attributes.) * </p> * * @param unit1 * the first Unit object to compare * @param unit2 * the second Unit object to compare * @return {@code true} if all the attributes of unit1 are identical to the * attributes of unit2, {@code false} otherwise. * @see #areEquivalent */ public static boolean areIdentical(Unit unit1, Unit unit2) { boolean identical = areEquivalent(unit1, unit2); identical &= unit1.getOffset() == unit2.getOffset(); identical &= unit1.getMultiplier() == unit2.getMultiplier(); return identical && unit1.getScale() == unit2.getScale(); }
/** * * @param u * @return */ @SuppressWarnings("deprecation") public static String toHTML(Unit u) { StringBuffer times = new StringBuffer(); if (u.getMultiplier() != 0) { if (u.getMultiplier() != 1) { times.append(StringTools.toString(u.getMultiplier())); } StringBuffer pow = new StringBuffer(); pow.append(u.getKind().getSymbol()); String prefix = u.getPrefix(); if (prefix.length() > 0 && !prefix.startsWith("10")) { pow.insert(0, prefix); } else if (u.getScale() != 0) { pow.insert(0, ' '); pow = HTMLFormula.times(HTMLFormula.pow(Integer.valueOf(10), u .getScale()), pow); } times = HTMLFormula.times(times, pow); } if (u.getOffset() != 0) { times = HTMLFormula.sum(StringTools.toString(u.getOffset()), times); } return HTMLFormula.pow(times, StringTools.toString(u.getExponent())) .toString(); }
@Override @SuppressWarnings("deprecation") public void setUnits(Unit unit) { if ((unit.getExponent() != 1) || (unit.getScale() != 0) || (unit.getMultiplier() != 1d) || (unit.getOffset() != 0d)) { StringBuilder sb = new StringBuilder(); sb.append('_'); sb.append(unit.getMultiplier()); sb.append('_'); sb.append(unit.getScale()); sb.append('_'); sb.append(unit.getKind().toString()); sb.append('_'); sb.append(unit.getExponent()); UnitDefinition ud = new UnitDefinition(sb.toString().replace('.', '_'), getLevel(), getVersion()); ud.addUnit(unit); Model m = getModel(); if (m != null) { m.addUnitDefinition(ud); } setUnits(ud); } else { // must be a base unit setUnits(unit.getKind().toString().toLowerCase()); } }
/** * * @param u * @return */ public static String toHTML(Unit u) { StringBuffer times = new StringBuffer(); if (u.getMultiplier() != 0) { if (u.getMultiplier() != 1) { times.append(StringTools.toString(u.getMultiplier())); } StringBuffer pow = new StringBuffer(); pow.append(u.getKind().getSymbol()); String prefix = u.getPrefix(); if (prefix.length() > 0 && !prefix.startsWith("10")) { pow.insert(0, prefix); } else if (u.getScale() != 0) { pow.insert(0, ' '); pow = HTMLFormula.times(HTMLFormula.pow(Integer.valueOf(10), u .getScale()), pow); } times = HTMLFormula.times(times, pow); } if (u.getOffset() != 0) { times = HTMLFormula.sum(StringTools.toString(u.getOffset()), times); } return HTMLFormula.pow(times, StringTools.toString(u.getExponent())) .toString(); }
" (exponent = {0}, multiplier = {1}, scale = {2})", StringTools.toString(unit.getExponent()), StringTools.toString(unit.getMultiplier()), unit.getScale()));
/** * Manipulates the attributes of the Unit to express the unit with the value * of the scale attribute reduced to zero. * * For example, 1 millimetre can be expressed as a Unit with kind= 'metre' * multiplier='1' scale='-3' exponent='1'. It can also be expressed as a * Unit with kind='metre' multiplier='0.001' scale='0' exponent='1'. * * @return */ public Unit removeScale() { if (isSetScale() && (getScale() != 0)) { setMultiplier(getMultiplier() * Math.pow(10, getScale())); setScale(0); } return this; }
@Override @Deprecated public void setUnits(Unit unit) { UnitDefinition ud = new UnitDefinition(unit.getKind().toString(), getLevel(), getVersion()); ud.addUnit(unit); if ((unit.getExponent() != 1) || (unit.getScale() != 0) || (unit.getMultiplier() != 1d) || (unit.getOffset() != 0d)) { StringBuilder sb = new StringBuilder(); sb.append(unit.getMultiplier()); sb.append('_'); sb.append(unit.getScale()); sb.append('_'); sb.append(unit.getKind().toString()); sb.append('_'); sb.append(unit.getExponent()); ud.setId(sb.toString()); Model m = getModel(); if (m != null) { m.addUnitDefinition(ud); } } setUnits(ud); }
@Override public boolean equals(Object object) { boolean equals = super.equals(object); if (equals) { Unit u = (Unit) object; equals &= getMultiplier() == u.getMultiplier(); equals &= getScale() == u.getScale(); equals &= getExponent() == u.getExponent(); equals &= getOffset() == u.getOffset(); equals &= getKind() == u.getKind(); } return equals; }
@Override @Deprecated public void setUnits(Unit unit) { if (!unit.isVariantOfSubstance() && !unit.isVariantOfTime()) { throw new IllegalArgumentException(MessageFormat.format( ILLEGAL_UNIT_KIND_EXCEPTION_MSG, unit.toString())); } if ((unit.getExponent() != 1) || (unit.getScale() != 0) || (unit.getMultiplier() != 1d) || (unit.getOffset() != 0d)) { StringBuilder sb = new StringBuilder(); sb.append(unit.getMultiplier()); sb.append('_'); sb.append(unit.getScale()); sb.append('_'); sb.append(unit.getKind().toString()); sb.append('_'); sb.append(unit.getExponent()); UnitDefinition ud = new UnitDefinition(sb.toString(), getLevel(), getVersion()); ud.addUnit(unit); Model m = getModel(); if (m != null) { m.addUnitDefinition(ud); } setUnits(ud.getId()); } else { setUnits(unit.getKind().toString()); } }
double multiplier = getMultiplier(); if (multiplier != 1d) { double exp = Math.log10(multiplier);
/** * We remove the offset by expressing it within a new {@link #multiplier}, * m': * <p> * m' = {@link #offset} / 10^{@link #scale} + {@link #multiplier} * <p> * When inserting this again into the unit formula, the offset vanishes: * <p> * (({@link #offset} + {@link #multiplier} * 10^{@link #scale}) * * {@link #kind})^{@link #exponent} * <p> * then becomes * <p> * (0 + ({@link #offset} / 10^{@link #scale} + {@link #multiplier}) * 10^{@link #scale} * {@link #kind})^{@link #exponent} = * <p> * (m' * 10^{@link #scale} * {@link #kind})^{@link #exponent} * <p> * This is possible because offset and multiplier are real double numbers. * * @return this {@link Unit} whose {@link #offset} and {@link #multiplier} * might have been changed in case that there was an {@link #offset} * defined that was different to zero. */ public Unit removeOffset() { if (isSetOffset() && (getOffset() != 0d)) { setMultiplier(getOffset() / Math.pow(10, getScale()) + getMultiplier()); setOffset(0d); } return this; }
attributes.put("multiplier", StringTools.toString(en, getMultiplier()));
Unit u1 = left.getUnits().getUnit(i); Unit u2 = right.getUnits().getUnit(i); if (((u1.getMultiplier() != u2.getMultiplier()) && (u1.getScale() != u2.getScale()) && (u1.getExponent() != u2.getExponent())) && (u1.getMultiplier() != 0d) && (u2.getMultiplier() != 0d)) { if (u1.getMultiplier() > 1d) { v1 = v1 * u1.getMultiplier(); u1.setMultiplier(1d); if (u2.getMultiplier() > 1d) { v2 = v2 * u2.getMultiplier(); u2.setMultiplier(1d);
Unit u1 = left.getUnits().getUnit(i); Unit u2 = right.getUnits().getUnit(i); if ((u1 != null && u2 != null) && ((u1.getMultiplier() != u2.getMultiplier()) && (u1.getScale() != u2.getScale()) && (u1.getExponent() != u2.getExponent())) && (u1.getMultiplier() != 0d) && (u2.getMultiplier() != 0d)) { if (u1.getMultiplier() > 1d) { v1 = v1 * u1.getMultiplier(); u1.setMultiplier(1d); if (u2.getMultiplier() > 1d) { v2 = v2 * u2.getMultiplier(); u2.setMultiplier(1d);
double m1 = unit1.getOffset() / Math.pow(10, s1) + unit1.getMultiplier(); double m2 = unit2.getOffset() / Math.pow(10, s2) + unit2.getMultiplier(); double e1 = k1 == Kind.DIMENSIONLESS && unit1.getExponent() != 0d ? 0d : unit1.getExponent(); if (newExponent == 0d) { newMultiplier = 1d; } else if (unit1.getMultiplier() != unit2.getMultiplier()) { m1 = unit1.getMultiplier(); m2 = unit2.getMultiplier(); e1 = unit1.getExponent(); e2 = unit2.getExponent(); unit1.setOffset(unit2.getOffset()); unit1.setMultiplier(unit2.getMultiplier()); unit1.setScale(unit2.getScale()); unit1.setExponent(unit2.getExponent());
@Override @SuppressWarnings("deprecation") public String getDerivedUnits() { UnitDefinition ud = getDerivedUnitDefinition(); Model m = getModel(); if (m != null) { if (m.getUnitDefinition(ud.getId()) != null) { return ud.getId(); } } if (ud.getUnitCount() == 1) { Unit u = ud.getUnit(0); if ((u.getOffset() == 0) && (u.getMultiplier() == 1) && (u.getScale() == 0) && (u.getExponent() == 1)) { return u.getKind().toString().toLowerCase(); } } return null; }
double mult = unit.getMultiplier(); double exp = unit.getExponent(); int scale = unit.getScale();