## visad
Class ScaledUnit

    java.lang.Object
      visad.Unit
          visad.ScaledUnit

All Implemented Interfaces:
  Serializable

public final class ScaledUnit
extends Unit
implements Serializable

A class that represents a certain amount of a derived unit.

See Also:
  Serialized Form

Field Summary
`(package private) double` `amount` The amount of the associated derived unit.
`(package private) DerivedUnit` `derivedUnit` The associated derived unit.

Fields inherited from class visad.Unit
`hashCode, hashCodeSet`

Constructor Summary
`ScaledUnit(double amount)` Construct a dimensionless scaled unit.
`ScaledUnit(double amount, BaseUnit that)` Construct a scaled unit from a base unit.
`ScaledUnit(double amount, BaseUnit that, String identifier)` Construct a scaled unit from a base unit and an identifier.
`ScaledUnit(double amount, DerivedUnit that)` Construct a scaled unit from a derived unit.
`ScaledUnit(double amount, DerivedUnit that, String identifier)` Construct a scaled unit from a derived unit and an identifier.
`ScaledUnit(double amount, ScaledUnit unit)` Construct a scaled unit from a scaled unit.
`ScaledUnit(double amount, ScaledUnit that, String identifier)` Construct a scaled unit from a scaled unit and an identifier.
`ScaledUnit(double amount, String identifier)` Construct a dimensionless scaled unit with an identifier.

Method Summary
`static ScaledUnit` `create(double amount, Unit unit)` Factory method for creating a scaled unit.
`Unit` `divide(Unit that)` Divides this unit by another unit.
`protected Unit` `divideInto(Unit that)` Divides this unit into another unit.
`boolean` `equals(Unit unit)` Indicates if this instance is equal to a unit.
`String` `getDefinition()` Returns the definition of this unit.
`int` `hashCode()` Returns the hash code of this instance.
`boolean` `isConvertible(Unit unit)` Indicate whether this unit is convertible with another unit.
`boolean` `isDimensionless()` Indicates if this instance is dimensionless.
`static void` `main(String[] args)` Test this class.
`Unit` `multiply(Unit that)` Multiplies this unit by another unit.
`Unit` `pow(double power)` Raises this unit to a power.
`Unit` `pow(int power)` Raises this unit to a power.
`protected Unit` `protectedClone(String identifier)` Clones this unit, changing the identifier.
`Unit` `root(int root)` Returns the N-th root of this unit.
`double[]` `toThat(double[] values, Unit that)` Convert values from this unit to another unit.
`double[]` `toThat(double[] values, Unit that, boolean copy)` Convert values from this unit to another unit.
`float[]` `toThat(float[] values, Unit that)` Convert values from this unit to another unit.
`float[]` `toThat(float[] values, Unit that, boolean copy)` Convert values from this unit to another unit.
`double[]` `toThis(double[] values, Unit that)` Convert values to this unit from another unit.
`double[]` `toThis(double[] values, Unit that, boolean copy)` Convert values to this unit from another unit.
`float[]` `toThis(float[] values, Unit that)` Convert values to this unit from another unit.
`float[]` `toThis(float[] values, Unit that, boolean copy)` Convert values to this unit from another unit.

Methods inherited from class visad.Unit
`adjustCheckAndCache, canConvert, canConvertArray, clone, convertTuple, convertTuple, convertTuple, convertTuple, copyUnitsArray, equals, getAbsoluteUnit, getIdentifier, scale, scale, shift, sqrt, toString, toThat, toThis, transformUnits, transformUnits, transformUnits, transformUnits`

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Field Detail

### amount

    final double amount

  The amount of the associated derived unit.

### derivedUnit

    final DerivedUnit derivedUnit

  The associated derived unit.

Constructor Detail

### ScaledUnit

    public ScaledUnit(double amount)

  Construct a dimensionless scaled unit. The identifier will be empty.

Parameters:
  `amount` - The given amount of this unit.

### ScaledUnit

    public ScaledUnit(double amount,
                      String identifier)

  Construct a dimensionless scaled unit with an identifier.

Parameters:
  `amount` - The given amount of this unit.
  `identifier` - Name or abbreviation for the unit. May be `null` or empty.

### ScaledUnit

    public ScaledUnit(double amount,
                      BaseUnit that)

  Construct a scaled unit from a base unit. The identifier will be that of the base unit if the amount is 1; otherwise, the identifier will be `null`.

Parameters:
  `amount` - The given amount of the base unit (e.g. 0.9144 to create a yard unit if `unit` represents a meter).
  `that` - The given base unit.

### ScaledUnit

    public ScaledUnit(double amount,
                      BaseUnit that,
                      String identifier)

  Construct a scaled unit from a base unit and an identifier.

Parameters:
  `amount` - The given amount of the base unit (e.g. 0.9144 to create a yard unit if `unit` represents a meter).
  `that` - The given base unit.
  `identifier` - Name or abbreviation for the unit. May be `null` or empty.

### ScaledUnit

    public ScaledUnit(double amount,
                      DerivedUnit that)

  Construct a scaled unit from a derived unit. The identifier will be that of the derived unit if the amount is 1; otherwise, the identifier will be `null`.

Parameters:
  `amount` - The given amount of the derived unit (e.g. 0.44704 to create a mile/hour unit if `unit` represents a meter/second.
  `that` - The given derived unit.

### ScaledUnit

    public ScaledUnit(double amount,
                      DerivedUnit that,
                      String identifier)

  Construct a scaled unit from a derived unit and an identifier.

Parameters:
  `amount` - The given amount of the derived unit (e.g. 0.44704 to create a mile/hour unit if `unit` represents a meter/second.
  `that` - The given derived unit.
  `identifier` - Name or abbreviation for the unit. May be `null` or empty.

### ScaledUnit

    public ScaledUnit(double amount,
                      ScaledUnit unit)

  Construct a scaled unit from a scaled unit. The identifier will be that of the scaled unit if both amounts are 1; otherwise, the identifier will be `null`.

Parameters:
  `amount` - The given amount of the scaled unit (e.g. 3.0 to create a yard unit if `unit` represents a foot.
  `unit` - The given scaled unit.

### ScaledUnit

    public ScaledUnit(double amount,
                      ScaledUnit that,
                      String identifier)

  Construct a scaled unit from a scaled unit and an identifier.

Parameters:
  `amount` - The given amount of the scaled unit (e.g. 3.0 to create a yard unit if `unit` represents a foot.
  `that` - The given scaled unit.
  `identifier` - Name or abbreviation for the unit. May be `null` or empty.

Method Detail

### create

    public static ScaledUnit create(double amount,
                                    Unit unit)
                             throws UnitException

  Factory method for creating a scaled unit. The identifier will be that of the input unit if both amounts are 1; otherwise, the identifier will be `null`.

  Parameters:
    `amount` - The given amount of the scaled unit (e.g. 3.0 to create a yard unit if `unit` represents a foot.
    `unit` - The given unit.
  Returns:
    A corresponding scaled unit.
  Throws:
    `UnitException` - Can't create Scaled Unit from `unit`.

### isDimensionless

    public boolean isDimensionless()

  Indicates if this instance is dimensionless. A unit is dimensionless if it is a measure of a dimensionless quantity like angle or concentration. Examples of dimensionless units include radian, degree, steradian, and "g/kg".

  Specified by:
    `isDimensionless` in class `Unit`
  Returns:
    True if an only if this unit is dimensionless.

### protectedClone

    protected Unit protectedClone(String identifier)

  Clones this unit, changing the identifier.

  Specified by:
    `protectedClone` in class `Unit`
  Parameters:
    `identifier` - The name or abbreviation for the cloned unit. May be `null` or empty.
  Returns:
    A unit equal to this instance but with the given identifier.

### pow

    public Unit pow(int power)

  Raises this unit to a power.

  Specified by:
    `pow` in class `Unit`
  Parameters:
    `power` - The power to raise this unit by.
  Returns:
    The unit resulting from raising this unit to `power`.

### root

    public Unit root(int root)
              throws IllegalArgumentException

  Returns the N-th root of this unit.

  Specified by:
    `root` in class `Unit`
  Parameters:
    `root` - The root to take (e.g. 2 means square root). May not be zero.
  Returns:
    The unit corresponding to the `root`-th root of this unit.
  Throws:
    `IllegalArgumentException` - The root value is zero or the resulting unit would have a non-integral unit dimension.

### pow

    public Unit pow(double power)
             throws IllegalArgumentException

  Raises this unit to a power.

  Specified by:
    `pow` in class `Unit`
  Parameters:
    `power` - The power to raise this unit by. If this unit is not dimensionless, then the value must be integral.
  Returns:
    The unit resulting from raising this unit to `power`.
  Throws:
    `IllegalArgumentException` - This unit is not dimensionless and `power` has a non-integral value.

### getDefinition

    public String getDefinition()

  Returns the definition of this unit.

  Specified by:
    `getDefinition` in class `Unit`
  Returns:
    The definition of this unit (e.g. "0.9144 m" for a yard).

### multiply

    public Unit multiply(Unit that)
                  throws UnitException

  Multiplies this unit by another unit.

  Specified by:
    `multiply` in class `Unit`
  Parameters:
    `that` - The unit with which to multiply this unit.
  Returns:
    The product of the two units.
  Throws:
    `UnitException` - Meaningless operation.

### divide

    public Unit divide(Unit that)
                throws UnitException

  Divides this unit by another unit.

  Specified by:
    `divide` in class `Unit`
  Parameters:
    `that` - The unit to divide into this unit.
  Returns:
    The quotient of the two units.
  Throws:
    `UnitException` - Meaningless operation.

### divideInto

    protected Unit divideInto(Unit that)
                       throws UnitException

  Divides this unit into another unit.

  Specified by:
    `divideInto` in class `Unit`
  Parameters:
    `that` - The unit to be divided by this unit.
  Returns:
    The quotient of the two units.
  Throws:
    `UnitException` - Meaningless operation.

### toThis

    public double[] toThis(double[] values,
                           Unit that)
                    throws UnitException

  Convert values to this unit from another unit.

  Specified by:
    `toThis` in class `Unit`
  Parameters:
    `values` - The values to be converted.
    `that` - The unit of `values`.
  Returns:
    The converted values in units of this unit.
  Throws:
    `UnitException` - The units are not convertible.

### toThis

    public float[] toThis(float[] values,
                          Unit that)
                   throws UnitException

  Convert values to this unit from another unit.

  Specified by:
    `toThis` in class `Unit`
  Parameters:
    `values` - The values to be converted.
    `that` - The unit of `values`.
  Returns:
    The converted values in units of this unit.
  Throws:
    `UnitException` - The units are not convertible.

### toThis

    public double[] toThis(double[] values,
                           Unit that,
                           boolean copy)
                    throws UnitException

  Convert values to this unit from another unit.

  Overrides:
    `toThis` in class `Unit`
  Parameters:
    `values` - The values to be converted.
    `that` - The unit of `values`.
    `copy` - if false and `that` equals this, return `values`, else return a new array
  Returns:
    The converted values in units of this unit.
  Throws:
    `UnitException` - The units are not convertible.

### toThis

    public float[] toThis(float[] values,
                          Unit that,
                          boolean copy)
                   throws UnitException

  Convert values to this unit from another unit.

  Overrides:
    `toThis` in class `Unit`
  Parameters:
    `values` - The values to be converted.
    `that` - The unit of `values`.
    `copy` - if false and `that` equals this, return `values`, else return a new array
  Returns:
    The converted values in units of this unit.
  Throws:
    `UnitException` - The units are not convertible.

### toThat

    public double[] toThat(double[] values,
                           Unit that)
                    throws UnitException

  Convert values from this unit to another unit.

  Specified by:
    `toThat` in class `Unit`
  Parameters:
    `values` - The values to be converted in units of this unit.
    `that` - The unit to which to convert the values.
  Returns:
    The converted values.
  Throws:
    `UnitException` - The units are not convertible.

### toThat

    public float[] toThat(float[] values,
                          Unit that)
                   throws UnitException

  Convert values from this unit to another unit.

  Specified by:
    `toThat` in class `Unit`
  Parameters:
    `values` - The values to be converted in units of this unit.
    `that` - The unit to which to convert the values.
  Returns:
    The converted values.
  Throws:
    `UnitException` - The units are not convertible.

### toThat

    public double[] toThat(double[] values,
                           Unit that,
                           boolean copy)
                    throws UnitException

  Convert values from this unit to another unit.

  Overrides:
    `toThat` in class `Unit`
  Parameters:
    `values` - The values to be converted in units of this unit.
    `that` - The unit to which to convert the values.
    `copy` - if false and `that` equals this, return `values`, else return a new array
  Returns:
    The converted values.
  Throws:
    `UnitException` - The units are not convertible.

### toThat

    public float[] toThat(float[] values,
                          Unit that,
                          boolean copy)
                   throws UnitException

  Convert values from this unit to another unit.

  Overrides:
    `toThat` in class `Unit`
  Parameters:
    `values` - The values to be converted in units of this unit.
    `that` - The unit to which to convert the values.
    `copy` - if false and `that` equals this, return `values`, else return a new array
  Returns:
    The converted values.
  Throws:
    `UnitException` - The units are not convertible.

### isConvertible

    public boolean isConvertible(Unit unit)

  Indicate whether this unit is convertible with another unit. If one unit is convertible with another, then the `toThis(...)`/ and `toThat(...)` methods will not throw a UnitException. Unit A is convertible with unit B if and only if unit B is convertible with unit A; hence, calling-order is irrelevant.

  Specified by:
    `isConvertible` in class `Unit`
  Parameters:
    `unit` - The other unit.
  Returns:
    True if and only if this unit is convertible with the other unit.

### main

    public static void main(String[] args)
                     throws UnitException

  Test this class.

  Parameters:
    `args` - Arguments (ignored).
  Throws:
    `UnitException` - A problem occurred.

### equals

    public boolean equals(Unit unit)

  Indicates if this instance is equal to a unit.

  Specified by:
    `equals` in class `Unit`
  Parameters:
    `unit` - The unit.
  Returns:
    `true` if and only if this instance equals the unit.

### hashCode

    public int hashCode()

  Returns the hash code of this instance. `Object.hashCode()` should be overridden whenever `Object.equals(Object)` is.

  Specified by:
    `hashCode` in class `Unit`
  Returns:
    The hash code of this instance (includes the values).