All Classes Interface Summary Class Summary Enum Summary Exception Summary Error Summary
| Class |
Description |
| AbstractCalculatorImpl |
Basic calculator implementation.
|
| AbstractConvolutionBuilder |
Abstract base class for creating convolutions of suitable type for the specified length.
|
| AbstractDataStorageBuilder |
Abstract base class for a data storage creation strategy.
|
| AbstractNTTBuilder |
Abstract base class for creating Number Theoretic Transforms suitable for the
specified length, based on available memory configured in the ApfloatContext.
|
| AbstractStepFNTStrategy |
Abstract superclass for step-based FNT strategies.
|
| AdditionBuilder<T> |
Interface of a factory for creating addition strategies.
|
| AdditionStrategy<T> |
Generic addition strategy.
|
| Apcomplex |
Arbitrary precision complex number class.
|
| ApcomplexMath |
Various mathematical functions for arbitrary precision complex numbers.
|
| apfloat |
|
| Apfloat |
Arbitrary precision floating-point number class.
|
| ApfloatBuilder |
An ApfloatBuilder contains factory methods to create
new instances of ApfloatImpl implementations.
|
| ApfloatCalculatorImpl |
Arbitrary precision calculator implementation.
|
| ApfloatConfigurationException |
Exception indicating an error in the apfloat configuration.
|
| ApfloatContext |
This class encapsulates the information needed by the apfloat implementation
to perform computations.
|
| ApfloatContext.CleanupThread |
|
| ApfloatHelper |
Various utility methods related to apfloats.
|
| ApfloatHolder |
Simple JavaBean to hold one Apfloat.
|
| ApfloatImpl |
Interface for apfloat implementations.
|
| ApfloatInternalException |
Exception indicating some unexpected apfloat
implementation specific error situation.
|
| ApfloatInterruptedException |
Exception indicating that the computation was interrupted.
|
| ApfloatMath |
Various mathematical functions for arbitrary precision floating-point numbers.
|
| ApfloatMath.ApfloatHolder |
Simple JavaBean to hold one apfloat.
|
| ApfloatMath.PiCalculator |
|
| ApfloatRuntimeException |
Exception indicating some unexpected error situation.
|
| Apint |
Arbitrary precision integer class.
|
| ApintMath |
Various mathematical functions for arbitrary precision integers.
|
| Aprational |
Arbitrary precision rational number class.
|
| AprationalMath |
Various mathematical functions for arbitrary precision rational numbers.
|
| ArrayAccess |
The ArrayAccess class simulates a C language pointer.
|
| BackgroundOperation<T> |
Class for running an Operation in the background in a separate thread.
|
| BackingStorageException |
Exception indicating a backing storage failure.
|
| BesselHelper |
Helper class for Bessel functions.
|
| BuilderFactory |
A BuilderFactory object contains factory methods for building
the various parts of an apfloat using the Builder pattern.
|
| Calculator |
Command-line calculator.
|
| CalculatorApplet |
Calculator applet.
|
| CalculatorAWT |
Graphical AWT elements for the calculator.
|
| CalculatorAWT.FlushStringWriter |
|
| CalculatorGUI |
AWT client application for the calculator.
|
| CalculatorImpl |
Calculator implementation interface.
|
| CalculatorParser |
|
| CalculatorParser.LookaheadSuccess |
|
| CalculatorParserConstants |
Token literal values and constants.
|
| CalculatorParserTokenManager |
Token Manager.
|
| CarryCRTBuilder<T> |
Interface of a factory for creating carry-CRT related objects.
|
| CarryCRTStepStrategy<T> |
Interface for performing the steps of a carry-CRT operation in a convolution.
|
| CarryCRTStrategy |
Interface for performing the final step of a three-modulus
Number Theoretic Transform based convolution.
|
| ColumnSixStepFNTStrategy |
Six-step NTT implementation that processes the data in the columns of the matrix.
|
| ColumnTwoPassFNTStrategy |
Two-pass NTT implementation that processes the data in the columns of the matrix.
|
| ConcurrentSoftHashMap<K,V> |
Map with an underlying ConcurrentHashMap with softly referenced values.
|
| ConcurrentSoftHashMap<K,V> |
ConcurrentHashMap with softly referenced values.
|
| ConcurrentWeakHashMap<K,V> |
Combination of WeakHashMap and ConcurrentHashMap,
providing weak keys and non-blocking access.
|
| ConcurrentWeakHashMap.Key |
|
| ContinuedFractionHelper |
Helper class for continued fractions.
|
| ContinuedFractionHelper.ContinuedFractionIterator<T extends Apfloat> |
|
| ConvolutionBuilder |
Interface of a factory for creating convolutors.
|
| ConvolutionStrategy |
Generic convolution strategy.
|
| DataStorage |
Generic data storage class.
|
| DataStorage.Iterator |
Iterator for iterating through elements of the data storage.
|
| DataStorageBuilder |
Interface for determining a suitable storage
type for data of some expected size.
|
| DiskDataStorage |
Abstract base class for disk-based data storage, containing the common
functionality independent of the element type.
|
| DiskDataStorage.FileStorage |
|
| DiskDataStorage.FileStorageReference |
|
| DoubleAdditionBuilder |
Creates additions for the specified radix and the double element type.
|
| DoubleAdditionStrategy |
Basic addition strategy for the double element type.
|
| DoubleApfloatBuilder |
Builder class for building ApfloatImpl implementations with the
double data element type.
|
| DoubleApfloatImpl |
Immutable apfloat implementation class for the
double data element type.
|
| DoubleBaseMath |
Mathematical operations on numbers in a base.
|
| DoubleBuilderFactory |
Factory class for getting instances of the various builder classes needed
to build an ApfloatImpl with the double data element type.
|
| DoubleCarryCRTBuilder |
Creates carry-CRT related objects, for the
double type.
|
| DoubleCarryCRTStepStrategy |
Class for performing the final steps of a three-modulus
Number Theoretic Transform based convolution.
|
| DoubleConstants |
Constants needed for various algorithms for the double type.
|
| DoubleConvolutionBuilder |
Creates convolutions of suitable type for the double type.
|
| DoubleCRTMath |
Basic arithmetic for calculating the Chinese Remainder
Theorem.
|
| DoubleDataStorageBuilder |
Default data storage creation strategy for the double data type.
|
| DoubleDiskDataStorage |
Disk-based data storage for the double element type.
|
| DoubleElementaryModMath |
Elementary modulo arithmetic functions for double data.
|
| DoubleFactor3NTTStepStrategy |
Steps for the factor-3 NTT.
|
| DoubleKaratsubaConvolutionStrategy |
Convolution strategy using the Karatsuba algorithm.
|
| DoubleMatrixBuilder |
Creates matrix operations objects, for the
double type.
|
| DoubleMatrixStrategy |
Optimized matrix transposition methods for the double type.
|
| DoubleMediumConvolutionStrategy |
Medium-length convolution strategy.
|
| DoubleMemoryArrayAccess |
Array access class based on a double[].
|
| DoubleMemoryDataStorage |
Memory based data storage implementation for the double
element type.
|
| DoubleModConstants |
Constants needed for various modular arithmetic operations for the double type.
|
| DoubleModMath |
Modulo arithmetic functions for double data.
|
| DoubleNTTBuilder |
Creates Number Theoretic Transforms for the
double type.
|
| DoubleNTTConvolutionStepStrategy |
Steps of a three-NTT convolution for the double type.
|
| DoubleNTTStepStrategy |
Common methods to calculate Fast Number Theoretic Transforms
in parallel using multiple threads.
|
| DoubleRadixConstants |
Constants related to different radixes for the double data type.
|
| DoubleScramble |
Functions to perform bit-reverse ordering of double data.
|
| DoubleShortConvolutionStrategy |
Short convolution strategy.
|
| DoubleTableFNT |
Fast Number Theoretic Transform that uses lookup tables
for powers of n:th root of unity and permutation indexes.
|
| DoubleTableFNTStrategy |
Fast Number Theoretic Transform strategy that uses lookup tables
for powers of n:th root of unity and permutation indexes.
|
| DoubleWTables |
Helper class for generating and caching tables of powers of the n:th root of unity.
|
| EulerHelper |
Helper class for computing the Euler gamma using binary splitting and the Brent-McMillan formula.
|
| ExecutionBuilder |
Interface of a factory for creating execution related objects.
|
| ExecutionStrategy |
Thread execution operations.
|
| Factor3NTTStepStrategy |
Steps for the factor-3 NTT.
|
| Factor3NTTStrategy |
A transform that implements a 3-point transform on
top of another Number Theoretic Transform that does
transforms of length 2n.
|
| FilenameGenerator |
Class for generating filenames for temporary files.
|
| FixedPrecisionApcomplexHelper |
Fixed-precision mathematical functions for complex numbers.
|
| FixedPrecisionApfloatHelper |
Fixed-precision mathematical functions for floating-point numbers.
|
| FloatAdditionBuilder |
Creates additions for the specified radix and the float element type.
|
| FloatAdditionStrategy |
Basic addition strategy for the float element type.
|
| FloatApfloatBuilder |
Builder class for building ApfloatImpl implementations with the
float data element type.
|
| FloatApfloatImpl |
Immutable apfloat implementation class for the
float data element type.
|
| FloatBaseMath |
Mathematical operations on numbers in a base.
|
| FloatBuilderFactory |
Factory class for getting instances of the various builder classes needed
to build an ApfloatImpl with the float data element type.
|
| FloatCarryCRTBuilder |
Creates carry-CRT related objects, for the
float type.
|
| FloatCarryCRTStepStrategy |
Class for performing the final steps of a three-modulus
Number Theoretic Transform based convolution.
|
| FloatConstants |
Constants needed for various algorithms for the float type.
|
| FloatConvolutionBuilder |
Creates convolutions of suitable type for the float type.
|
| FloatCRTMath |
Basic arithmetic for calculating the Chinese Remainder
Theorem.
|
| FloatDataStorageBuilder |
Default data storage creation strategy for the float data type.
|
| FloatDiskDataStorage |
Disk-based data storage for the float element type.
|
| FloatElementaryModMath |
Elementary modulo arithmetic functions for float data.
|
| FloatFactor3NTTStepStrategy |
Steps for the factor-3 NTT.
|
| FloatKaratsubaConvolutionStrategy |
Convolution strategy using the Karatsuba algorithm.
|
| FloatMatrixBuilder |
Creates matrix operations objects, for the
float type.
|
| FloatMatrixStrategy |
Optimized matrix transposition methods for the float type.
|
| FloatMediumConvolutionStrategy |
Medium-length convolution strategy.
|
| FloatMemoryArrayAccess |
Array access class based on a float[].
|
| FloatMemoryDataStorage |
Memory based data storage implementation for the float
element type.
|
| FloatModConstants |
Constants needed for various modular arithmetic operations for the float type.
|
| FloatModMath |
Modulo arithmetic functions for float data.
|
| FloatNTTBuilder |
Creates Number Theoretic Transforms for the
float type.
|
| FloatNTTConvolutionStepStrategy |
Steps of a three-NTT convolution for the float type.
|
| FloatNTTStepStrategy |
Common methods to calculate Fast Number Theoretic Transforms
in parallel using multiple threads.
|
| FloatRadixConstants |
Constants related to different radixes for the float data type.
|
| FloatScramble |
Functions to perform bit-reverse ordering of float data.
|
| FloatShortConvolutionStrategy |
Short convolution strategy.
|
| FloatTableFNT |
Fast Number Theoretic Transform that uses lookup tables
for powers of n:th root of unity and permutation indexes.
|
| FloatTableFNTStrategy |
Fast Number Theoretic Transform strategy that uses lookup tables
for powers of n:th root of unity and permutation indexes.
|
| FloatWTables |
Helper class for generating and caching tables of powers of the n:th root of unity.
|
| FormattingHelper |
Helper class for formatting.
|
| FormattingHelper.AppendableWriter |
|
| FormattingHelper.BufferWriter |
|
| FormattingHelper.CountWriter |
|
| FormattingHelper.LocalizeWriter |
|
| FunctionCalculatorImpl |
Calculator implementation with function support.
|
| FunctionCalculatorImpl.FixedFunctionHandler |
Handler for FixedFunction.
|
| FunctionCalculatorImpl.Function |
Arbitrary function.
|
| FunctionCalculatorImpl.Functions |
Function implementations.
|
| GCDHelper |
Binary recursive GCD algorithm implementation.
|
| GCDHelper.HalfGcdType |
|
| GCDHelper.Matrix |
|
| HurwitzZetaHelper |
Helper class for the Hurwitz zeta function.
|
| HypergeometricHelper |
Helper class for hypergeometric functions.
|
| HypergeometricHelper.NotConvergingException |
|
| HypergeometricHelper.RetryException |
|
| HypergeometricHelper.Transformation |
|
| ImplementationMismatchException |
Exception indicating a different implementation of the apfloat SPI
being used in two operands of a calculation.
|
| IncompleteGammaHelper |
Helper class for the incomplete gamma function.
|
| IncompleteGammaHelper.ContinuedFraction |
|
| IncompleteGammaHelper.ContinuedFractionResult |
|
| IncompleteGammaHelper.ContinuedFractionType |
|
| IncompleteGammaHelper.GammaValue |
|
| IncompleteGammaHelper.RetryException |
|
| IncompleteGammaHelper.Sequence |
|
| InfiniteExpansionException |
Exception indicating that the result of an operation
would have infinite size.
|
| IntAdditionBuilder |
Creates additions for the specified radix and the int element type.
|
| IntAdditionStrategy |
Basic addition strategy for the int element type.
|
| IntAparapiBuilderFactory |
Builder factory for aparapi transform implementations for the int element type.
|
| IntAparapiFactor3NTTStepStrategy |
Steps for the factor-3 NTT using the GPU, for the int element type.
|
| IntAparapiFactor3NTTStrategy |
Factor-3 NTT implementation for the int element type.
|
| IntAparapiMatrixStrategy |
Matrix transposition in the GPU for the int type.
|
| IntAparapiNTTBuilder |
NTT Builder for aparapi transform implementations for the int element type.
|
| IntAparapiNTTStepStrategy |
NTT steps for the int element type aparapi transforms.
|
| IntAparapiSixStepFNTStrategy |
Six-step NTT implementation for the int element type.
|
| IntApfloatBuilder |
Builder class for building ApfloatImpl implementations with the
int data element type.
|
| IntApfloatImpl |
Immutable apfloat implementation class for the
int data element type.
|
| IntBaseMath |
Mathematical operations on numbers in a base.
|
| IntBuilderFactory |
Factory class for getting instances of the various builder classes needed
to build an ApfloatImpl with the int data element type.
|
| IntCarryCRTBuilder |
Creates carry-CRT related objects, for the
int type.
|
| IntCarryCRTStepStrategy |
Class for performing the final steps of a three-modulus
Number Theoretic Transform based convolution.
|
| IntConstants |
Constants needed for various algorithms for the int type.
|
| IntConvolutionBuilder |
Creates convolutions of suitable type for the int type.
|
| IntCRTMath |
Basic arithmetic for calculating the Chinese Remainder
Theorem.
|
| IntDataStorageBuilder |
Default data storage creation strategy for the int data type.
|
| IntDiskDataStorage |
Disk-based data storage for the int element type.
|
| IntElementaryModMath |
Elementary modulo arithmetic functions for int data.
|
| IntFactor3NTTStepStrategy |
Steps for the factor-3 NTT.
|
| IntKaratsubaConvolutionStrategy |
Convolution strategy using the Karatsuba algorithm.
|
| IntKernel |
Kernel for the int element type.
|
| IntMatrixBuilder |
Creates matrix operations objects, for the
int type.
|
| IntMatrixStrategy |
Optimized matrix transposition methods for the int type.
|
| IntMediumConvolutionStrategy |
Medium-length convolution strategy.
|
| IntMemoryArrayAccess |
Array access class based on a int[].
|
| IntMemoryDataStorage |
Memory based data storage implementation for the int
element type.
|
| IntModConstants |
Constants needed for various modular arithmetic operations for the int type.
|
| IntModMath |
Modulo arithmetic functions for int data.
|
| IntNTTBuilder |
Creates Number Theoretic Transforms for the
int type.
|
| IntNTTConvolutionStepStrategy |
Steps of a three-NTT convolution for the int type.
|
| IntNTTStepStrategy |
Common methods to calculate Fast Number Theoretic Transforms
in parallel using multiple threads.
|
| IntRadixConstants |
Constants related to different radixes for the int data type.
|
| IntScramble |
Functions to perform bit-reverse ordering of int data.
|
| IntShortConvolutionStrategy |
Short convolution strategy.
|
| IntTableFNT |
Fast Number Theoretic Transform that uses lookup tables
for powers of n:th root of unity and permutation indexes.
|
| IntTableFNTStrategy |
Fast Number Theoretic Transform strategy that uses lookup tables
for powers of n:th root of unity and permutation indexes.
|
| IntWTables |
Helper class for generating and caching tables of powers of the n:th root of unity.
|
| LambertWHelper |
Helper class for Lambert W function.
|
| LambertWHelper.ComplexException |
|
| LocalOperationExecutor |
|
| LongAdditionBuilder |
Creates additions for the specified radix and the long element type.
|
| LongAdditionStrategy |
Basic addition strategy for the long element type.
|
| LongAparapiBuilderFactory |
Builder factory for aparapi transform implementations for the long element type.
|
| LongAparapiFactor3NTTStepStrategy |
Steps for the factor-3 NTT using the GPU, for the long element type.
|
| LongAparapiFactor3NTTStrategy |
Factor-3 NTT implementation for the long element type.
|
| LongAparapiMatrixStrategy |
Matrix transposition in the GPU for the long type.
|
| LongAparapiNTTBuilder |
NTT Builder for aparapi transform implementations for the long element type.
|
| LongAparapiNTTStepStrategy |
NTT steps for the long element type aparapi transforms.
|
| LongAparapiSixStepFNTStrategy |
Six-step NTT implementation for the long element type.
|
| LongApfloatBuilder |
Builder class for building ApfloatImpl implementations with the
long data element type.
|
| LongApfloatImpl |
Immutable apfloat implementation class for the
long data element type.
|
| LongBaseMath |
Mathematical operations on numbers in a base.
|
| LongBuilderFactory |
Factory class for getting instances of the various builder classes needed
to build an ApfloatImpl with the long data element type.
|
| LongCarryCRTBuilder |
Creates carry-CRT related objects, for the
long type.
|
| LongCarryCRTStepStrategy |
Class for performing the final steps of a three-modulus
Number Theoretic Transform based convolution.
|
| LongConstants |
Constants needed for various algorithms for the long type.
|
| LongConvolutionBuilder |
Creates convolutions of suitable type for the long type.
|
| LongCRTMath |
Basic arithmetic for calculating the Chinese Remainder
Theorem.
|
| LongDataStorageBuilder |
Default data storage creation strategy for the long data type.
|
| LongDiskDataStorage |
Disk-based data storage for the long element type.
|
| LongElementaryModMath |
Elementary modulo arithmetic functions for long data.
|
| LongFactor3NTTStepStrategy |
Steps for the factor-3 NTT.
|
| LongKaratsubaConvolutionStrategy |
Convolution strategy using the Karatsuba algorithm.
|
| LongKernel |
Kernel for the long element type.
|
| LongMatrixBuilder |
Creates matrix operations objects, for the
long type.
|
| LongMatrixStrategy |
Optimized matrix transposition methods for the long type.
|
| LongMediumConvolutionStrategy |
Medium-length convolution strategy.
|
| LongMemoryArrayAccess |
Array access class based on a long[].
|
| LongMemoryDataStorage |
Memory based data storage implementation for the long
element type.
|
| LongModConstants |
Constants needed for various modular arithmetic operations for the long type.
|
| LongModMath |
Modulo arithmetic functions for long data.
|
| LongNTTBuilder |
Creates Number Theoretic Transforms for the
long type.
|
| LongNTTConvolutionStepStrategy |
Steps of a three-NTT convolution for the long type.
|
| LongNTTStepStrategy |
Common methods to calculate Fast Number Theoretic Transforms
in parallel using multiple threads.
|
| LongRadixConstants |
Constants related to different radixes for the long data type.
|
| LongScramble |
Functions to perform bit-reverse ordering of long data.
|
| LongShortConvolutionStrategy |
Short convolution strategy.
|
| LongTableFNT |
Fast Number Theoretic Transform that uses lookup tables
for powers of n:th root of unity and permutation indexes.
|
| LongTableFNTStrategy |
Fast Number Theoretic Transform strategy that uses lookup tables
for powers of n:th root of unity and permutation indexes.
|
| LongWTables |
Helper class for generating and caching tables of powers of the n:th root of unity.
|
| LossOfPrecisionException |
Exception indicating a result that would have no significant digits.
|
| MatrixBuilder |
Interface of a factory for creating matrix related objects.
|
| MatrixStrategy |
Matrix operations.
|
| MessagePasser<K,V> |
Message passing helper class for parallel codes.
|
| NTTBuilder |
Interface of a factory for creating Number Theoretic Transforms.
|
| NTTConvolutionStepStrategy |
Steps for a three-NTT convolution.
|
| NTTStepStrategy |
Steps for the six-step or two-pass NTT.
|
| NTTStrategy |
Number Theoretic Transform (NTT) strategy.
|
| NumericComputationException |
Exception indicating that something went wrong in a numeric computation.
|
| Operation<T> |
Interface for implementing arbitrary operations to be executed.
|
| OperationExecutor |
Interface for implementing objects that can execute Operations.
|
| OperationServer |
Server for executing Operations from remote calls.
|
| OperationServer.Request |
|
| OverflowException |
Exception indicating an overflow in a calculation.
|
| ParallelExecutionBuilder |
|
| ParallelExecutionStrategy |
|
| ParallelHelper |
Helper methods for parallel algorithms.
|
| ParallelHelper.ProductKernel<T extends Apcomplex> |
|
| Parallelizable |
Any task that can use a ParallelRunner to execute operations in parallel.
|
| ParallelRunnable |
Abstract class for a Runnable that can be run in parallel by
multiple threads.
|
| ParallelRunner |
Class for running ParallelRunnable objects in parallel using
multiple threads.
|
| ParallelThreeNTTConvolutionStrategy |
Convolution using three Number Theoretic Transforms
and the CRT to get the final result, using multiple threads in parallel.
|
| ParallelThreeNTTConvolutionStrategy.LockFuture |
|
| ParseException |
This exception is thrown when parse errors are encountered.
|
| Pi |
Calculates pi using four different algorithms.
|
| Pi.AbstractBinarySplittingSeries |
Abstract base class for the binary splitting series.
|
| Pi.BinarySplittingPiCalculator |
Class for implementing the binary splitting algorithm.
|
| Pi.BinarySplittingProgressIndicator |
Indicates progress of the pi calculation using
the binary splitting algorithm.
|
| Pi.BinarySplittingSeries |
Terms for the binary splitting series.
|
| Pi.BorweinPiCalculator |
Calculates pi using the Borweins' quartic algorithm.
|
| Pi.ChudnovskyBinarySplittingSeries |
Chudnovskys' algorithm terms for the binary splitting series.
|
| Pi.ChudnovskyPiCalculator |
Basic class for calculating pi using the Chudnovskys' binary splitting algorithm.
|
| Pi.GaussLegendrePiCalculator |
Calculates pi using the Gauss-Legendre algorithm.
|
| Pi.RamanujanBinarySplittingSeries |
Ramanujan's algorithm terms for the binary splitting series.
|
| Pi.RamanujanPiCalculator |
Basic class for calculating pi using the Ramanujan binary splitting algorithm.
|
| PiApplet |
Applet for calculating pi using four different algorithms.
|
| PiAWT |
Graphical AWT elements for calculating pi using four different algorithms.
|
| PiAWT.FlushStringWriter |
|
| PiAWT.StatusIndicator |
Interface to indicate an error status in the application.
|
| PiDistributed |
Calculates pi using a cluster of servers.
|
| PiDistributed.DistributedBinarySplittingPiCalculator |
Distributed version of the binary splitting algorithm.
|
| PiDistributed.DistributedChudnovskyPiCalculator |
Class for calculating pi using the distributed Chudnovskys' binary splitting algorithm.
|
| PiDistributed.DistributedRamanujanPiCalculator |
Class for calculating pi using the distributed Ramanujan's binary splitting algorithm.
|
| PiDistributed.Node |
RemoteOperationExecutor that implements the weight property.
|
| PiGUI |
AWT client application for calculating pi using four different algorithms.
|
| PiParallel |
Calculates pi using multiple threads in parallel.
|
| PiParallel.ParallelBinarySplittingPiCalculator |
Parallel version of the binary splitting algorithm.
|
| PiParallel.ParallelChudnovskyPiCalculator |
Class for calculating pi using the parallel Chudnovskys' binary splitting algorithm.
|
| PiParallel.ParallelRamanujanPiCalculator |
Class for calculating pi using the parallel Ramanujan's binary splitting algorithm.
|
| PiParallel.ThreadLimitedOperation<T> |
|
| PiParallelApplet |
Applet for calculating pi using multiple threads in parallel.
|
| PiParallelAWT |
Graphical AWT elements for calculating pi using multiple threads in parallel.
|
| PiParallelGUI |
AWT client application for calculating pi using multiple threads in parallel.
|
| RadixConstants |
Constants related to different radixes.
|
| RadixConversionHelper |
Helper class for radix conversion.
|
| RadixConversionHelper.RadixPowerList |
|
| RadixMismatchException |
Exception indicating a different radix being used in two operands
of a calculation.
|
| RangeHelper |
Range helper methods.
|
| RemoteOperationExecutor |
|
| RootFinder |
Helper class for finding roots of functions.
|
| RoundingHelper |
Helper class for rounding functions.
|
| Scramble |
Functions to perform bit-reverse ordering of data.
|
| ShutdownMap<K,V> |
Map that always throws ApfloatRuntimeException on all operations.
|
| SimpleCharStream |
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
|
| SixStepFNTStrategy |
Fast Number Theoretic Transform that uses a "six-step"
algorithm to calculate a long transform more efficiently on
cache-based memory architectures.
|
| StepCarryCRTStrategy |
Class for performing the final step of a three-modulus
Number Theoretic Transform based convolution.
|
| ThreeNTTConvolutionStrategy |
Convolution using three Number Theoretic Transforms
and the Chinese Remainder Theorem to get the final result.
|
| Token |
Describes the input token stream.
|
| TokenMgrError |
Token Manager Error.
|
| TransformLengthExceededException |
Exception indicating that the "size" of the numbers used in a
multiplication is too large.
|
| TwoPassFNTStrategy |
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.
|
| Util |
Miscellaneous utility methods.
|
| ZetaHelper |
Helper class for the Riemann zeta function.
|