Package org.apfloat.internal
Class FloatCarryCRTStepStrategy
- java.lang.Object
-
- org.apfloat.internal.FloatBaseMath
-
- org.apfloat.internal.FloatCRTMath
-
- org.apfloat.internal.FloatCarryCRTStepStrategy
-
- All Implemented Interfaces:
java.io.Serializable
,CarryCRTStepStrategy<float[]>
public class FloatCarryCRTStepStrategy extends FloatCRTMath implements CarryCRTStepStrategy<float[]>
Class for performing the final steps of a three-modulus Number Theoretic Transform based convolution. Works for thefloat
type.All access to this class must be externally synchronized.
- Since:
- 1.7.0
- Version:
- 1.9.0
- See Also:
- Serialized Form
-
-
Field Summary
Fields Modifier and Type Field Description private static float[]
M01
private static float[]
M012
private static float[]
M02
private static float[]
M12
private static FloatModMath
MATH_MOD_0
private static FloatModMath
MATH_MOD_1
private static FloatModMath
MATH_MOD_2
private static long
serialVersionUID
private static float
T0
private static float
T1
private static float
T2
-
Constructor Summary
Constructors Constructor Description FloatCarryCRTStepStrategy(int radix)
Creates a carry-CRT steps object using the specified radix.
-
Method Summary
All Methods Static Methods Instance Methods Concrete Methods Modifier and Type Method Description private static DataStorage.Iterator
arrayIterator(float[] data)
private float
baseCarry(DataStorage.Iterator srcDst, float carry, long size)
float[]
carry(DataStorage dataStorage, long size, long resultSize, long offset, long length, float[] results, float[] previousResults)
Propagate carries from the previous block computed with the CRT method.private static DataStorage.Iterator
compositeIterator(DataStorage.Iterator iterator1, long size, DataStorage.Iterator iterator2)
float[]
crt(DataStorage resultMod0, DataStorage resultMod1, DataStorage resultMod2, DataStorage dataStorage, long size, long resultSize, long offset, long length)
Perform the Chinese Remainder Theorem (CRT) on each element of the three result data sets to get the result of each element modulo the product of the three moduli.-
Methods inherited from class org.apfloat.internal.FloatCRTMath
add, compare, divide, multiply, subtract
-
Methods inherited from class org.apfloat.internal.FloatBaseMath
baseAdd, baseDivide, baseMultiplyAdd, baseSubtract
-
-
-
-
Field Detail
-
serialVersionUID
private static final long serialVersionUID
- See Also:
- Constant Field Values
-
MATH_MOD_0
private static final FloatModMath MATH_MOD_0
-
MATH_MOD_1
private static final FloatModMath MATH_MOD_1
-
MATH_MOD_2
private static final FloatModMath MATH_MOD_2
-
T0
private static final float T0
-
T1
private static final float T1
-
T2
private static final float T2
-
M01
private static final float[] M01
-
M02
private static final float[] M02
-
M12
private static final float[] M12
-
M012
private static final float[] M012
-
-
Method Detail
-
crt
public float[] crt(DataStorage resultMod0, DataStorage resultMod1, DataStorage resultMod2, DataStorage dataStorage, long size, long resultSize, long offset, long length) throws ApfloatRuntimeException
Description copied from interface:CarryCRTStepStrategy
Perform the Chinese Remainder Theorem (CRT) on each element of the three result data sets to get the result of each element modulo the product of the three moduli. Then it calculates the carries for the block of data to get the final result.Note that the return value's initial word may be zero or non-zero, depending on how large the result is.
Assumes that
MODULUS[0] > MODULUS[1] > MODULUS[2]
.- Specified by:
crt
in interfaceCarryCRTStepStrategy<float[]>
- Parameters:
resultMod0
- The result moduloMODULUS[0]
.resultMod1
- The result moduloMODULUS[1]
.resultMod2
- The result moduloMODULUS[2]
.dataStorage
- The destination data storage of the computation.size
- The number of elements in the whole data set.resultSize
- The number of elements needed in the final result.offset
- The offset within the data for the block to be computed.length
- Length of the block to be computed.- Returns:
- The carries overflowing from this block (two elements).
- Throws:
ApfloatRuntimeException
-
carry
public float[] carry(DataStorage dataStorage, long size, long resultSize, long offset, long length, float[] results, float[] previousResults) throws ApfloatRuntimeException
Description copied from interface:CarryCRTStepStrategy
Propagate carries from the previous block computed with the CRT method.- Specified by:
carry
in interfaceCarryCRTStepStrategy<float[]>
- Parameters:
dataStorage
- The destination data storage of the computation.size
- The number of elements in the whole data set.resultSize
- The number of elements needed in the final result.offset
- The offset within the data for the block to be computed.length
- Length of the block to be computed.results
- The carry overflow from this block (two elements).previousResults
- The carry overflow from the previous block (two elements).- Returns:
- The carries overflowing from this block (two elements).
- Throws:
ApfloatRuntimeException
-
baseCarry
private float baseCarry(DataStorage.Iterator srcDst, float carry, long size) throws ApfloatRuntimeException
- Throws:
ApfloatRuntimeException
-
arrayIterator
private static DataStorage.Iterator arrayIterator(float[] data)
-
compositeIterator
private static DataStorage.Iterator compositeIterator(DataStorage.Iterator iterator1, long size, DataStorage.Iterator iterator2)
-
-