JScience v4.3

Package javax.measure

Provides strongly typed measurements to enforce compile-time check of parameters consistency and avoid interface errors.

See:
          Description

Interface Summary
Measurable<Q extends Quantity> This interface represents the measurable, countable, or comparable property or aspect of a thing.
 

Class Summary
DecimalMeasure<Q extends Quantity> This class represents a measure whose value is an arbitrary-precision decimal number.
Measure<V,Q extends Quantity> This class represents the result of a measurement stated in a known unit.
MeasureFormat This class provides the interface for formatting and parsing measures.
VectorMeasure<Q extends Quantity> This class represents a measurement vector of two or more dimensions.
 

Package javax.measure Description

Provides strongly typed measurements to enforce compile-time check of parameters consistency and avoid interface errors.

Let's take the following example:

        class Person {
            void setWeight(double weight);
        }
Should the weight be in pound, kilogram ??
Using measures there is no room for error:
        class Person {
            void setWeight(Measurable<Mass> weight);
        }
Not only the interface is cleaner (the weight has to be of mass type); but also there is no confusion on the measurement unit:
        double weightInKg = weight.doubleValue(KILOGRAM);
        double weightInLb = weight.doubleValue(POUND);
Measurable work hand-in-hand with units (also parameterized). For example, the following would result in compile-time error:
        double weightInLiter = weight.doubleValue(LITER); // Compile error, Unit<Mass> required.
        

Users may create their own Measurable implementation:


         public class Period implements Measurable<Duration> {
              long nanoseconds;
              ...
         }
 
         public class Distance implements Measurable<Length> {
              double meters;
              ...
         }
                  
         public class Velocity3D implements Measurable<Velocity> {
              double x, y, z; // In meters.
              ...
         }
                 

Users may also combine a definite amount (scalar, vector, collection, etc.) to a unit and make it a Measure (and a Measurable instance). For example:

           
         // Scalar measurement (numerical).     
         person.setWeight(Measure.valueOf(180.0, POUND)); // Measure<Double, Mass>
         timer.setPeriod(Measure.valueOf(20, MILLI(SECOND)); // Measure<Integer, Duration>
         circuit.setCurrent(Measure.valueOf(Complex.valueOf(2, -3), AMPERE); // (2 - 3i) A
         bottle.setPression(Measure.valueOf(Rational.valueOf(20, 100), ATMOSPHERE)); // (20/100) Atm

         // Vector measurement.
         abstract class MeasureVector<E, Q extends Quantity> extends Measure<E[], Q> {
             ... // doubleValue(Unit) returns vector norm.
         }
         MeasureVector<Double, Velocity> v = MeasureVector.valueOf(METRE_PER_SECOND, 1.0, 2.0, 3.0);
         plane.setVelocity(v);

         // Statistical measurement.
         class Average<Q extends Quantity> extends Measure<double[], Q>{
             ... // doubleValue(Unit) returns average value.
         }
         sea.setTemperature(Average.valueOf(new double[] { 33.4, 44.55, 32.33} , CELCIUS));
         
         // Measurement with uncertainty (and additional operations).
         public class Amount<Q extends Quantity> extends Measurable<Q>  {
              public Amount(double value, double error, Unit<Q> unit) { ... }
              public Amount<Q> plus(Amount<Q> that) {...}
              public Amount<?> times(Amount<?> that) {...} 
              ... // doubleValue(Unit) returns estimated value.
         }  
    


JScience v4.3

Copyright © 2006 JScience.