All Classes and Interfaces
Class
Description
Basic calculator implementation.
Abstract base class for creating convolutions of suitable type for the specified length.
Abstract base class for a data storage creation strategy.
This class represents an arbitrary precision field object.
Abstract base class for creating Number Theoretic Transforms suitable for the
specified length, based on available memory configured in the
ApfloatContext
.Abstract superclass for step-based FNT strategies.
Interface of a factory for creating addition strategies.
Generic addition strategy.
Arbitrary precision complex number class.
This class represents an arbitrary precision complex number.
Various mathematical functions for arbitrary precision complex numbers.
Arbitrary precision floating-point number class.
An ApfloatBuilder contains factory methods to create
new instances of
ApfloatImpl
implementations.Arbitrary precision calculator implementation.
Exception indicating an error in the apfloat configuration.
This class encapsulates the information needed by the apfloat implementation
to perform computations.
This class represents an arbitrary precision floating-point number.
Simple JavaBean to hold one
Apfloat
.Interface for apfloat implementations.
Exception indicating some unexpected apfloat
implementation specific error situation.
Exception indicating that the computation was interrupted.
Various mathematical functions for arbitrary precision floating-point numbers.
Exception indicating some unexpected error situation.
Arbitrary precision integer class.
Various mathematical functions for arbitrary precision integers.
Arbitrary precision rational number class.
This class represents an arbitrary precision rational number.
Various mathematical functions for arbitrary precision rational numbers.
The
ArrayAccess
class simulates a C
language pointer.Class for running an
Operation
in the background in a separate thread.Exception indicating a backing storage failure.
A
BuilderFactory
object contains factory methods for building
the various parts of an apfloat using the Builder pattern.Command-line calculator.
Calculator applet.
Graphical AWT elements for the calculator.
AWT client application for the calculator.
Calculator implementation interface.
Token literal values and constants.
Token Manager.
Interface of a factory for creating carry-CRT related objects.
Interface for performing the steps of a carry-CRT operation in a convolution.
Interface for performing the final step of a three-modulus
Number Theoretic Transform based convolution.
Six-step NTT implementation that processes the data in the columns of the matrix.
Two-pass NTT implementation that processes the data in the columns of the matrix.
Interface of a factory for creating convolutors.
Generic convolution strategy.
Generic data storage class.
Iterator for iterating through elements of the data storage.
Interface for determining a suitable storage
type for data of some expected size.
Abstract base class for disk-based data storage, containing the common
functionality independent of the element type.
Creates additions for the specified radix and the
double
element type.Basic addition strategy for the
double
element type.Builder class for building
ApfloatImpl
implementations with the
double
data element type.Immutable apfloat implementation class for the
double
data element type.Mathematical operations on numbers in a base.
Factory class for getting instances of the various builder classes needed
to build an
ApfloatImpl
with the double
data element type.Creates carry-CRT related objects, for the
double
type.Class for performing the final steps of a three-modulus
Number Theoretic Transform based convolution.
Constants needed for various algorithms for the
double
type.Creates convolutions of suitable type for the
double
type.Basic arithmetic for calculating the Chinese Remainder
Theorem.
Default data storage creation strategy for the
double
data type.Disk-based data storage for the
double
element type.Elementary modulo arithmetic functions for
double
data.Steps for the factor-3 NTT.
Convolution strategy using the Karatsuba algorithm.
Creates matrix operations objects, for the
double
type.Optimized matrix transposition methods for the
double
type.Medium-length convolution strategy.
Array access class based on a
double[]
.Memory based data storage implementation for the
double
element type.Constants needed for various modular arithmetic operations for the
double
type.Modulo arithmetic functions for
double
data.Creates Number Theoretic Transforms for the
double
type.Steps of a three-NTT convolution for the
double
type.Common methods to calculate Fast Number Theoretic Transforms
in parallel using multiple threads.
Constants related to different radixes for the
double
data type.Functions to perform bit-reverse ordering of
double
data.Short convolution strategy.
Fast Number Theoretic Transform that uses lookup tables
for powers of n:th root of unity and permutation indexes.
Fast Number Theoretic Transform strategy that uses lookup tables
for powers of n:th root of unity and permutation indexes.
Helper class for generating and caching tables of powers of the n:th root of unity.
Interface of a factory for creating execution related objects.
Thread execution operations.
Steps for the factor-3 NTT.
A transform that implements a 3-point transform on
top of another Number Theoretic Transform that does
transforms of length 2n.
Class for generating filenames for temporary files.
This class represents a fixed-precision complex number.
Fixed-precision mathematical functions for complex numbers.
This class represents a fixed-precision floating-point number.
Fixed-precision mathematical functions for floating-point numbers.
Creates additions for the specified radix and the
float
element type.Basic addition strategy for the
float
element type.Builder class for building
ApfloatImpl
implementations with the
float
data element type.Immutable apfloat implementation class for the
float
data element type.Mathematical operations on numbers in a base.
Factory class for getting instances of the various builder classes needed
to build an
ApfloatImpl
with the float
data element type.Creates carry-CRT related objects, for the
float
type.Class for performing the final steps of a three-modulus
Number Theoretic Transform based convolution.
Constants needed for various algorithms for the
float
type.Creates convolutions of suitable type for the
float
type.Basic arithmetic for calculating the Chinese Remainder
Theorem.
Default data storage creation strategy for the
float
data type.Disk-based data storage for the
float
element type.Elementary modulo arithmetic functions for
float
data.Steps for the factor-3 NTT.
Convolution strategy using the Karatsuba algorithm.
Creates matrix operations objects, for the
float
type.Optimized matrix transposition methods for the
float
type.Medium-length convolution strategy.
Array access class based on a
float[]
.Memory based data storage implementation for the
float
element type.Constants needed for various modular arithmetic operations for the
float
type.Modulo arithmetic functions for
float
data.Creates Number Theoretic Transforms for the
float
type.Steps of a three-NTT convolution for the
float
type.Common methods to calculate Fast Number Theoretic Transforms
in parallel using multiple threads.
Constants related to different radixes for the
float
data type.Functions to perform bit-reverse ordering of
float
data.Short convolution strategy.
Fast Number Theoretic Transform that uses lookup tables
for powers of n:th root of unity and permutation indexes.
Fast Number Theoretic Transform strategy that uses lookup tables
for powers of n:th root of unity and permutation indexes.
Helper class for generating and caching tables of powers of the n:th root of unity.
Calculator implementation with function support.
Handler for FixedFunction.
Arbitrary function.
Function implementations.
Exception indicating a different implementation of the apfloat SPI
being used in two operands of a calculation.
Exception indicating that the result of an operation
would have infinite size.
Creates additions for the specified radix and the
int
element type.Basic addition strategy for the
int
element type.Builder factory for aparapi transform implementations for the
int
element type.Steps for the factor-3 NTT using the GPU, for the
int
element type.Factor-3 NTT implementation for the
int
element type.Matrix transposition in the GPU for the
int
type.NTT Builder for aparapi transform implementations for the
int
element type.NTT steps for the
int
element type aparapi transforms.Six-step NTT implementation for the
int
element type.Builder class for building
ApfloatImpl
implementations with the
int
data element type.Immutable apfloat implementation class for the
int
data element type.Mathematical operations on numbers in a base.
Factory class for getting instances of the various builder classes needed
to build an
ApfloatImpl
with the int
data element type.Creates carry-CRT related objects, for the
int
type.Class for performing the final steps of a three-modulus
Number Theoretic Transform based convolution.
Constants needed for various algorithms for the
int
type.Creates convolutions of suitable type for the
int
type.Basic arithmetic for calculating the Chinese Remainder
Theorem.
Default data storage creation strategy for the
int
data type.Disk-based data storage for the
int
element type.Elementary modulo arithmetic functions for
int
data.Steps for the factor-3 NTT.
Convolution strategy using the Karatsuba algorithm.
Creates matrix operations objects, for the
int
type.Optimized matrix transposition methods for the
int
type.Medium-length convolution strategy.
Array access class based on a
int[]
.Memory based data storage implementation for the
int
element type.Constants needed for various modular arithmetic operations for the
int
type.Modulo arithmetic functions for
int
data.Creates Number Theoretic Transforms for the
int
type.Steps of a three-NTT convolution for the
int
type.Common methods to calculate Fast Number Theoretic Transforms
in parallel using multiple threads.
Constants related to different radixes for the
int
data type.Functions to perform bit-reverse ordering of
int
data.Short convolution strategy.
Fast Number Theoretic Transform that uses lookup tables
for powers of n:th root of unity and permutation indexes.
Fast Number Theoretic Transform strategy that uses lookup tables
for powers of n:th root of unity and permutation indexes.
Helper class for generating and caching tables of powers of the n:th root of unity.
Class to execute
Operation
s locally.Creates additions for the specified radix and the
long
element type.Basic addition strategy for the
long
element type.Builder factory for aparapi transform implementations for the
long
element type.Steps for the factor-3 NTT using the GPU, for the
long
element type.Factor-3 NTT implementation for the
long
element type.Matrix transposition in the GPU for the
long
type.NTT Builder for aparapi transform implementations for the
long
element type.NTT steps for the
long
element type aparapi transforms.Six-step NTT implementation for the
long
element type.Builder class for building
ApfloatImpl
implementations with the
long
data element type.Immutable apfloat implementation class for the
long
data element type.Mathematical operations on numbers in a base.
Factory class for getting instances of the various builder classes needed
to build an
ApfloatImpl
with the long
data element type.Creates carry-CRT related objects, for the
long
type.Class for performing the final steps of a three-modulus
Number Theoretic Transform based convolution.
Constants needed for various algorithms for the
long
type.Creates convolutions of suitable type for the
long
type.Basic arithmetic for calculating the Chinese Remainder
Theorem.
Default data storage creation strategy for the
long
data type.Disk-based data storage for the
long
element type.Elementary modulo arithmetic functions for
long
data.Steps for the factor-3 NTT.
Convolution strategy using the Karatsuba algorithm.
Creates matrix operations objects, for the
long
type.Optimized matrix transposition methods for the
long
type.Medium-length convolution strategy.
Array access class based on a
long[]
.Memory based data storage implementation for the
long
element type.Constants needed for various modular arithmetic operations for the
long
type.Modulo arithmetic functions for
long
data.Creates Number Theoretic Transforms for the
long
type.Steps of a three-NTT convolution for the
long
type.Common methods to calculate Fast Number Theoretic Transforms
in parallel using multiple threads.
Constants related to different radixes for the
long
data type.Functions to perform bit-reverse ordering of
long
data.Short convolution strategy.
Fast Number Theoretic Transform that uses lookup tables
for powers of n:th root of unity and permutation indexes.
Fast Number Theoretic Transform strategy that uses lookup tables
for powers of n:th root of unity and permutation indexes.
Helper class for generating and caching tables of powers of the n:th root of unity.
Exception indicating a result that would have no significant digits.
Interface of a factory for creating matrix related objects.
Matrix operations.
Message passing helper class for parallel codes.
This class represents an arbitrary precision modulo integer.
Interface of a factory for creating Number Theoretic Transforms.
Steps for a three-NTT convolution.
Steps for the six-step or two-pass NTT.
Number Theoretic Transform (NTT) strategy.
Exception indicating that something went wrong in a numeric computation.
Interface for implementing arbitrary operations to be executed.
Interface for implementing objects that can execute
Operation
s.Server for executing
Operation
s from remote calls.Exception indicating an overflow in a calculation.
Returns an execution strategy using the
ParallelRunner
.Execution strategy using the
ParallelRunner
.Any task that can use a
ParallelRunner
to execute operations in parallel.Abstract class for a
Runnable
that can be run in parallel by
multiple threads.Class for running
ParallelRunnable
objects in parallel using
multiple threads.Convolution using three Number Theoretic Transforms
and the CRT to get the final result, using multiple threads in parallel.
This exception is thrown when parse errors are encountered.
Calculates pi using four different algorithms.
Abstract base class for the binary splitting series.
Class for implementing the binary splitting algorithm.
Indicates progress of the pi calculation using
the binary splitting algorithm.
Terms for the binary splitting series.
Calculates pi using the Borweins' quartic algorithm.
Chudnovskys' algorithm terms for the binary splitting series.
Basic class for calculating pi using the Chudnovskys' binary splitting algorithm.
Calculates pi using the Gauss-Legendre algorithm.
Ramanujan's algorithm terms for the binary splitting series.
Basic class for calculating pi using the Ramanujan binary splitting algorithm.
Applet for calculating pi using four different algorithms.
Graphical AWT elements for calculating pi using four different algorithms.
Interface to indicate an error status in the application.
Calculates pi using a cluster of servers.
Distributed version of the binary splitting algorithm.
Class for calculating pi using the distributed Chudnovskys' binary splitting algorithm.
Class for calculating pi using the distributed Ramanujan's binary splitting algorithm.
RemoteOperationExecutor that implements the weight property.
AWT client application for calculating pi using four different algorithms.
Calculates pi using multiple threads in parallel.
Parallel version of the binary splitting algorithm.
Class for calculating pi using the parallel Chudnovskys' binary splitting algorithm.
Class for calculating pi using the parallel Ramanujan's binary splitting algorithm.
Class to execute operations while setting
ApfloatContext.setNumberOfProcessors(int)
to some value.Applet for calculating pi using multiple threads in parallel.
Graphical AWT elements for calculating pi using multiple threads in parallel.
AWT client application for calculating pi using multiple threads in parallel.
Constants related to different radixes.
Exception indicating a different radix being used in two operands
of a calculation.
Class to call an
OperationServer
to execute Operation
s remotely.Functions to perform bit-reverse ordering of data.
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
Fast Number Theoretic Transform that uses a "six-step"
algorithm to calculate a long transform more efficiently on
cache-based memory architectures.
Class for performing the final step of a three-modulus
Number Theoretic Transform based convolution.
Convolution using three Number Theoretic Transforms
and the Chinese Remainder Theorem to get the final result.
Describes the input token stream.
Token Manager Error.
Exception indicating that the "size" of the numbers used in a
multiplication is too large.
Fast Number Theoretic Transform that uses a "two-pass"
algorithm to calculate a very long transform on data that
resides on a mass storage device.
Miscellaneous utility methods.