SimpleAffineTransform (common 7.1.2 API)

java.lang.Object
- org.openjdk.jmc.common.unit.SimpleAffineTransform

All Implemented Interfaces:: IScalarAffineTransform

public class SimpleAffineTransform
extends Object
implements IScalarAffineTransform

Constructor Summary

Constructors
Constructor and Description

SimpleAffineTransform(double multiplier, double offset)

Constructors
Constructor and Description
`SimpleAffineTransform(double multiplier, double offset)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`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.
`static IScalarAffineTransform`	`createWithNegPreOffset(double multiplier, Number negativeOffset)`
`static IScalarAffineTransform`	`createWithPostOffset(double multiplier, Number offset)`
`static IScalarAffineTransform`	`createWithPreOffset(double multiplier, Number offset)`
`boolean`	`equals(Object other)`
`double`	`getMultiplier()`
`Number`	`getOffset()`
`int`	`hashCode()`
`IScalarAffineTransform`	`invert()`
`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.
`boolean`	`isInteger()`
`boolean`	`isUnity()`
`double`	`targetFloor(double srcNumericalValue)`
`long`	`targetFloor(long srcNumericalValue)`
`int`	`targetIntFloor(Number srcNumericalValue)`
`Number`	`targetNumber(long srcNumericalValue)`
`Number`	`targetNumber(Number srcNumericalValue)`
`boolean`	`targetOutOfRange(double srcNumericalValue, long maxAbsValue)`
`boolean`	`targetOutOfRange(long srcNumericalValue, long maxAbsValue)`
`double`	`targetValue(double srcNumericalValue)`
`long`	`targetValue(long srcNumericalValue)`

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

- Constructor Detail
  - SimpleAffineTransform
```
public SimpleAffineTransform(double multiplier,
                             double offset)
```
- Method Detail
  - createWithPostOffset
```
public static IScalarAffineTransform createWithPostOffset(double multiplier,
                                                          Number offset)
```
  - createWithPreOffset
```
public static IScalarAffineTransform createWithPreOffset(double multiplier,
                                                         Number offset)
```
  - createWithNegPreOffset
```
public static IScalarAffineTransform createWithNegPreOffset(double multiplier,
                                                            Number negativeOffset)
```
  - getOffset
```
public Number 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

Class SimpleAffineTransform

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

SimpleAffineTransform

Method Detail

createWithPostOffset

createWithPreOffset

createWithNegPreOffset

getOffset

getMultiplier

equals

hashCode

targetOutOfRange

targetOutOfRange

targetValue

targetFloor

targetFloor

targetIntFloor

targetNumber

targetNumber

targetValue

invert

isUnity

isInteger

concat

invertAndConcat