Package tech.units.indriya

Class AbstractUnit<Q extends Quantity<Q>>

  • All Implemented Interfaces:
    Serializable, Comparable<Unit<Q>>, Unit<Q>, tech.uom.lib.common.function.Nameable, tech.uom.lib.common.function.PrefixOperator<Q>, tech.uom.lib.common.function.SymbolSupplier
    Direct Known Subclasses:
    AlternateUnit, AnnotatedUnit, BaseUnit, ProductUnit, TransformedUnit
    public abstract class AbstractUnit<Q extends Quantity<Q>>
extends Object
implements Unit<Q>, Comparable<Unit<Q>>, tech.uom.lib.common.function.PrefixOperator<Q>, tech.uom.lib.common.function.Nameable, Serializable, tech.uom.lib.common.function.SymbolSupplier

    The class represents units founded on the seven SI base units for seven base quantities assumed to be mutually independent.

    For all physics units, unit conversions are symmetrical: u1.getConverterTo(u2).equals(u2.getConverterTo(u1).inverse()). Non-physical units (e.g. currency units) for which conversion is not symmetrical should have their own separate class hierarchy and are considered distinct (e.g. financial units), although they can always be combined with physics units (e.g. "€/Kg", "$/h").

    Since:
    1.0
    Version:
    4.1, October 4, 2024
    Author:
    Jean-Marie Dautelle, Werner Keil
    See Also:
    Wikipedia: International System of Units, Serialized Form

    • Constructor Detail

      • AbstractUnit

        protected AbstractUnit()
        Default constructor.

      • AbstractUnit

        protected AbstractUnit​(String symbol)
        Constructor setting a symbol.
        Parameters:
        symbol - the unit symbol.

    • Method Detail

      • isSystemUnit

        public boolean isSystemUnit()
        Indicates if this unit belongs to the set of coherent SI units (unscaled SI units). The base and coherent derived units of the SI form a coherent set, designated the set of coherent SI units. The word coherent is used here in the following sense: when coherent units are used, equations between the numerical values of quantities take exactly the same form as the equations between the quantities themselves. Thus if only units from a coherent set are used, conversion factors between units are never required.
        Returns:
        equals(toSystemUnit())

      • toSystemUnit

        protected abstract Unit<Q> toSystemUnit()
        Returns the unscaled SI unit from which this unit is derived. The SI unit can be be used to identify a quantity given the unit. For example: static boolean isAngularVelocity(AbstractUnit unit) { return unit.toSystemUnit().equals(RADIAN.divide(SECOND)); } assert(REVOLUTION.divide(MINUTE).isAngularVelocity()); // Returns true.
        Returns:
        the unscaled metric unit from which this unit is derived.

      • annotate

        public final Unit<Q> annotate​(String annotation)
        Annotates the specified unit. Annotation does not change the unit semantic. Annotations are often written between curly braces behind units. For example:
        Unit PERCENT_VOL = ((AbstractUnit)Units.PERCENT).annotate("vol"); // "%{vol}" Unit KG_TOTAL = ((AbstractUnit)Units.KILOGRAM).annotate("total"); // "kg{total}" Unit RED_BLOOD_CELLS = ((AbstractUnit)Units.ONE).annotate("RBC"); // "{RBC}" Note: Annotation of system units are not considered themselves as system units.
        Parameters:
        annotation - the unit annotation.
        Returns:
        the annotated unit.

      • parse

        public static Unit<?> parse​(CharSequence charSequence)
        Returns the abstract unit represented by the specified characters as per default format. Locale-sensitive unit parsing could be handled using LocalUnitFormat in subclasses of AbstractUnit.

        Note: The standard format supports dimensionless units. AbstractUnit PERCENT = AbstractUnit.parse("100").inverse().asType(Dimensionless.class);

        Parameters:
        charSequence - the character sequence to parse.
        Returns:
        SimpleUnitFormat.getInstance().parse(csq)
        Throws:
        MeasurementParseException - if the specified character sequence cannot be correctly parsed (e.g. not UCUM compliant).

      • toString

        public String toString()
        Returns the standard representation of this physics unit. The string produced for a given unit is always the same; it is not affected by the locale. It can be used as a canonical string representation for exchanging units, or as a key for a Hashtable, etc. Locale-sensitive unit parsing could be handled using LocalUnitFormat in subclasses of AbstractUnit.
        Specified by:
        toString in interface Unit<Q extends Quantity<Q>>
        Overrides:
        toString in class Object
        Returns:
        SimpleUnitFormat.getInstance().format(this)

      • getSystemUnit

        public final Unit<Q> getSystemUnit()
        Returns the system unit (unscaled SI unit) from which this unit is derived. They can be be used to identify a quantity given the unit. For example:
        static boolean isAngularVelocity(AbstractUnit unit) {
          return unit.getSystemUnit().equals(RADIAN.divide(SECOND));
        }
        assert(REVOLUTION.divide(MINUTE).isAngularVelocity()); // Returns true.
        Specified by:
        getSystemUnit in interface Unit<Q extends Quantity<Q>>
        Returns:
        the unscaled metric unit from which this unit is derived.

      • isCompatible

        public final boolean isCompatible​(Unit<?> that)
        Indicates if this unit is compatible with the unit specified. To be compatible both units must be physics units having the same fundamental dimension.
        Specified by:
        isCompatible in interface Unit<Q extends Quantity<Q>>
        Parameters:
        that - the other unit.
        Returns:
        true if this unit and that unit have the same fundamental dimension according to the current dimensional model; false otherwise.

      • asType

        public final <T extends Quantity<T>> Unit<T> asType​(Class<T> type)
        Casts this unit to a parameterized unit of specified nature or throw a ClassCastException if the dimension of the specified quantity and this unit's dimension do not match (regardless whether or not the dimensions are independent or not).
        Specified by:
        asType in interface Unit<Q extends Quantity<Q>>
        Parameters:
        type - the quantity class identifying the nature of the unit.
        Throws:
        ClassCastException - if the dimension of this unit is different from the SI dimension of the specified type.
        See Also:
        AbstractSystemOfUnits.getUnit(Class)

      • getName

        public String getName()
        Specified by:
        getName in interface tech.uom.lib.common.function.Nameable
        Specified by:
        getName in interface Unit<Q extends Quantity<Q>>

      • multiply

        public final Unit<?> multiply​(Unit<?> that)
        Returns the product of this physical unit with the one specified.
        Specified by:
        multiply in interface Unit<Q extends Quantity<Q>>
        Parameters:
        that - the physical unit multiplicand.
        Returns:
        this * that

      • inverse

        public final Unit<?> inverse()
        Returns the inverse of this physical unit.
        Specified by:
        inverse in interface Unit<Q extends Quantity<Q>>
        Returns:
        1 / this

      • divide

        public final Unit<Q> divide​(Number divisor)
        Returns the result of dividing this unit by the specified divisor. If the factor is an integer value, the division is exact. For example: 
         
    QUART = GALLON_LIQUID_US.divide(4); // Exact definition.
        Specified by:
        divide in interface Unit<Q extends Quantity<Q>>
        Parameters:
        divisor - the divisor value.
        Returns:
        this unit divided by the specified divisor.

      • divide

        public final Unit<?> divide​(Unit<?> that)
        Returns the quotient of this unit with the one specified.
        Specified by:
        divide in interface Unit<Q extends Quantity<Q>>
        Parameters:
        that - the unit divisor.
        Returns:
        this.multiply(that.inverse())

      • root

        public final Unit<?> root​(int n)
        Returns a unit equals to the given root of this unit.
        Specified by:
        root in interface Unit<Q extends Quantity<Q>>
        Parameters:
        n - the root's order.
        Returns:
        the result of taking the given root of this unit.
        Throws:
        ArithmeticException - if n == 0 or if this operation would result in an unit with a fractional exponent.

      • pow

        public Unit<?> pow​(int n)
        Returns a unit equals to this unit raised to an exponent.
        Specified by:
        pow in interface Unit<Q extends Quantity<Q>>
        Parameters:
        n - the exponent.
        Returns:
        the result of raising this unit to the exponent.

      • compareTo

        public int compareTo​(Unit<Q> that)
        Compares this unit to the specified unit. The default implementation compares the name and symbol of both this unit and the specified unit, giving precedence to the symbol.
        Specified by:
        compareTo in interface Comparable<Q extends Quantity<Q>>
        Returns:
        a negative integer, zero, or a positive integer as this unit is less than, equal to, or greater than the specified unit.