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.
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.
Various mathematical functions for arbitrary precision complex numbers.
Default initial settings for the global
ApfloatContext.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.
Various utility methods related to apfloats.
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.
Simple JavaBean to hold one apfloat.
Exception indicating some unexpected error situation.
Arbitrary precision integer class.
Various mathematical functions for arbitrary precision integers.
Arbitrary precision rational number class.
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.
Helper class for Bessel functions.
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.
Map with an underlying ConcurrentHashMap with softly referenced values.
ConcurrentHashMap with softly referenced values.
Combination of WeakHashMap and ConcurrentHashMap,
providing weak keys and non-blocking access.
Helper class for continued fractions.
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.
Helper class for computing the Euler gamma using binary splitting and the Brent-McMillan formula.
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.
Fixed-precision mathematical functions for complex numbers.
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.
Helper class for formatting.
Calculator implementation with function support.
Handler for FixedFunction.
Arbitrary function.
Function implementations.
Binary recursive GCD algorithm implementation.
Helper class for the Hurwitz zeta function.
Helper class for hypergeometric functions.
Exception indicating a different implementation of the apfloat SPI
being used in two operands of a calculation.
Helper class for the incomplete gamma function.
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 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.
Helper class for Lambert W function.
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 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.
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.Helper methods for parallel algorithms.
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.
Helper class for radix conversion.
Exception indicating a different radix being used in two operands
of a calculation.
Class to call an
OperationServer to execute Operations remotely.Helper class for finding roots of functions.
Helper class for rounding functions.
Functions to perform bit-reverse ordering of data.
Map that always throws
ApfloatRuntimeException on all operations.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.
Helper class for the Riemann zeta function.