org.djunits.value.vdouble.scalar

Class DoubleScalar

java.lang.Object

org.djunits.value.vdouble.scalar.DoubleScalar

public abstract class DoubleScalar
extends Object

Immutable DoubleScalar, with Abs and Rel static subclasses.

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	DoubleScalar.Abs<AU extends AbsoluteLinearUnit<AU,RU>,RU extends Unit<RU>> Absolute Immutable DoubleScalar.
static class	DoubleScalar.Rel<U extends Unit<U>> Relative Immutable DoubleScalar.

Constructor Summary

Constructors

Constructor and Description
DoubleScalar()

Method Summary

Modifier and Type	Method and Description
static DoubleScalar.Rel<SIUnit>	divide(AbstractDoubleScalarRel<?,?> left, AbstractDoubleScalarRel<?,?> 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 AbstractDoubleScalarRel<RU,R>,A extends AbstractDoubleScalarAbs<AU,A,RU,R>> A	interpolate(A zero, A one, double ratio) Interpolate between two values.
static <U extends Unit<U>,R extends AbstractDoubleScalarRel<U,R>> R	interpolate(R zero, R one, double ratio) Interpolate between two values.
static <U extends Unit<U>,T extends AbstractDoubleScalar<U,T>> T	max(T r1, T r2) Return the maximum value of two relative scalars.
static <U extends Unit<U>,T extends AbstractDoubleScalar<U,T>> T	max(T r1, T r2, T... rn) Return the maximum value of more than two relative scalars.
static <U extends Unit<U>,T extends AbstractDoubleScalar<U,T>> T	min(T r1, T r2) Return the minimum value of two relative scalars.
static <U extends Unit<U>,T extends AbstractDoubleScalar<U,T>> T	min(T r1, T r2, T... rn) Return the minimum value of more than two relative scalars.
static <AU extends AbsoluteLinearUnit<AU,RU>,RU extends Unit<RU>,R extends AbstractDoubleScalarRel<RU,R>,A extends AbstractDoubleScalarAbs<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 AbstractDoubleScalarRel<RU,R>,A extends AbstractDoubleScalarAbs<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 AbstractDoubleScalarRel<U,R>> R	minus(R left, R right) Subtract a relative value from a relative value.
static DoubleScalar.Rel<SIUnit>	multiply(AbstractDoubleScalarRel<?,?> left, AbstractDoubleScalarRel<?,?> 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 AbstractDoubleScalarRel<RU,R>,A extends AbstractDoubleScalarAbs<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 AbstractDoubleScalarRel<RU,R>,A extends AbstractDoubleScalarAbs<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 AbstractDoubleScalarRel<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

DoubleScalar

public DoubleScalar()

Method Detail

plus

public static <AU extends AbsoluteLinearUnit<AU,RU>,RU extends Unit<RU>,R extends AbstractDoubleScalarRel<RU,R>,A extends AbstractDoubleScalarAbs<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 parameters and the result

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

R - the relative type

A - the corresponding absolute type

Parameters:

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

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

Returns:

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

plus

public static <AU extends AbsoluteLinearUnit<AU,RU>,RU extends Unit<RU>,R extends AbstractDoubleScalarRel<RU,R>,A extends AbstractDoubleScalarAbs<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 parameters and the result

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

R - the relative type

A - the corresponding absolute type

Parameters:

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

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

Returns:

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

plus

public static <U extends Unit<U>,R extends AbstractDoubleScalarRel<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 DoubleScalar; the left argument

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

Returns:

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

minus

public static <AU extends AbsoluteLinearUnit<AU,RU>,RU extends Unit<RU>,R extends AbstractDoubleScalarRel<RU,R>,A extends AbstractDoubleScalarAbs<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 parameters and the result

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

R - the relative type

A - the corresponding absolute type

Parameters:

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

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

Returns:

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

minus

public static <U extends Unit<U>,R extends AbstractDoubleScalarRel<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 DoubleScalar; the left value

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

Returns:

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

minus

public static <AU extends AbsoluteLinearUnit<AU,RU>,RU extends Unit<RU>,R extends AbstractDoubleScalarRel<RU,R>,A extends AbstractDoubleScalarAbs<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 parameters and the result

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

R - the relative type

A - the corresponding absolute type

Parameters:

left - A, an absolute typed DoubleScalar; value 1

right - A, an absolute typed DoubleScalar; value 2

Returns:

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

multiply

public static DoubleScalar.Rel<SIUnit> multiply(AbstractDoubleScalarRel<?,?> left,
                                                AbstractDoubleScalarRel<?,?> right)

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

Parameters:

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

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

Returns:

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

divide

public static DoubleScalar.Rel<SIUnit> divide(AbstractDoubleScalarRel<?,?> left,
                                              AbstractDoubleScalarRel<?,?> right)

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

Parameters:

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

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

Returns:

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

interpolate

public static <U extends Unit<U>,R extends AbstractDoubleScalarRel<U,R>> R interpolate(R zero,
                                                                                       R one,
                                                                                       double ratio)

Interpolate between two values. Made to be able to call e.g., Area a = DoubleScalar.interpolate(a1, a2, 0.4);

Type Parameters:

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

R - the relative type

Parameters:

zero - R; the low value

one - R; the high value

ratio - double; the ratio between 0 and 1, inclusive

Returns:

a Scalar at the ratio between

interpolate

public static <AU extends AbsoluteLinearUnit<AU,RU>,RU extends Unit<RU>,R extends AbstractDoubleScalarRel<RU,R>,A extends AbstractDoubleScalarAbs<AU,A,RU,R>> A interpolate(A zero,
                                                                                                                                                                            A one,
                                                                                                                                                                            double ratio)

Interpolate between two values. Made to be able to call e.g., Time t = DoubleScalar.interpolate(t1, t2, 0.4);

Type Parameters:

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

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

R - the relative type

A - the corresponding absolute type

Parameters:

zero - A; the low value

one - A; the high value

ratio - double; the ratio between 0 and 1, inclusive

Returns:

a Scalar at the ratio between

max

public static <U extends Unit<U>,T extends AbstractDoubleScalar<U,T>> T max(T r1,
                                                                            T r2)

Return the maximum value of two relative scalars.

Type Parameters:

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

T - the argument and result type

Parameters:

r1 - T; the first scalar

r2 - T; the second scalar

Returns:

the maximum value of two relative scalars

max

@SafeVarargs
public static <U extends Unit<U>,T extends AbstractDoubleScalar<U,T>> T max(T r1,
                                                                                          T r2,
                                                                                          T... rn)

Return the maximum value of more than two relative scalars.

Type Parameters:

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

T - the argument and result type

Parameters:

r1 - T; the first scalar

r2 - T; the second scalar

rn - T...; the other scalars

Returns:

the maximum value of more than two relative scalars

min

public static <U extends Unit<U>,T extends AbstractDoubleScalar<U,T>> T min(T r1,
                                                                            T r2)

Return the minimum value of two relative scalars.

Type Parameters:

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

T - the argument and result type

Parameters:

r1 - T; the first scalar

r2 - T; the second scalar

Returns:

the minimum value of two relative scalars

min

@SafeVarargs
public static <U extends Unit<U>,T extends AbstractDoubleScalar<U,T>> T min(T r1,
                                                                                          T r2,
                                                                                          T... rn)

Return the minimum value of more than two relative scalars.

Type Parameters:

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

T - the argument and result type

Parameters:

r1 - T; the first scalar

r2 - T; the second scalar

rn - T...; the other scalars

Returns:

the minimum value of more than two relative scalars