Package org.openjdk.jmc.common.unit

Class LongPreOffsetTransform

java.lang.Object
org.openjdk.jmc.common.unit.LongPreOffsetTransform
All Implemented Interfaces:
IScalarAffineTransform
public class LongPreOffsetTransform extends Object implements IScalarAffineTransform
Transform that adds an offset first and then multiplies with the multiplier. This is typically used to reduce cancellation errors when the offset is larger than can be accurately represented in a double.

  • Constructor Details

    • LongPreOffsetTransform

      public LongPreOffsetTransform(long preOffset, double multiplier)

  • Method Details

    • getOffset

      public double getOffset()
      Specified by:
      getOffset in interface IScalarAffineTransform
      Returns:
      the offset to be added (after the source value has been multiplied with the multiplier)

    • getMultiplier

      public double getMultiplier()
      Specified by:
      getMultiplier in interface IScalarAffineTransform
      Returns:
      the multiplier which source values should be multiplied with (before the offset is added)

    • equals

      public boolean equals(Object other)
      Overrides:
      equals in class Object

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • targetOutOfRange

      public boolean targetOutOfRange(long srcNumericalValue, long maxAbsValue)
      Specified by:
      targetOutOfRange in interface IScalarAffineTransform

    • targetOutOfRange

      public boolean targetOutOfRange(double srcNumericalValue, long maxAbsValue)
      Specified by:
      targetOutOfRange in interface IScalarAffineTransform

    • targetValue

      public long targetValue(long srcNumericalValue)
      Specified by:
      targetValue in interface IScalarAffineTransform
      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

      public long targetFloor(long srcNumericalValue)
      Specified by:
      targetFloor in interface IScalarAffineTransform
      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

      public double targetFloor(double srcNumericalValue)
      Specified by:
      targetFloor in interface IScalarAffineTransform
      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

      public int targetIntFloor(Number srcNumericalValue)
      Specified by:
      targetIntFloor in interface IScalarAffineTransform
      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

      public Number targetNumber(long srcNumericalValue)
      Specified by:
      targetNumber in interface IScalarAffineTransform
      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

      public Number targetNumber(Number srcNumericalValue)
      Specified by:
      targetNumber in interface IScalarAffineTransform
      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

      public double targetValue(double srcNumericalValue)
      Specified by:
      targetValue in interface IScalarAffineTransform
      Parameters:
      srcNumericalValue - a numerical quantity value, expressed in the source unit
      Returns:
      the corresponding numerical quantity value, when expressed in the target unit

    • invert

      public IScalarAffineTransform invert()
      Specified by:
      invert in interface IScalarAffineTransform
      Returns:
      the inverse transform

    • isUnity

      public boolean isUnity()
      Specified by:
      isUnity in interface IScalarAffineTransform
      Returns:
      true iff this represents the identity transform

    • isInteger

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

    • concat

      public IScalarAffineTransform concat(IScalarAffineTransform innerTransform)
      Description copied from interface: IScalarAffineTransform
      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));

      Specified by:
      concat in interface IScalarAffineTransform
      Parameters:
      innerTransform - the transform that should be applied before this transform
      Returns:
      the concatenated transform

    • invertAndConcat

      public IScalarAffineTransform invertAndConcat(IScalarAffineTransform innerTransform)
      Description copied from interface: IScalarAffineTransform
      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));

      Specified by:
      invertAndConcat in interface IScalarAffineTransform
      Parameters:
      innerTransform - the transform that should be applied before this transform
      Returns:
      the concatenated transform