FloatValue (JPMML evaluator 1.4.2 API)

java.lang.Object
- org.jpmml.evaluator.Value<Float>
- - org.jpmml.evaluator.FloatValue

All Implemented Interfaces:

Comparable<Value<Float>>

Direct Known Subclasses:

ReportingFloatValue
```
public class FloatValue
extends Value<Float>
```

Field Summary

Fields
Modifier and Type Field and Description

static double E

static double PI

protected float value

Fields
Modifier and Type	Field and Description
`static double`	`E`
`static double`	`PI`
`protected float`	`value`

Constructor Summary

Constructors
Constructor and Description

FloatValue(float value)

Constructors
Constructor and Description
`FloatValue(float value)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`FloatValue`	`abs()`
`FloatValue`	`add(double value)`
`FloatValue`	`add(double coefficient, Number... factors)` Adds `coefficient * product(factors)`.
`FloatValue`	`add(double coefficient, Number factor)` Adds `coefficient * factor`.
`FloatValue`	`add(double coefficient, Number factor, int exponent)` Adds `coefficient * (factor ^ exponent)`.
`FloatValue`	`add(double coefficient, Number firstFactor, Number secondFactor)`
`FloatValue`	`add(Value<? extends Number> value)`
`FloatValue`	`arctan()`
`FloatValue`	`ceiling()`
`int`	`compareTo(double value)`
`int`	`compareTo(Value<Float> that)`
`FloatValue`	`copy()`
`FloatValue`	`cos()`
`FloatValue`	`denormalize(double leftOrig, double leftNorm, double rightOrig, double rightNorm)`
`FloatValue`	`divide(double value)`
`FloatValue`	`divide(Value<? extends Number> value)`
`double`	`doubleValue()`
`FloatValue`	`elliott()`
`boolean`	`equals(double value)`
`boolean`	`equals(Object object)`
`FloatValue`	`exp()`
`static float`	`exp(float value)` Computes `exp(float)`.
`float`	`floatValue()`
`FloatValue`	`floor()`
`FloatValue`	`gauss()`
`FloatValue`	`gaussSim(double value)`
`Float`	`getValue()`
`int`	`hashCode()`
`FloatValue`	`inverseCauchit()`
`FloatValue`	`inverseCloglog()`
`FloatValue`	`inverseLogc()`
`FloatValue`	`inverseLogit()`
`FloatValue`	`inverseLoglog()`
`FloatValue`	`inverseNegbin(double value)`
`FloatValue`	`inverseOddspower(double value)`
`FloatValue`	`inversePower(double value)`
`FloatValue`	`inverseProbit()`
`FloatValue`	`multiply(double value)`
`FloatValue`	`multiply(Number factor, double exponent)` Multiplies by `factor ^ exponent`.
`FloatValue`	`multiply(Value<? extends Number> value)`
`static float`	`pow(float value, float power)`
`FloatValue`	`power(double value)`
`FloatValue`	`reciprocal()`
`FloatValue`	`relu()`
`FloatValue`	`residual(Value<? extends Number> value)`
`FloatValue`	`restrict(double lowValue, double highValue)`
`FloatValue`	`round()`
`FloatValue`	`sin()`
`FloatValue`	`square()`
`FloatValue`	`subtract(double value)`
`FloatValue`	`subtract(Value<? extends Number> value)`
`FloatValue`	`tanh()`
`FloatValue`	`threshold(double value)`
`String`	`toString()`

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

- Field Detail
  - value
```
protected float value
```
  - E
```
public static final double E
```
    See Also:
    
    Constant Field Values
  - PI
```
public static final double PI
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - FloatValue
```
public FloatValue(float value)
```
- Method Detail
  - compareTo
```
public int compareTo(Value<Float> that)
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object object)
```
    Overrides:
    
    equals in class Object
  - copy
```
public FloatValue copy()
```
    Specified by:
    
    copy in class Value<Float>
  - add
```
public FloatValue add(double value)
```
    Specified by:
    
    add in class Value<Float>
  - add
```
public FloatValue add(Value<? extends Number> value)
```
    Specified by:
    
    add in class Value<Float>
  - add
```
public FloatValue add(double coefficient,
                      Number factor)
```
    Description copied from class: Value
    
    Adds coefficient * factor.
    
    Specified by:
    
    add in class Value<Float>
  - add
```
public FloatValue add(double coefficient,
                      Number firstFactor,
                      Number secondFactor)
```
    Specified by:
    
    add in class Value<Float>
  - add
```
public FloatValue add(double coefficient,
                      Number... factors)
```
    Description copied from class: Value
    
    Adds coefficient * product(factors).
    
    Specified by:
    
    add in class Value<Float>
  - add
```
public FloatValue add(double coefficient,
                      Number factor,
                      int exponent)
```
    Description copied from class: Value
    
    Adds coefficient * (factor ^ exponent).
    
    Specified by:
    
    add in class Value<Float>
  - subtract
```
public FloatValue subtract(double value)
```
    Specified by:
    
    subtract in class Value<Float>
  - subtract
```
public FloatValue subtract(Value<? extends Number> value)
```
    Specified by:
    
    subtract in class Value<Float>
  - multiply
```
public FloatValue multiply(double value)
```
    Specified by:
    
    multiply in class Value<Float>
  - multiply
```
public FloatValue multiply(Value<? extends Number> value)
```
    Specified by:
    
    multiply in class Value<Float>
  - multiply
```
public FloatValue multiply(Number factor,
                           double exponent)
```
    Description copied from class: Value
    
    Multiplies by factor ^ exponent.
    
    Specified by:
    
    multiply in class Value<Float>
  - divide
```
public FloatValue divide(double value)
```
    Specified by:
    
    divide in class Value<Float>
  - divide
```
public FloatValue divide(Value<? extends Number> value)
```
    Specified by:
    
    divide in class Value<Float>
  - residual
```
public FloatValue residual(Value<? extends Number> value)
```
    Specified by:
    
    residual in class Value<Float>
  - square
```
public FloatValue square()
```
    Specified by:
    
    square in class Value<Float>
  - power
```
public FloatValue power(double value)
```
    Specified by:
    
    power in class Value<Float>
  - reciprocal
```
public FloatValue reciprocal()
```
    Specified by:
    
    reciprocal in class Value<Float>
  - elliott
```
public FloatValue elliott()
```
    Specified by:
    
    elliott in class Value<Float>
  - exp
```
public FloatValue exp()
```
    Specified by:
    
    exp in class Value<Float>
  - gauss
```
public FloatValue gauss()
```
    Specified by:
    
    gauss in class Value<Float>
  - inverseLogit
```
public FloatValue inverseLogit()
```
    Specified by:
    
    inverseLogit in class Value<Float>
  - inverseCloglog
```
public FloatValue inverseCloglog()
```
    Specified by:
    
    inverseCloglog in class Value<Float>
  - inverseLoglog
```
public FloatValue inverseLoglog()
```
    Specified by:
    
    inverseLoglog in class Value<Float>
  - inverseLogc
```
public FloatValue inverseLogc()
```
    Specified by:
    
    inverseLogc in class Value<Float>
  - inverseNegbin
```
public FloatValue inverseNegbin(double value)
```
    Specified by:
    
    inverseNegbin in class Value<Float>
  - inverseOddspower
```
public FloatValue inverseOddspower(double value)
```
    Specified by:
    
    inverseOddspower in class Value<Float>
  - inversePower
```
public FloatValue inversePower(double value)
```
    Specified by:
    
    inversePower in class Value<Float>
  - inverseCauchit
```
public FloatValue inverseCauchit()
```
    Specified by:
    
    inverseCauchit in class Value<Float>
  - inverseProbit
```
public FloatValue inverseProbit()
```
    Specified by:
    
    inverseProbit in class Value<Float>
  - sin
```
public FloatValue sin()
```
    Specified by:
    
    sin in class Value<Float>
  - cos
```
public FloatValue cos()
```
    Specified by:
    
    cos in class Value<Float>
  - arctan
```
public FloatValue arctan()
```
    Specified by:
    
    arctan in class Value<Float>
  - tanh
```
public FloatValue tanh()
```
    Specified by:
    
    tanh in class Value<Float>
  - threshold
```
public FloatValue threshold(double value)
```
    Specified by:
    
    threshold in class Value<Float>
  - relu
```
public FloatValue relu()
```
    Specified by:
    
    relu in class Value<Float>
  - abs
```
public FloatValue abs()
```
    Specified by:
    
    abs in class Value<Float>
  - gaussSim
```
public FloatValue gaussSim(double value)
```
    Specified by:
    
    gaussSim in class Value<Float>
  - restrict
```
public FloatValue restrict(double lowValue,
                           double highValue)
```
    Specified by:
    
    restrict in class Value<Float>
  - round
```
public FloatValue round()
```
    Specified by:
    
    round in class Value<Float>
  - ceiling
```
public FloatValue ceiling()
```
    Specified by:
    
    ceiling in class Value<Float>
  - floor
```
public FloatValue floor()
```
    Specified by:
    
    floor in class Value<Float>
  - denormalize
```
public FloatValue denormalize(double leftOrig,
                              double leftNorm,
                              double rightOrig,
                              double rightNorm)
```
    Specified by:
    
    denormalize in class Value<Float>
  - equals
```
public boolean equals(double value)
```
    Specified by:
    
    equals in class Value<Float>
  - compareTo
```
public int compareTo(double value)
```
    Specified by:
    
    compareTo in class Value<Float>
  - floatValue
```
public float floatValue()
```
    Specified by:
    
    floatValue in class Value<Float>
  - doubleValue
```
public double doubleValue()
```
    Specified by:
    
    doubleValue in class Value<Float>
  - getValue
```
public Float getValue()
```
    Specified by:
    
    getValue in class Value<Float>
  - exp
```
public static float exp(float value)
```
    Computes exp(float).
    The function exp(float) can be reasonably emulated as (float)Math#pow(2.7182817d, double). The constant 2.7182817d has to be hard-coded as double literal, because a float value, which could be either hard-coded as float literal or computed as (float)Math#E, would be promoted to a double value 2.7182817459106445d (via a widening primitive conversion) by the method invocation expression.
  - pow
```
public static float pow(float value,
                        float power)
```

Class FloatValue

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

value

E

PI

Constructor Detail

FloatValue

Method Detail

compareTo

toString

hashCode

equals

copy

add

add

add

add

add

add

subtract

subtract

multiply

multiply

multiply

divide

divide

residual

square

power

reciprocal

elliott

exp

gauss

inverseLogit

inverseCloglog

inverseLoglog

inverseLogc

inverseNegbin

inverseOddspower

inversePower

inverseCauchit

inverseProbit

sin

cos

arctan

tanh

threshold

relu

abs

gaussSim

restrict

round

ceiling

floor

denormalize

equals

compareTo

floatValue

doubleValue

getValue

exp

pow