Package org.openjdk.jmc.common.unit

Interface IScalarAffineTransform

  • All Known Implementing Classes:
    BinaryScaleFactor, DecimalScaleFactor, ImpreciseScaleFactor, LongPostOffsetTransform, LongPreOffsetTransform, LongScaleFactor, ScaleFactor, SimpleAffineTransform
    public interface IScalarAffineTransform
    A one dimensional affine transform, to be used on numerical quantity values (that is, the numbers in front of a unit). In other words, a transformation for numbers consisting of a linear scaling followed by the addition of an offset. Typically, you request a value transform from a source unit to a target unit.

    The transform is fully described (apart from numerical precision) by the multiplier and the offset. These methods are intended for when the transform is to be performed on a large number of primitives and possibly in conjunction with other transformations. A coalesced transformation can then be applied to every primitive, optimally by specialized hardware (like a GPU).

    • Method Detail

      • getOffset

        Number getOffset()
        Returns:
        the offset to be added (after the source value has been multiplied with the multiplier)

      • getMultiplier

        double getMultiplier()
        Returns:
        the multiplier which source values should be multiplied with (before the offset is added)

      • targetOutOfRange

        boolean targetOutOfRange​(long srcNumericalValue,
                         long maxAbsValue)

      • targetOutOfRange

        boolean targetOutOfRange​(double srcNumericalValue,
                         long maxAbsValue)

      • targetValue

        long targetValue​(long srcNumericalValue)
        Parameters:
        srcNumericalValue - a numerical quantity value, expressed in the source unit
        Returns:
        the corresponding numerical quantity value, when expressed in the target unit, rounded to the closest integer that can be represented by a long

      • targetFloor

        long targetFloor​(long srcNumericalValue)
        Parameters:
        srcNumericalValue - a numerical quantity value, expressed in the source unit
        Returns:
        the floor of the corresponding numerical quantity value, when expressed in the target unit, clamped to a long

      • targetFloor

        double targetFloor​(double srcNumericalValue)
        Parameters:
        srcNumericalValue - a numerical quantity value, expressed in the source unit
        Returns:
        the floor of the corresponding numerical quantity value, when expressed in the target unit

      • targetIntFloor

        int targetIntFloor​(Number srcNumericalValue)
        Parameters:
        srcNumericalValue - a numerical quantity value, expressed in the source unit
        Returns:
        the floor of the corresponding numerical quantity value, when expressed in the target unit, clamped to an int

      • targetNumber

        Number targetNumber​(long srcNumericalValue)
        Parameters:
        srcNumericalValue - an exact numerical quantity value, expressed in the source unit
        Returns:
        the corresponding numerical quantity value, when expressed in the target unit, as a Long if it can exactly be represented in one, otherwise as some other Number with at least the precision of double

      • targetNumber

        Number targetNumber​(Number srcNumericalValue)
        Parameters:
        srcNumericalValue - an exact or inexact numerical quantity value, expressed in the source unit
        Returns:
        the corresponding numerical quantity value, when expressed in the target unit, as a Long if it can exactly be represented in one, otherwise as some other Number with at least the precision of double

      • targetValue

        double targetValue​(double srcNumericalValue)
        Parameters:
        srcNumericalValue - a numerical quantity value, expressed in the source unit
        Returns:
        the corresponding numerical quantity value, when expressed in the target unit

      • isUnity

        boolean isUnity()
        Returns:
        true iff this represents the identity transform

      • isInteger

        boolean isInteger()
        Returns:
        true iff this transform can exactly be described by an integer multiplier followed by an integer offset

      • concat

        IScalarAffineTransform concat​(IScalarAffineTransform innerTransform)
        Concatenate this transform with innerTransform, such that applying the resulting transform is equivalent to first applying innerTransform and then applying this transform on the resulting value. That is, R(v) = T(I(v)), where R(v) is the resulting transform, T(v) is this transform, and I(v) is innerTransform.

        In this snippet, v1 and v2 should be equal, apart from numerical precision, for any v. 

         IScalarAffineTransform R, T = ..., I = ...;
 double v = ...;

 R = T.concat(I);
 double v1 = R.targetValue(v);
 double v2 = T.targetValue(I.targetValue(v));

        Parameters:
        innerTransform - the transform that should be applied before this transform
        Returns:
        the concatenated transform

      • invertAndConcat

        IScalarAffineTransform invertAndConcat​(IScalarAffineTransform innerTransform)
        Concatenate the inverse of this transform with innerTransform, such that applying the resulting transform is equivalent to first applying innerTransform and then applying this inverse of this transform on the resulting value. That is, R(v) = T-1(I(v)), where R(v) is the resulting transform, T-1(v) is the inverse of this transform, and I(v) is innerTransform.

        In this snippet, v1 and v2 should be equal, apart from numerical precision, for any v. 

         IScalarAffineTransform R, T = ..., I = ...;
 double v = ...;

 R = T.invertAndConcat(I);
 double v1 = R.targetValue(v);
 double v2 = T.invert().targetValue(I.targetValue(v));

        Parameters:
        innerTransform - the transform that should be applied before this transform
        Returns:
        the concatenated transform