@Override public void setUnits(Unit unit) { this.unit = unit.toString(); }
public Unit buildUnit(double multiplier, int scale, Kind kind, double exponent) { Unit unit = new Unit(doc.getLevel(), doc.getVersion()); unit.setKind(kind); unit.setMultiplier(multiplier); unit.setScale(scale); unit.setExponent(exponent); return unit; }
/** * Checks whether the given {@link Unit} and the {@link Unit} represented by * the given {@link String} are equivalent. * * @param unit * @param units * @return * @see #areEquivalent(Unit, Unit) */ public static boolean areEquivalent(Unit unit, String units) { return areEquivalent(unit, new Unit(1d, 0, Unit.Kind.valueOf(units), 1d, unit.getLevel(), unit.getVersion())); }
/** * * @return {@code true} if this Unit is a variant of length. */ public boolean isVariantOfLength() { Kind kind = getKind(); // Meter only allowed in Level 1 or -1 (level undefined) return (getLevel() < 2 && (kind == Kind.METER)) || (kind == Kind.METRE) && (getOffset() == 0d) && (getExponent() == 1d); }
/** * Returns {@code true} if this Unit is a variant of area, meaning of {@link Kind#METRE} * with an exponent of 2. * * @return {@code true} if this Unit is a variant of area. */ public boolean isVariantOfArea() { Kind kind = getKind(); return (kind == Kind.METER) || (kind == Kind.METRE) && (getOffset() == 0d) && (getExponent() == 2d); }
/** * Predicate for testing whether this Unit is of the {@link Kind} * {@link Kind#DIMENSIONLESS}. A unit is also dimensionless if it does not * declare an offset and at the same time its exponent is zero. In this case * the unit represents a dimensionless quantity. * * @return True if this unit represents a dimensionless quantity, i.e., its * {@link Kind} is {@link Kind#DIMENSIONLESS} or offset = exponent = 0 */ public boolean isDimensionless() { return (kind == Kind.DIMENSIONLESS) || ((getOffset() == 0d) && (getExponent() == 0d)); }
@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; }
Kind k1 = unit1.getKind(); Kind k2 = unit2.getKind(); boolean equivalent = Kind.areEquivalent(k1, k2); if (equivalent || unit1.isDimensionless() || unit2.isDimensionless()) { int s1 = unit1.getScale(), s2 = unit2.getScale(); 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(); double e2 = k2 == Kind.DIMENSIONLESS && unit2.getExponent() != 0d ? 0d : unit2.getExponent(); if (unit1.getOffset() != 0d) { unit1.setOffset(0d); e1 = unit1.getExponent(); e2 = unit2.getExponent(); removeScale(unit1); removeScale(unit2); newScale = 0d; newExponent = unit1.getExponent() + unit2.getExponent(); if (newExponent == 0d) { newMultiplier = 1d; } else if (unit1.getMultiplier() != unit2.getMultiplier()) { m1 = unit1.getMultiplier(); m2 = unit2.getMultiplier(); e1 = unit1.getExponent();
@Override public Map<String, String> writeXMLAttributes() { Map<String, String> attributes = super.writeXMLAttributes(); int level = getLevel(), version = getVersion(); Locale en = Locale.ENGLISH; if (isSetKind()) { attributes.put("kind", getKind().toString().toLowerCase()); if (isSetScale()) { attributes.put("scale", Integer.toString(getScale())); if (isSetMultiplier()) { attributes.put("multiplier", StringTools.toString(en, getMultiplier())); if (isSetOffset()) { attributes.put("offset", StringTools.toString(en, getOffset())); if (isSetExponent()) { if (2 < level) { attributes.put("exponent", StringTools.toString(en, getExponent())); } else { int exponent = (int) getExponent(); attributes.put("exponent", Integer.toString((int) getExponent())); if (exponent - getExponent() != 0d) { logger.warn(MessageFormat.format( ResourceManager.getBundle("org.sbml.jsbml.resources.cfg.Messages").getString("LOSS_OF_INFORMATION_DUE_TO_ROUNDING"), getExponent(), exponent));
return null; } else if (!(isPredefined(id, level) || (Unit.isUnitKind(id, level, version)))) { logger.warn(MessageFormat.format( "No such predefined unit ''{0}'' in SBML Level {1,number,integer}.", id, Unit u = new Unit(); u.putUserObject(JSBML.ALLOW_INVALID_SBML, Boolean.TRUE); u.setLevel(level); u.setVersion(version); u.initDefaults(2, 4, true); u.setKind(Kind.MOLE); } else if (id.equals(VOLUME)) { u.setKind(Kind.LITRE); } else if (id.equals(AREA)) { u.setKind(Kind.METRE); u.setExponent(2d); } else if (id.equals(LENGTH)) { u.setKind(Kind.METRE); } else if (id.equals(TIME)) { u.setKind(Kind.SECOND); } else { Kind kind = null; u.setKind(kind);
Unit unit1 = ud.getUnit(0); Unit unit2 = ud.getUnit(1); if (unit1.isVariantOfSubstance()) { Unit two = unit2.clone(); two.setExponent(-two.getExponent()); return two.isVariantOfTime(); } else if (unit2.isVariantOfSubstance()) { Unit one = unit1.clone(); one.setExponent(-one.getExponent()); return one.isVariantOfTime();
@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()); } }
Unit unit = unit1.clone(); if (!(unit.isDimensionless() || unit.isInvalid())) { unit.setExponent(-unit1.getExponent()); for (int i = getUnitCount() - 1; (i >= 0) && !contains; i--) { Unit u = getUnit(i); if (Unit.Kind.areEquivalent(u.getKind(), unit.getKind()) || u.isDimensionless() || unit.isDimensionless() || u.isInvalid() || unit.isInvalid()) { if (u.isDimensionless()) { Unit.merge(unit, removeUnit(i)); break; } else { Unit.merge(u, unit); contains = true; unit.unsetMetaId(); addUnit(unit);
Kind kind = getKind(); if ((kind == Kind.MOLE) || (kind == Kind.ITEM) || ((((getLevel() == 2) && (getVersion() > 1)) || (getLevel() > 2)) && ((kind == Kind.GRAM) || isKilogram())) || (getLevel() > 2 && kind == Kind.AVOGADRO)) if (getLevelAndVersion().compareTo(3, 1) <= 0) { return (getOffset() == 0d) && (getExponent() == 1d); } else { return (getOffset() == 0d);
double mult = unit.getMultiplier(); double exp = unit.getExponent(); int scale = unit.getScale(); int l = unit.getLevel(); int v = unit.getVersion(); UnitDefinition ud = new UnitDefinition(l, v); switch (unit.getKind()) { case AMPERE: ud.addUnit(new Unit(mult, scale, Kind.AMPERE, exp, l, v)); break; ud.addUnit(new Unit(Math.pow(mult, -1d), scale, Kind.SECOND, -exp, l, v)); break; ud.addUnit(new Unit(mult, scale, Kind.CANDELA, exp, l, v)); break; Unit newUnit = new Unit(mult, scale, Kind.KELVIN, exp, l, v); newUnit.setOffset(273.15); ud.addUnit(newUnit); break; ud.addUnit(new Unit(mult, scale, Kind.AMPERE, exp, l, v)); ud.addUnit(new Unit(mult, scale, Kind.SECOND, exp, l, v)); break; ud.addUnit(new Unit(mult, scale, Kind.DIMENSIONLESS, exp, l, v));
if (Unit.Kind.areEquivalent(u.getKind(), s.getKind()) || u.isDimensionless() || s.isDimensionless() || u.isInvalid() || s.isInvalid()) { if (s.isDimensionless()) { Unit.merge(u, removeUnit(i + 1)); } else { Unit.merge(s, removeUnit(i)); && (getUnit(0).getKind().equals(Kind.DIMENSIONLESS))) { u = removeUnit(0); Unit.merge(getUnit(0), u); if (!Unit.Kind.areEquivalent(u.getKind(), s.getKind()) && !u.isDimensionless() && !s.isDimensionless() && !u.isInvalid() && !s.isInvalid()) { int s1 = u.getScale(); int s2 = s.getScale(); double e1 = u.getExponent(); double e2 = s.getExponent(); double p1 = s1 * e1; double p2 = s2 * e2; u.setScale((int) newScale); s.setScale(0);
for (int i = getUnitCount() - 1; (i >= 0) && !contains; i--) { Unit u = getUnit(i); if (Unit.Kind.areEquivalent(u.getKind(), unit.getKind()) || u.isDimensionless() || unit.isDimensionless() || u.isInvalid() || unit.isInvalid()) { if (u.isDimensionless()) { unit = unit.clone(); Unit.merge(unit, removeUnit(i)); break; } else { Unit.merge(u, unit); contains = true; Unit u = unit.clone(); u.unsetMetaId(); addUnit(u);
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)) { mean = (Math.abs(u1.getScale()) + Math.abs(u2.getScale())) / 2; if (u1.getScale() > mean) { scale1 = Math.abs(u1.getScale()) - mean; scale2 = mean - u2.getScale(); scale2 = Math.abs(u2.getScale()) - mean; scale1 = mean - u1.getScale(); if (u1.getExponent() < 0) { scale1 = -scale1; scale2 = -scale2; v1 = v1 * Math.pow(10d, -scale1 * u1.getExponent()); v2 = v2 * Math.pow(10d, -scale2 * u2.getExponent()); v1 = v1 * Math.pow(10d, scale1 * u1.getExponent()); v2 = v2 * Math.pow(10d, scale2 * u2.getExponent()); if (u1.getMultiplier() > 1d) { v1 = v1 * u1.getMultiplier(); u1.setMultiplier(1d);
/** * * @param rootExponent * @param radiant * @return * @throws SBMLException */ private <T> ASTNode2Value<Double> root(double rootExponent, ASTNode2Value radiant) throws SBMLException { UnitDefinition ud = radiant.getUnits().clone(); for (Unit u : ud.getListOfUnits()) { if ((((u.getExponent() / rootExponent) % 1d) != 0d) && !u.isDimensionless() && !u.isInvalid()) { new UnitException(MessageFormat.format( "Cannot perform power or root operation due to incompatibility with a unit exponent. Given are {0,number} as the exponent of the unit and {1,number} as the root exponent for the current computation.", u.getExponent(), rootExponent)); } if (!(u.isDimensionless() || u.isInvalid())) { u.setExponent(u.getExponent() / rootExponent); } } ASTNode2Value<Double> value = new ASTNode2Value<Double>(ud, this); value.setValue(Double.valueOf(Math.pow(radiant.toDouble(), 1d / rootExponent))); return value; }
sb.append(unit.printUnit()); } else { sb.append(unit.getKind().getName().toLowerCase()); sb.append(MessageFormat.format( " (exponent = {0}, multiplier = {1}, scale = {2})", StringTools.toString(unit.getExponent()), StringTools.toString(unit.getMultiplier()), unit.getScale()));