org.djunits.value.vfloat.scalar

Class FloatScalar

java.lang.Object

org.djunits.value.vfloat.scalar.FloatScalar

public abstract class FloatScalar
extends Object

Immutable FloatScalar.

This file was generated by the djunits value classes generator, 26 jun, 2015

Copyright (c) 2015-2019 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
BSD-style license. See DJUNITS License.

$LastChangedDate: 2019-01-18 00:35:01 +0100 (Fri, 18 Jan 2019) $, @version $Revision: 324 $, by $Author: averbraeck $, initial version 26 jun, 2015

Author:

Alexander Verbraeck, Peter Knoppers

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	FloatScalar.Abs<AU extends AbsoluteLinearUnit<AU,RU>,RU extends Unit<RU>> Absolute Immutable FloatScalar.
static class	FloatScalar.Rel<U extends Unit<U>> Relative Immutable FloatScalar.

Constructor Summary

Constructors

Constructor and Description
FloatScalar()

Method Summary

Modifier and Type	Method and Description
static FloatScalar.Rel<SIUnit>	divide(AbstractFloatScalarRel<?,?> left, AbstractFloatScalarRel<?,?> right) Divide two values; the result is a new instance with a different (existing or generated) SI unit.
static <AU extends AbsoluteLinearUnit<AU,RU>,RU extends Unit<RU>,R extends AbstractFloatScalarRel<RU,R>,A extends AbstractFloatScalarAbs<AU,A,RU,R>> A	interpolate(A zero, A one, float ratio) Interpolate between or extrapolate over two values.
static <AU extends AbsoluteLinearUnit<AU,RU>,RU extends Unit<RU>> FloatScalar.Abs<AU,RU>	interpolate(FloatScalar.Abs<AU,RU> zero, FloatScalar.Abs<AU,RU> one, float ratio) Interpolate between or extrapolate over two values.
static <U extends Unit<U>> FloatScalar.Rel<U>	interpolate(FloatScalar.Rel<U> zero, FloatScalar.Rel<U> one, float ratio) Interpolate between or extrapolate over two values.
static <U extends Unit<U>,R extends AbstractFloatScalarRel<U,R>> R	interpolate(R zero, R one, float ratio) Interpolate between or extrapolate over two values.
static <AU extends AbsoluteLinearUnit<AU,RU>,RU extends Unit<RU>,R extends AbstractFloatScalarRel<RU,R>,A extends AbstractFloatScalarAbs<AU,A,RU,R>> R	minus(A left, A right) Subtract two absolute values.
static <AU extends AbsoluteLinearUnit<AU,RU>,RU extends Unit<RU>,R extends AbstractFloatScalarRel<RU,R>,A extends AbstractFloatScalarAbs<AU,A,RU,R>> A	minus(A left, R right) Subtract a Relative value from an absolute value.
static <U extends Unit<U>,R extends AbstractFloatScalarRel<U,R>> R	minus(R left, R right) Subtract a relative value from a relative value.
static FloatScalar.Rel<SIUnit>	multiply(AbstractFloatScalarRel<?,?> left, AbstractFloatScalarRel<?,?> right) Multiply two values; the result is a new instance with a different (existing or generated) SI unit.
static <AU extends AbsoluteLinearUnit<AU,RU>,RU extends Unit<RU>,R extends AbstractFloatScalarRel<RU,R>,A extends AbstractFloatScalarAbs<AU,A,RU,R>> A	plus(A left, R right) Add a Relative value to an Absolute value.
static <AU extends AbsoluteLinearUnit<AU,RU>,RU extends Unit<RU>,R extends AbstractFloatScalarRel<RU,R>,A extends AbstractFloatScalarAbs<AU,A,RU,R>> A	plus(R left, A right) Add an Absolute value to a Relative value.
static <U extends Unit<U>,R extends AbstractFloatScalarRel<U,R>> R	plus(R left, R right) Add a Relative value to a Relative value.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

FloatScalar

public FloatScalar()

Method Detail

plus

public static <AU extends AbsoluteLinearUnit<AU,RU>,RU extends Unit<RU>,R extends AbstractFloatScalarRel<RU,R>,A extends AbstractFloatScalarAbs<AU,A,RU,R>> A plus(A left,
                                                                                                                                                                   R right)

Add a Relative value to an Absolute value. Return a new instance of the value. The unit of the return value will be the unit of the left argument.

Type Parameters:

AU - Unit; the absolute unit of the parameter and the result

RU - Unit; the relative unit of the parameter

R - the relative type

A - the corresponding absolute type

Parameters:

left - A, an absolute typed FloatScalar; the left argument

right - R, a relative typed FloatScalar; the right argument

Returns:

A, an absolute typed FloatScalar; the sum of the values as an Absolute value

plus

public static <AU extends AbsoluteLinearUnit<AU,RU>,RU extends Unit<RU>,R extends AbstractFloatScalarRel<RU,R>,A extends AbstractFloatScalarAbs<AU,A,RU,R>> A plus(R left,
                                                                                                                                                                   A right)

Add an Absolute value to a Relative value. Return a new instance of the value. The unit of the return value will be the unit of the left argument.

Type Parameters:

AU - Unit; the absolute unit of the parameter and the result

RU - Unit; the relative unit of the parameter

R - the relative type

A - the corresponding absolute type

Parameters:

left - A, an absolute typed FloatScalar; the left argument

right - R, a relative typed FloatScalar; the right argument

Returns:

A, an absolute typed FloatScalar; the sum of the values as an Absolute value

plus

public static <U extends Unit<U>,R extends AbstractFloatScalarRel<U,R>> R plus(R left,
                                                                               R right)

Add a Relative value to a Relative value. Return a new instance of the value. The unit of the return value will be the unit of the left argument.

Type Parameters:

U - Unit; the unit of the parameters and the result

R - the relative type

Parameters:

left - R, a relative typed FloatScalar; the left argument

right - R, a relative typed FloatScalar; the right argument

Returns:

R, a relative typed FloatScalar; the sum of the values as a Relative value

minus

public static <AU extends AbsoluteLinearUnit<AU,RU>,RU extends Unit<RU>,R extends AbstractFloatScalarRel<RU,R>,A extends AbstractFloatScalarAbs<AU,A,RU,R>> A minus(A left,
                                                                                                                                                                    R right)

Subtract a Relative value from an absolute value. Return a new instance of the value. The unit of the return value will be the unit of the left argument.

Type Parameters:

AU - Unit; the absolute unit of the parameter and the result

RU - Unit; the relative unit of the parameter

R - the relative type

A - the corresponding absolute type

Parameters:

left - A, an absolute typed FloatScalar; the left value

right - R, a relative typed FloatScalar; the right value

Returns:

A, an absolute typed FloatScalar; the resulting value as an absolute value

minus

public static <U extends Unit<U>,R extends AbstractFloatScalarRel<U,R>> R minus(R left,
                                                                                R right)

Subtract a relative value from a relative value. Return a new instance of the value. The unit of the value will be the unit of the first argument.

Type Parameters:

U - Unit; the unit of the parameters and the result

R - the relative type

Parameters:

left - R, a relative typed FloatScalar; the left value

right - R, a relative typed FloatScalar; the right value

Returns:

R, a relative typed FloatScalar; the resulting value as a relative value

minus

public static <AU extends AbsoluteLinearUnit<AU,RU>,RU extends Unit<RU>,R extends AbstractFloatScalarRel<RU,R>,A extends AbstractFloatScalarAbs<AU,A,RU,R>> R minus(A left,
                                                                                                                                                                    A right)

Subtract two absolute values. Return a new instance of a relative value of the difference. The unit of the value will be the unit of the first argument.

Type Parameters:

AU - Unit; the absolute unit of the parameter

RU - Unit; the relative unit of the parameter and the result

R - the relative type

A - the corresponding absolute type

Parameters:

left - A, an absolute typed FloatScalar; value 1

right - A, an absolute typed FloatScalar; value 2

Returns:

R, a relative typed FloatScalar; the difference of the two absolute values as a relative value

interpolate

public static <AU extends AbsoluteLinearUnit<AU,RU>,RU extends Unit<RU>,R extends AbstractFloatScalarRel<RU,R>,A extends AbstractFloatScalarAbs<AU,A,RU,R>> A interpolate(A zero,
                                                                                                                                                                          A one,
                                                                                                                                                                          float ratio)

Interpolate between or extrapolate over two values.

Type Parameters:

AU - Unit; the absolute unit of the parameter and the result

RU - Unit; the relative unit belonging to the absolute unit

R - the relative type

A - the corresponding absolute type

Parameters:

zero - A, an absolute typed FloatScalar; zero reference (returned when ratio == 0)

one - A, an absolute typed FloatScalar; one reference (returned when ratio == 1)

ratio - float; the ratio that determines where between (or outside) zero and one the result lies

Returns:

Absolute FloatScalar

interpolate

public static <U extends Unit<U>,R extends AbstractFloatScalarRel<U,R>> R interpolate(R zero,
                                                                                      R one,
                                                                                      float ratio)

Interpolate between or extrapolate over two values.

Type Parameters:

U - Unit; the unit of the parameters and the result

R - the relative type

Parameters:

zero - R, a relative typed FloatScalar; zero reference (returned when ratio == 0)

one - R, a relative typed FloatScalar; one reference (returned when ratio == 1)

ratio - float; the ratio that determines where between (or outside) zero and one the result lies

Returns:

Relative FloatScalar

multiply

public static FloatScalar.Rel<SIUnit> multiply(AbstractFloatScalarRel<?,?> left,
                                               AbstractFloatScalarRel<?,?> right)

Multiply two values; the result is a new instance with a different (existing or generated) SI unit.

Parameters:

left - AbstractFloatScalarRel<?, ?>; the left operand

right - AbstractFloatScalarRel<?, ?>; the right operand

Returns:

FloatScalar.Rel<SIUnit>; the product of the two values

divide

public static FloatScalar.Rel<SIUnit> divide(AbstractFloatScalarRel<?,?> left,
                                             AbstractFloatScalarRel<?,?> right)

Divide two values; the result is a new instance with a different (existing or generated) SI unit.

Parameters:

left - AbstractFloatScalarRel<?, ?>; the left operand

right - AbstractFloatScalarRel<?, ?>; the right operand

Returns:

FloatScalar.Rel<SIUnit>; the ratio of the two values

interpolate

public static <AU extends AbsoluteLinearUnit<AU,RU>,RU extends Unit<RU>> FloatScalar.Abs<AU,RU> interpolate(FloatScalar.Abs<AU,RU> zero,
                                                                                                            FloatScalar.Abs<AU,RU> one,
                                                                                                            float ratio)

Interpolate between or extrapolate over two values.

Type Parameters:

AU - Unit; the absolute unit of the parameter and the result

RU - Unit; the relative unit belonging to the absolute unit

Parameters:

zero - FloatScalar.Abs<AU, RU>; zero reference (returned when ratio == 0)

one - FloatScalar.Abs<AU, RU>; one reference (returned when ratio == 1)

ratio - float; the ratio that determines where between (or outside) zero and one the result lies

Returns:

FloatScalar.Abs<U>

interpolate

public static <U extends Unit<U>> FloatScalar.Rel<U> interpolate(FloatScalar.Rel<U> zero,
                                                                 FloatScalar.Rel<U> one,
                                                                 float ratio)

Interpolate between or extrapolate over two values.

Type Parameters:

U - Unit; the unit of the parameters and the result

Parameters:

zero - FloatScalar.Rel<U>; zero reference (returned when ratio == 0)

one - FloatScalar.Rel<U>; one reference (returned when ratio == 1)

ratio - float; the ratio that determines where between (or outside) zero and one the result lies

Returns:

FloatScalar.Rel<U>