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 Operations 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 Operations.
Server for executing Operations 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 Operations 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.