# Class LongNTTStepStrategy

java.lang.Object
org.apfloat.internal.LongElementaryModMath
org.apfloat.internal.LongModMath
org.apfloat.internal.LongTableFNT
org.apfloat.internal.LongNTTStepStrategy

All Implemented Interfaces:
  `Parallelizable, NTTStepStrategy`

Direct Known Subclasses:
  `LongAparapiNTTStepStrategy`

public class LongNTTStepStrategy extends LongTableFNT implements NTTStepStrategy, Parallelizable
Common methods to calculate Fast Number Theoretic Transforms in parallel using multiple threads.

All access to this class must be externally synchronized.

Since:
  1.7.0
Version:
  1.9.0
Author:
  Mikko Tommila

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `LongNTTStepStrategy()`
  Default constructor.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `protected ParallelRunnable`
  `createMultiplyElementsParallelRunnable(ArrayAccess arrayAccess, int startRow, int startColumn, int rows, int columns, long length, long totalTransformLength, boolean isInverse, int modulus)`
  Create a ParallelRunnable object for multiplying the elements of the matrix.
  `protected ParallelRunnable`
  `createTransformRowsParallelRunnable(ArrayAccess arrayAccess, int length, int count, boolean isInverse, boolean permute, int modulus)`
  Create a ParallelRunnable object for transforming the rows of the matrix.
  `long`
  `getMaxTransformLength()`
  Get the maximum transform length.
  `void`
  `multiplyElements(ArrayAccess arrayAccess, int startRow, int startColumn, int rows, int columns, long length, long totalTransformLength, boolean isInverse, int modulus)`
  Multiply each matrix element `(i, j)` by `wi * j / totalTransformLength`.
  `void`
  `transformRows(ArrayAccess arrayAccess, int length, int count, boolean isInverse, boolean permute, int modulus)`
  Transform the rows of the data matrix.

  ### Methods inherited from class LongTableFNT

  `inverseTableFNT, tableFNT`

  ### Methods inherited from class LongModMath

  `createWTable, getForwardNthRoot, getInverseNthRoot, modDivide, modInverse, modPow, negate`

  ### Methods inherited from class LongElementaryModMath

  `getModulus, modAdd, modMultiply, modSubtract, setModulus`

  ### Methods inherited from class Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Constructor Details

  - ### LongNTTStepStrategy

    public LongNTTStepStrategy()
    Default constructor.

- ## Method Details

  - ### multiplyElements

    public void multiplyElements(ArrayAccess arrayAccess, int startRow, int startColumn, int rows, int columns, long length, long totalTransformLength, boolean isInverse, int modulus) throws ApfloatRuntimeException
    Description copied from interface: `NTTStepStrategy`
    Multiply each matrix element `(i, j)` by `wi * j / totalTransformLength`. The matrix size is n1 x n2.
    Specified by:
      `multiplyElements` in interface `NTTStepStrategy`
    Parameters:
      `arrayAccess` - The memory array to multiply.
      `startRow` - Which row in the whole matrix the starting row in the `arrayAccess` is.
      `startColumn` - Which column in the whole matrix the starting column in the `arrayAccess` is.
      `rows` - The number of rows in the `arrayAccess` to multiply.
      `columns` - The number of columns in the matrix (= n2).
      `length` - The length of data in the matrix being transformed.
      `totalTransformLength` - The total transform length, for the scaling factor. Used only for the inverse case.
      `isInverse` - If the multiplication is done for the inverse transform or not.
      `modulus` - Index of the modulus.
    Throws:
      `ApfloatRuntimeException`

  - ### transformRows

    public void transformRows(ArrayAccess arrayAccess, int length, int count, boolean isInverse, boolean permute, int modulus) throws ApfloatRuntimeException
    Description copied from interface: `NTTStepStrategy`
    Transform the rows of the data matrix. If only one processor is available, it runs all transforms in the current thread. If more than one processor are available, it dispatches the calculations to multiple threads to parallelize the calculation. The number of processors is determined using `ApfloatContext.getNumberOfProcessors()`.
    Specified by:
      `transformRows` in interface `NTTStepStrategy`
    Parameters:
      `arrayAccess` - The memory array to split to rows and to transform.
      `length` - Length of one transform (one row).
      `count` - Number of rows.
      `isInverse` - `true` if an inverse transform is performed, `false` if a forward transform is performed.
      `permute` - If permutation should be done.
      `modulus` - Index of the modulus.
    Throws:
      `ApfloatRuntimeException`

  - ### getMaxTransformLength

    public long getMaxTransformLength()
    Description copied from interface: `NTTStepStrategy`
    Get the maximum transform length.
    Specified by:
      `getMaxTransformLength` in interface `NTTStepStrategy`
    Returns:
      The maximum transform length.

  - ### createMultiplyElementsParallelRunnable

    protected ParallelRunnable createMultiplyElementsParallelRunnable(ArrayAccess arrayAccess, int startRow, int startColumn, int rows, int columns, long length, long totalTransformLength, boolean isInverse, int modulus) throws ApfloatRuntimeException
    Create a ParallelRunnable object for multiplying the elements of the matrix.
    Parameters:
      `arrayAccess` - The memory array to multiply.
      `startRow` - Which row in the whole matrix the starting row in the `arrayAccess` is.
      `startColumn` - Which column in the whole matrix the starting column in the `arrayAccess` is.
      `rows` - The number of rows in the `arrayAccess` to multiply.
      `columns` - The number of columns in the matrix (= n2).
      `length` - The length of data in the matrix being transformed.
      `totalTransformLength` - The total transform length, for the scaling factor. Used only for the inverse case.
      `isInverse` - If the multiplication is done for the inverse transform or not.
      `modulus` - Index of the modulus.
    Returns:
      An object suitable for multiplying the elements of the matrix in parallel.
    Throws:
      `ApfloatRuntimeException`

  - ### createTransformRowsParallelRunnable

    protected ParallelRunnable createTransformRowsParallelRunnable(ArrayAccess arrayAccess, int length, int count, boolean isInverse, boolean permute, int modulus) throws ApfloatRuntimeException
    Create a ParallelRunnable object for transforming the rows of the matrix.
    Parameters:
      `arrayAccess` - The memory array to split to rows and to transform.
      `length` - Length of one transform (one row).
      `count` - Number of rows.
      `isInverse` - `true` if an inverse transform is performed, `false` if a forward transform is performed.
      `permute` - If permutation should be done.
      `modulus` - Index of the modulus.
    Returns:
      An object suitable for transforming the rows of the matrix in parallel.
    Throws:
      `ApfloatRuntimeException`