Module ojalgo

Package org.ojalgo.scalar

Class Quadruple

java.lang.Object

org.ojalgo.scalar.Quadruple

All Implemented Interfaces:

java.lang.Comparable<Quadruple>, Field<Scalar<Quadruple>>, Group, Group.Additive<Scalar<Quadruple>>, Group.Multiplicative<Scalar<Quadruple>>, NormedVectorSpace<Scalar<Quadruple>,Quadruple>, Operation, Operation.Addition<Scalar<Quadruple>>, Operation.Division<Scalar<Quadruple>>, Operation.Multiplication<Scalar<Quadruple>>, Operation.Subtraction<Scalar<Quadruple>>, Ring<Scalar<Quadruple>>, ScalarOperation, ScalarOperation.Addition<Scalar<Quadruple>,Quadruple>, ScalarOperation.Division<Scalar<Quadruple>,Quadruple>, ScalarOperation.Multiplication<Scalar<Quadruple>,Quadruple>, ScalarOperation.Subtraction<Scalar<Quadruple>,Quadruple>, VectorSpace<Scalar<Quadruple>,Quadruple>, Scalar<Quadruple>, SelfDeclaringScalar<Quadruple>, AccessScalar<Quadruple>, Tensor<Quadruple,Scalar<Quadruple>>, NumberContext.Enforceable<Quadruple>, NumberDefinition

public class Quadruple
extends java.lang.Object
implements SelfDeclaringScalar<Quadruple>

https://stackoverflow.com/questions/66962567/how-to-emulate-double-precision-using-two-floats-in-opengl-es

https://blog.cyclemap.link/2011-06-09-glsl-part2-emu/

https://www.researchgate.net/publication/228570156_Library_for_Double-Double_and_Quad-Double_Arithmetic

https://libntl.org

http://mrob.com/pub/math/f161.html

https://www.davidhbailey.com/dhbsoftware/

Nested Class Summary

Nested classes/interfaces inherited from interface org.ojalgo.algebra.Group

Group.Additive<T>, Group.Multiplicative<T>

Nested classes/interfaces inherited from interface org.ojalgo.algebra.Operation

Operation.Addition<T>, Operation.Division<T>, Operation.Multiplication<T>, Operation.Subtraction<T>

Nested classes/interfaces inherited from interface org.ojalgo.scalar.Scalar

Scalar.Factory<N extends java.lang.Comparable<N>>

Nested classes/interfaces inherited from interface org.ojalgo.algebra.ScalarOperation

ScalarOperation.Addition<T,N extends java.lang.Comparable<N>>, ScalarOperation.Division<T,N extends java.lang.Comparable<N>>, ScalarOperation.Multiplication<T,N extends java.lang.Comparable<N>>, ScalarOperation.Subtraction<T,N extends java.lang.Comparable<N>>

Field Summary

Fields

Modifier and Type	Field	Description
static Scalar.Factory<Quadruple>	FACTORY
static Quadruple	MAX_VALUE
static Quadruple	MIN_VALUE
private double	myBase
private java.math.BigDecimal	myDecimal
private double	myRemainder
static Quadruple	NaN
static Quadruple	NEG
static Quadruple	NEGATIVE_INFINITY
static Quadruple	ONE
static Quadruple	POSITIVE_INFINITY
private static double	SPLIT	1+2^27 (Example code, that emulated double using float, had 1+2^13)
static Quadruple	TWO
static Quadruple	ZERO

Constructor Summary

Constructors

Modifier	Constructor	Description
	Quadruple()
private	Quadruple(double base)
private	Quadruple(double base, double remainder)

Method Summary

Modifier and Type	Method	Description
Quadruple	add(double arg)
private static Quadruple	add(double base1, double remainder1, double base2, double remainder2)	https://blog.cyclemap.link/2011-06-09-glsl-part2-emu/
Quadruple	add(Quadruple arg)
int	compareTo(Quadruple reference)
Quadruple	conjugate()	This method will (most likely) be moved to some other interface in the future! Just have to figure out where it fits...
Quadruple	divide(double arg)
private static Quadruple	divide(double base1, double remainder1, double base2, double remainder2)	High-precision division.
Quadruple	divide(Quadruple arg)
private static Quadruple	divide(Quadruple arg1, Quadruple arg2)
double	doubleValue()
Quadruple	enforce(NumberContext context)
boolean	equals(java.lang.Object obj)
float	floatValue()
Quadruple	get()
(package private) double	getBase()
(package private) double	getRemainder()
int	hashCode()
int	intValue()
Quadruple	invert()	The multiplicative inverse.
boolean	isAbsolute()
static boolean	isAbsolute(Quadruple value)
static boolean	isInfinite(Quadruple value)
static boolean	isNaN(Quadruple value)
boolean	isSmall(double comparedTo)
static boolean	isSmall(double comparedTo, Quadruple value)
boolean	isZero()	Tests if this scalar value is exactly zero.
long	longValue()
Quadruple	multiply(double arg)
private static Quadruple	multiply(double base1, double remainder1, double base2, double remainder2)	https://blog.cyclemap.link/2011-06-09-glsl-part2-emu/
Quadruple	multiply(Quadruple arg)
Quadruple	negate()	The additive inverse of this.
double	norm()	this == this.signum().multiply(this.norm())
static Quadruple	parse(java.lang.CharSequence plainNumberString)
Quadruple	power(int power)	Multiply by itself power times.
private int	sign()
Quadruple	signum()	this == this.signum().multiply(this.norm())
Quadruple	subtract(double arg)
Quadruple	subtract(Quadruple arg)
java.math.BigDecimal	toBigDecimal()
private java.math.BigDecimal	toBigDecimal(java.math.MathContext context)
java.lang.String	toString()
java.lang.String	toString(NumberContext context)
static Quadruple	valueOf(double value)
static Quadruple	valueOf(java.lang.Comparable<?> number)
static Quadruple	valueOf(java.math.BigDecimal number)

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.ojalgo.type.NumberDefinition

booleanValue, byteValue, shortValue

Methods inherited from interface org.ojalgo.scalar.Scalar

add, dimensions, divide, multiply, rank, subtract, toPlainString

Methods inherited from interface org.ojalgo.scalar.SelfDeclaringScalar

add, divide, multiply, subtract

Methods inherited from interface org.ojalgo.tensor.Tensor

components, isSameShape

Field Detail

FACTORY

public static Scalar.Factory<Quadruple> FACTORY

MAX_VALUE

public static final Quadruple MAX_VALUE

MIN_VALUE

public static final Quadruple MIN_VALUE

NaN

public static final Quadruple NaN

NEG

public static final Quadruple NEG

NEGATIVE_INFINITY

public static final Quadruple NEGATIVE_INFINITY

ONE

public static final Quadruple ONE

POSITIVE_INFINITY

public static final Quadruple POSITIVE_INFINITY

TWO

public static final Quadruple TWO

ZERO

public static final Quadruple ZERO

SPLIT

private static final double SPLIT

1+2^27 (Example code, that emulated double using float, had 1+2^13)

See Also:

Constant Field Values

myBase

private final double myBase

myDecimal

private transient java.math.BigDecimal myDecimal

myRemainder

private final double myRemainder

Constructor Detail

Quadruple

public Quadruple()

Quadruple

private Quadruple(double base)

Quadruple

private Quadruple(double base,
                  double remainder)

Method Detail

isAbsolute

public static boolean isAbsolute(Quadruple value)

isInfinite

public static boolean isInfinite(Quadruple value)

isNaN

public static boolean isNaN(Quadruple value)

isSmall

public static boolean isSmall(double comparedTo,
                              Quadruple value)

parse

public static Quadruple parse(java.lang.CharSequence plainNumberString)

valueOf

public static Quadruple valueOf(java.math.BigDecimal number)

valueOf

public static Quadruple valueOf(java.lang.Comparable<?> number)

valueOf

public static Quadruple valueOf(double value)

add

private static Quadruple add(double base1,
                             double remainder1,
                             double base2,
                             double remainder2)

https://blog.cyclemap.link/2011-06-09-glsl-part2-emu/

divide

private static Quadruple divide(double base1,
                                double remainder1,
                                double base2,
                                double remainder2)

High-precision division.

divide

private static Quadruple divide(Quadruple arg1,
                                Quadruple arg2)

multiply

private static Quadruple multiply(double base1,
                                  double remainder1,
                                  double base2,
                                  double remainder2)

https://blog.cyclemap.link/2011-06-09-glsl-part2-emu/

add

public Quadruple add(double arg)

Specified by:

add in interface ScalarOperation.Addition<Scalar<Quadruple>,Quadruple>

Specified by:

add in interface SelfDeclaringScalar<Quadruple>

Returns:

this + scalarAddend.

add

public Quadruple add(Quadruple arg)

Specified by:

add in interface ScalarOperation.Addition<Scalar<Quadruple>,Quadruple>

Specified by:

add in interface SelfDeclaringScalar<Quadruple>

Returns:

this + scalarAddend.

compareTo

public int compareTo(Quadruple reference)

Specified by:

compareTo in interface java.lang.Comparable<Quadruple>

conjugate

public Quadruple conjugate()

Description copied from interface: VectorSpace

This method will (most likely) be moved to some other interface in the future! Just have to figure out where it fits...

The conjugate transpose of a matrix and/or the conjugate of a scalar/field like ComplexNumber or Quaternion.

The conjugate transpose of a real matrix is simply its transpose.

Specified by:

conjugate in interface SelfDeclaringScalar<Quadruple>

Specified by:

conjugate in interface VectorSpace<Scalar<Quadruple>,Quadruple>

divide

public Quadruple divide(double arg)

Specified by:

divide in interface ScalarOperation.Division<Scalar<Quadruple>,Quadruple>

Specified by:

divide in interface SelfDeclaringScalar<Quadruple>

Returns:

this / scalarDivisor.

divide

public Quadruple divide(Quadruple arg)

Specified by:

divide in interface ScalarOperation.Division<Scalar<Quadruple>,Quadruple>

Specified by:

divide in interface SelfDeclaringScalar<Quadruple>

Returns:

this / scalarDivisor.

doubleValue

public double doubleValue()

Specified by:

doubleValue in interface NumberDefinition

enforce

public Quadruple enforce(NumberContext context)

Specified by:

enforce in interface NumberContext.Enforceable<Quadruple>

equals

public boolean equals(java.lang.Object obj)

Overrides:

equals in class java.lang.Object

floatValue

public float floatValue()

Specified by:

floatValue in interface NumberDefinition

get

public Quadruple get()

Specified by:

get in interface AccessScalar<Quadruple>

hashCode

public int hashCode()

Overrides:

hashCode in class java.lang.Object

intValue

public int intValue()

Specified by:

intValue in interface NumberDefinition

invert

public Quadruple invert()

Description copied from interface: Group.Multiplicative

The multiplicative inverse.

Specified by:

invert in interface Group.Multiplicative<Scalar<Quadruple>>

Specified by:

invert in interface SelfDeclaringScalar<Quadruple>

Returns:

IDENTITY / this.

isAbsolute

public boolean isAbsolute()

Specified by:

isAbsolute in interface Scalar<Quadruple>

Returns:

true if this is equal to its own norm, modulus or absolute value (non-negative real part and no imaginary part); otherwise false.

See Also:

Scalar.isAbsolute()

isSmall

public boolean isSmall(double comparedTo)

Specified by:

isSmall in interface NormedVectorSpace<Scalar<Quadruple>,Quadruple>

Parameters:

comparedTo - What to compare with

Returns:

true if this is small compared to the magnitude of the input reference value.

isZero

public boolean isZero()

Description copied from interface: Scalar

Tests if this scalar value is exactly zero.

Each implementation should test for zero as exactly as possible based on what's achievable with that specific scalar type. The purpose is NOT to have similar behavior between different implementations, but rather to leverage the full precision and capabilities of each type.

For example:

• Primitive types (like double) should use exact equality comparison
• High-precision types (like Quadruple) should check both base and remainder components
• Arbitrary-precision types (like BigDecimal) should use their built-in zero detection
• Complex types should check both real and imaginary parts

This method should NOT use tolerance-based comparisons or approximate zero detection, as those are better handled by context-aware methods like NormedVectorSpace.isSmall(double).

Specified by:

isZero in interface Scalar<Quadruple>

Returns:

true if this scalar represents exactly zero, false otherwise

See Also:

NormedVectorSpace.isSmall(double)

longValue

public long longValue()

Specified by:

longValue in interface NumberDefinition

multiply

public Quadruple multiply(double arg)

Specified by:

multiply in interface ScalarOperation.Multiplication<Scalar<Quadruple>,Quadruple>

Specified by:

multiply in interface SelfDeclaringScalar<Quadruple>

Returns:

this * scalarMultiplicand.

multiply

public Quadruple multiply(Quadruple arg)

Specified by:

multiply in interface ScalarOperation.Multiplication<Scalar<Quadruple>,Quadruple>

Specified by:

multiply in interface SelfDeclaringScalar<Quadruple>

Returns:

this * multiplicand.

negate

public Quadruple negate()

Description copied from interface: Group.Additive

The additive inverse of this.

Specified by:

negate in interface Group.Additive<Scalar<Quadruple>>

Specified by:

negate in interface SelfDeclaringScalar<Quadruple>

Returns:

-this.

norm

public double norm()

Description copied from interface: NormedVectorSpace

this == this.signum().multiply(this.norm())

Specified by:

norm in interface NormedVectorSpace<Scalar<Quadruple>,Quadruple>

Returns:

The norm

power

public Quadruple power(int power)

Description copied from interface: Operation.Multiplication

Multiply by itself power times.

Specified by:

power in interface Operation.Multiplication<Scalar<Quadruple>>

Specified by:

power in interface SelfDeclaringScalar<Quadruple>

signum

public Quadruple signum()

Description copied from interface: NormedVectorSpace

this == this.signum().multiply(this.norm())

Specified by:

signum in interface NormedVectorSpace<Scalar<Quadruple>,Quadruple>

Specified by:

signum in interface SelfDeclaringScalar<Quadruple>

Returns:

A unit "vector"

subtract

public Quadruple subtract(double arg)

Specified by:

subtract in interface ScalarOperation.Subtraction<Scalar<Quadruple>,Quadruple>

Specified by:

subtract in interface SelfDeclaringScalar<Quadruple>

Returns:

this - scalarSubtrahend.

subtract

public Quadruple subtract(Quadruple arg)

Specified by:

subtract in interface ScalarOperation.Subtraction<Scalar<Quadruple>,Quadruple>

Specified by:

subtract in interface SelfDeclaringScalar<Quadruple>

Returns:

this - scalarSubtrahend.

toBigDecimal

public java.math.BigDecimal toBigDecimal()

Specified by:

toBigDecimal in interface Scalar<Quadruple>

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object

toString

public java.lang.String toString(NumberContext context)

Specified by:

toString in interface Scalar<Quadruple>

sign

private int sign()

toBigDecimal

private java.math.BigDecimal toBigDecimal(java.math.MathContext context)

getBase

double getBase()

getRemainder

double getRemainder()