ArrayUtilsGPU (JDiffraction 1.2 API)

java.lang.Object
- unal.od.jdiffraction.gpu.utils.ArrayUtilsGPU

```
public class ArrayUtilsGPU
extends java.lang.Object
```
Utilities for working with complex and real data arrays. The physical layout of the complex data must be the same as in JTransforms:
field[i * 2 * N + 2 * j] = Re[i][j], field[i * 2 * N + 2 * j + 1] = Im[i][j]; 0 <= i < M, 0 <= j < N

Since:

JDiffraction 1.2

Author:

Pablo Piedrahita-Quintero (jppiedrahitaq@unal.edu.co), Carlos Trujillo (catrujila@unal.edu.co), Jorge Garcia-Sucerquia (jigarcia@unal.edu.co)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`double[]`	`complexAmplitude(int M, int N, double[] phase, double amp)` Creates a complex array pointwise.
`double[]`	`complexAmplitude(int M, int N, double[] phase, double[] amp)` Creates a complex array pointwise.
`double[]`	`complexAmplitude(int M, int N, double phase, double[] amp)` Creates a complex array pointwise.
`float[]`	`complexAmplitude(int M, int N, float[] phase, float amp)` Creates a complex array element by element.
`float[]`	`complexAmplitude(int M, int N, float[] phase, float[] amp)` Creates a complex array pointwise.
`float[]`	`complexAmplitude(int M, int N, float phase, float[] amp)` Creates a complex array pointwise.
`double[]`	`complexAmplitude2(int M, int N, double[] real, double[] imaginary)` Takes the real and imaginary parts and returns a complex array.
`float[]`	`complexAmplitude2(int M, int N, float[] real, float[] imaginary)` Takes the real and imaginary parts and returns a complex array.
`double[]`	`complexMultiplication(int M, int N, double[] a, double[] b)` Computes the pointwise complex multiplication of 2 arrays.
`float[]`	`complexMultiplication(int M, int N, float[] a, float[] b)` Computes the pointwise complex multiplication of 2 arrays.
`void`	`complexMultiplication2(int M, int N, double[] a, double[] b)` Computes the pointwise complex multiplication of 2 arrays leaving the result in `a`.
`void`	`complexMultiplication2(int M, int N, float[] a, float[] b)` Computes the pointwise complex multiplication of 2 arrays leaving the result in `a`.
`void`	`complexShift(int M, int N, double[] a)` Performs the circular shifting of a complex array, leaving the result in `a`.
`void`	`complexShift(int M, int N, float[] a)` Performs the circular shifting of a complex array, leaving the result in `a`.
`void`	`complexShiftGPU(int M, int N, jcuda.driver.CUdeviceptr devA, boolean isFloat)` Performs the circular shifting of a complex array, leaving the result in `a`.
`void`	`divide(double[] a, double num)` Computes the pointwise division of an array by `num`, leaving the result in `a`.
`void`	`divide(float[] a, float num)` Computes the pointwise division of an array by `num`, leaving the result in `a`.
`static ArrayUtilsGPU`	`getInstance()` Returns the current instance of ArrayUtilsGPU.
`double[]`	`imaginary(int M, int N, double[] a)` Extracts the imaginary part of a complex array.
`float[]`	`imaginary(int M, int N, float[] a)` Extracts the imaginary part of a complex array.
`static java.lang.String`	`jDiffractionVersion()` Returns the library version as a String.
`double[]`	`log10(double[] a)` Computes log10 of a real array.
`float[]`	`log10(float[] a)` Computes log10 of a real array.
`static void`	`matrixToVectorArray(int M, int N, double[][] a, double[] b)` Converts a 2D array into a 1D array leaving the result in `b`.
`static void`	`matrixToVectorArray(int M, int N, float[][] a, float[] b)` Converts a 2D array into a 1D array leaving the result in `b`.
`double`	`max(double[] a)` Gets the max value of a real array.
`float`	`max(float[] a)` Gets the max value of a real array.
`double`	`min(double[] a)` Gets the min value of a real array.
`float`	`min(float[] a)` Gets the min value of a real array.
`double[]`	`modulus(int M, int N, double[] a)` Computes the modulus of a complex array.
`float[]`	`modulus(int M, int N, float[] a)` Computes the modulus of a complex array.
`double[]`	`modulusSq(int M, int N, double[] a)` Computes the squared modulus of a complex array.
`float[]`	`modulusSq(int M, int N, float[] a)` Computes the squared modulus of a complex array.
`void`	`multiply(double[] a, double num)` Computes the pointwise multiplication of an array by `num`, leaving the result in `a`.
`void`	`multiply(float[] a, float num)` Computes the pointwise multiplication of an array by `num`, leaving the result in `a`.
`double[]`	`phase(int M, int N, double[] a)` Computes the phase (angle) of a complex array.
`float[]`	`phase(int M, int N, float[] a)` Computes the phase (angle) of a complex array.
`static double[]`	`real(int M, int N, double[] a)` Extracts the real part of a complex array.
`float[]`	`real(int M, int N, float[] a)` Extracts the real part of a complex array.
`void`	`realShift(int M, int N, double[] a)` Performs the circular shifting of a real array, leaving the result in `a`.
`void`	`realShift(int M, int N, float[] a)` Performs the circular shifting of a real array, leaving the result in `a`.
`double[]`	`scale(double[] a, double maxScale)` Scales a real array to `[0 - maxScale]`.
`double[]`	`scale(double[] a, double max, double min, double maxScale)` Scales a real array to `[0 - maxScale]`.
`float[]`	`scale(float[] a, float maxScale)` Scales a real array to `[0 - maxScale]`.
`float[]`	`scale(float[] a, float max, float min, float maxScale)` Scales a real array to `[0 - maxScale]`.
`void`	`scale2(double[] a, double maxScale)` Scales a real array to `[0 - maxScale]` leaving the result in `a`.
`void`	`scale2(double[] a, double max, double min, double maxScale)` Scales a real array to `[0 - maxScale]` leaving the result in `a`.
`void`	`scale2(float[] a, float maxScale)` Scales a real array to `[0 - maxScale]` leaving the result in `a`.
`void`	`scale2(float[] a, float max, float min, float maxScale)` Scales a real array to `[0 - maxScale]` leaving the result in `a`.
`static void`	`vectorToMatrixArray(int M, int N, double[] a, double[][] b)` Converts a 1D array into a 2D array leaving the result in `b`.
`static void`	`vectorToMatrixArray(int M, int N, float[] a, float[][] b)` Converts a 1D array into a 2D array leaving the result in `b`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - getInstance
```
public static ArrayUtilsGPU getInstance()
                                 throws java.io.IOException
```
    Returns the current instance of ArrayUtilsGPU. If the current instance is null, a new instance is created.
    
    Returns:
    
    instance of ArrayUtilsGPU
    
    Throws:
    
    java.io.IOException
  - jDiffractionVersion
```
public static java.lang.String jDiffractionVersion()
```
    Returns the library version as a String.
    
    Returns:
    
    library version
  - phase
```
public float[] phase(int M,
                     int N,
                     float[] a)
```
    Computes the phase (angle) of a complex array.
    phase[i * N + j] = atan(Im[i][j] / Re[i][j])
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    a - complex array
    
    Returns:
    
    phase (angle) array
  - phase
```
public double[] phase(int M,
                      int N,
                      double[] a)
```
    Computes the phase (angle) of a complex array.
    phase[i * N + j] = atan(Im[i][j] / Re[i][j])
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    a - complex array
    
    Returns:
    
    phase (angle) array
  - modulus
```
public float[] modulus(int M,
                       int N,
                       float[] a)
```
    Computes the modulus of a complex array.
    modulus[i * N + j] = sqrt(Re[i][j]^2 + Im[i][j]^2)
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    a - complex array
    
    Returns:
    
    modulus array
  - modulus
```
public double[] modulus(int M,
                        int N,
                        double[] a)
```
    Computes the modulus of a complex array.
    modulus[i][j] = sqrt(Re[i][j]^2 + Im[i][j]^2)
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    a - complex array
    
    Returns:
    
    modulus array
  - modulusSq
```
public float[] modulusSq(int M,
                         int N,
                         float[] a)
```
    Computes the squared modulus of a complex array.
    modulusSq[i * N + j] = Re[i][j]^2 + Im[i][j]^2
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    a - complex array
    
    Returns:
    
    modulus squared array
  - modulusSq
```
public double[] modulusSq(int M,
                          int N,
                          double[] a)
```
    Computes the squared modulus of a complex array.
    modulusSq[i * N + j] = Re[i][j]^2 + Im[i][j]^2
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    a - complex array
    
    Returns:
    
    modulus squared array
  - complexMultiplication
```
public float[] complexMultiplication(int M,
                                     int N,
                                     float[] a,
                                     float[] b)
```
    Computes the pointwise complex multiplication of 2 arrays.
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    a - complex array
    
    b - complex array
    
    Returns:
    
    multiplication
  - complexMultiplication
```
public double[] complexMultiplication(int M,
                                      int N,
                                      double[] a,
                                      double[] b)
```
    Computes the pointwise complex multiplication of 2 arrays.
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    a - complex array
    
    b - complex array
    
    Returns:
    
    multiplication
  - complexMultiplication2
```
public void complexMultiplication2(int M,
                                   int N,
                                   float[] a,
                                   float[] b)
```
    Computes the pointwise complex multiplication of 2 arrays leaving the result in a.
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    a - complex array
    
    b - complex array
  - complexMultiplication2
```
public void complexMultiplication2(int M,
                                   int N,
                                   double[] a,
                                   double[] b)
```
    Computes the pointwise complex multiplication of 2 arrays leaving the result in a.
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    a - complex array
    
    b - complex array
  - complexAmplitude
```
public float[] complexAmplitude(int M,
                                int N,
                                float[] phase,
                                float[] amp)
```
    Creates a complex array pointwise. The computation is done calculating amp * exp(i * phase).
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    phase - phase array
    
    amp - amplitude array
    
    Returns:
    
    complex array
  - complexAmplitude
```
public double[] complexAmplitude(int M,
                                 int N,
                                 double[] phase,
                                 double[] amp)
```
    Creates a complex array pointwise. The computation is done calculating amp * exp(i * phase).
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    phase - phase array
    
    amp - amplitude array
    
    Returns:
    
    complex array
  - complexAmplitude
```
public float[] complexAmplitude(int M,
                                int N,
                                float[] phase,
                                float amp)
```
    Creates a complex array element by element. The computation is done calculating amp * exp(i * phase)
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    phase - phase array
    
    amp - amplitude
    
    Returns:
    
    complex array
  - complexAmplitude
```
public double[] complexAmplitude(int M,
                                 int N,
                                 double[] phase,
                                 double amp)
```
    Creates a complex array pointwise. The computation is done calculating amp * exp(i * phase).
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    phase - phase array
    
    amp - amplitude
    
    Returns:
    
    complex array
  - complexAmplitude
```
public float[] complexAmplitude(int M,
                                int N,
                                float phase,
                                float[] amp)
```
    Creates a complex array pointwise. The computation is done calculating amp * exp(i * phase).
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    phase - phase
    
    amp - amplitude array
    
    Returns:
    
    complex array
  - complexAmplitude
```
public double[] complexAmplitude(int M,
                                 int N,
                                 double phase,
                                 double[] amp)
```
    Creates a complex array pointwise. The computation is done calculating amp * exp(i * phase).
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    phase - phase
    
    amp - amplitude array
    
    Returns:
    
    complex array
  - complexAmplitude2
```
public float[] complexAmplitude2(int M,
                                 int N,
                                 float[] real,
                                 float[] imaginary)
```
    Takes the real and imaginary parts and returns a complex array. If one of the input arrays is null, that part is filled with zeros.
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    real - real part array
    
    imaginary - imaginary part array
    
    Returns:
    
    complex array
  - complexAmplitude2
```
public double[] complexAmplitude2(int M,
                                  int N,
                                  double[] real,
                                  double[] imaginary)
```
    Takes the real and imaginary parts and returns a complex array. If one of the input arrays is null, that part is filled with zeros.
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    real - real part array
    
    imaginary - imaginary part array
    
    Returns:
    
    complex array
  - real
```
public float[] real(int M,
                    int N,
                    float[] a)
```
    Extracts the real part of a complex array.
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    a - complex array
    
    Returns:
    
    real array
  - real
```
public static double[] real(int M,
                            int N,
                            double[] a)
```
    Extracts the real part of a complex array.
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    a - complex array
    
    Returns:
    
    real array
  - imaginary
```
public float[] imaginary(int M,
                         int N,
                         float[] a)
```
    Extracts the imaginary part of a complex array.
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    a - complex array
    
    Returns:
    
    imaginary array
  - imaginary
```
public double[] imaginary(int M,
                          int N,
                          double[] a)
```
    Extracts the imaginary part of a complex array.
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    a - complex array
    
    Returns:
    
    imaginary array
  - complexShift
```
public void complexShift(int M,
                         int N,
                         float[] a)
```
    Performs the circular shifting of a complex array, leaving the result in a.
    a b -> d c c d b a
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    a - complex array
  - complexShift
```
public void complexShift(int M,
                         int N,
                         double[] a)
```
    Performs the circular shifting of a complex array, leaving the result in a.
    a b -> d c c d b a
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    a - complex array
  - complexShiftGPU
```
public void complexShiftGPU(int M,
                            int N,
                            jcuda.driver.CUdeviceptr devA,
                            boolean isFloat)
```
    Performs the circular shifting of a complex array, leaving the result in a.
    a b -> d c c d b a
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    devA - complex array
    
    isFloat -
  - realShift
```
public void realShift(int M,
                      int N,
                      float[] a)
```
    Performs the circular shifting of a real array, leaving the result in a.
    a b -> d c c d b a
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    a - real array
  - realShift
```
public void realShift(int M,
                      int N,
                      double[] a)
```
    Performs the circular shifting of a real array, leaving the result in a.
    a b -> d c c d b a
    
    Parameters:
    
    M - number of rows
    
    N - number of columns
    
    a - real array
  - multiply
```
public void multiply(float[] a,
                     float num)
```
    Computes the pointwise multiplication of an array by num, leaving the result in a.
    
    Parameters:
    
    a - array
    
    num - number
  - multiply
```
public void multiply(double[] a,
                     double num)
```
    Computes the pointwise multiplication of an array by num, leaving the result in a.
    
    Parameters:
    
    a - array
    
    num - number
  - divide
```
public void divide(float[] a,
                   float num)
```
    Computes the pointwise division of an array by num, leaving the result in a.
    
    Parameters:
    
    a - array
    
    num - number
  - divide
```
public void divide(double[] a,
                   double num)
```
    Computes the pointwise division of an array by num, leaving the result in a.
    
    Parameters:
    
    a - array
    
    num - number
  - log10
```
public float[] log10(float[] a)
```
    Computes log10 of a real array.
    
    Parameters:
    
    a - array
    
    Returns:
    
    array containing log10(a)
  - log10
```
public double[] log10(double[] a)
```
    Computes log10 of a real array.
    
    Parameters:
    
    a - array
    
    Returns:
    
    array containing log10(a)
  - max
```
public float max(float[] a)
```
    Gets the max value of a real array.
    
    Parameters:
    
    a - array
    
    Returns:
    
    max
  - max
```
public double max(double[] a)
```
    Gets the max value of a real array.
    
    Parameters:
    
    a - array
    
    Returns:
    
    max
  - min
```
public float min(float[] a)
```
    Gets the min value of a real array.
    
    Parameters:
    
    a - array
    
    Returns:
    
    min
  - min
```
public double min(double[] a)
```
    Gets the min value of a real array.
    
    Parameters:
    
    a - array
    
    Returns:
    
    min
  - scale
```
public float[] scale(float[] a,
                     float max,
                     float min,
                     float maxScale)
```
    Scales a real array to [0 - maxScale].
    
    Parameters:
    
    a - array
    
    max - array's max value
    
    min - array's min value
    
    maxScale - max value of the output array
    
    Returns:
    
    scaled array
  - scale
```
public double[] scale(double[] a,
                      double max,
                      double min,
                      double maxScale)
```
    Scales a real array to [0 - maxScale].
    
    Parameters:
    
    a - array
    
    max - array's max value
    
    min - array's min value
    
    maxScale - max value of the output array
    
    Returns:
    
    scaled array
  - scale
```
public float[] scale(float[] a,
                     float maxScale)
```
    Scales a real array to [0 - maxScale]. Array's max and min values are found using max(float[]) and min(float[]).
    
    Parameters:
    
    a - array
    
    maxScale - max value of the output array
    
    Returns:
    
    scaled array
  - scale
```
public double[] scale(double[] a,
                      double maxScale)
```
    Scales a real array to [0 - maxScale]. Array's max and min values are found using max(double[]) and min(double[]).
    
    Parameters:
    
    a - array
    
    maxScale - max value of the output array
    
    Returns:
    
    scaled array
  - scale2
```
public void scale2(float[] a,
                   float max,
                   float min,
                   float maxScale)
```
    Scales a real array to [0 - maxScale] leaving the result in a.
    
    Parameters:
    
    a - array
    
    max - array's max value
    
    min - array's min value
    
    maxScale - max value of the output array
  - scale2
```
public void scale2(double[] a,
                   double max,
                   double min,
                   double maxScale)
```
    Scales a real array to [0 - maxScale] leaving the result in a.
    
    Parameters:
    
    a - array
    
    max - array's max value
    
    min - array's min value
    
    maxScale - max value of the output array
  - scale2
```
public void scale2(float[] a,
                   float maxScale)
```
    Scales a real array to [0 - maxScale] leaving the result in a. Array's max and min values are found using max(float[]) and min(float[]).
    
    Parameters:
    
    a - array
    
    maxScale - max value of the output array
  - scale2
```
public void scale2(double[] a,
                   double maxScale)
```
    Scales a real array to [0 - maxScale] leaving the result in a. Array's max and min values are found using max(double[]) and min(double[]).
    
    Parameters:
    
    a - array
    
    maxScale - max value of the output array
  - vectorToMatrixArray
```
public static void vectorToMatrixArray(int M,
                                       int N,
                                       float[] a,
                                       float[][] b)
```
    Converts a 1D array into a 2D array leaving the result in b. It is assumed that the information on the 1D array is distributed as the rows of the 2D array in sequence.
    
    Parameters:
    
    M - number of data points in x direction
    
    N - number of data points in y direction
    
    a - 1D array
    
    b - 2D array
  - vectorToMatrixArray
```
public static void vectorToMatrixArray(int M,
                                       int N,
                                       double[] a,
                                       double[][] b)
```
    Converts a 1D array into a 2D array leaving the result in b. It is assumed that the information on the 1D array is distributed as the rows of the 2D array in sequence.
    
    Parameters:
    
    M - number of data points in x direction
    
    N - number of data points in y direction
    
    a - 1D array
    
    b - 2D array
  - matrixToVectorArray
```
public static void matrixToVectorArray(int M,
                                       int N,
                                       float[][] a,
                                       float[] b)
```
    Converts a 2D array into a 1D array leaving the result in b. The information on the 1D array is distributed as the rows of the 2D array in sequence.
    
    Parameters:
    
    M - number of data points in x direction
    
    N - number of data points in y direction
    
    a - 2D array
    
    b - 1D array
  - matrixToVectorArray
```
public static void matrixToVectorArray(int M,
                                       int N,
                                       double[][] a,
                                       double[] b)
```
    Converts a 2D array into a 1D array leaving the result in b. The information on the 1D array is distributed as the rows of the 2D array in sequence.
    
    Parameters:
    
    M - number of data points in x direction
    
    N - number of data points in y direction
    
    a - 2D array
    
    b - 1D array

Class ArrayUtilsGPU

Method Summary

Methods inherited from class java.lang.Object

Method Detail

getInstance

jDiffractionVersion

phase

phase

modulus

modulus

modulusSq

modulusSq

complexMultiplication

complexMultiplication

complexMultiplication2

complexMultiplication2

complexAmplitude

complexAmplitude

complexAmplitude

complexAmplitude

complexAmplitude

complexAmplitude

complexAmplitude2

complexAmplitude2

real

real

imaginary

imaginary

complexShift

complexShift

complexShiftGPU

realShift

realShift

multiply

multiply

divide

divide

log10

log10

max

max

min

min

scale

scale

scale

scale

scale2

scale2

scale2

scale2

vectorToMatrixArray

vectorToMatrixArray

matrixToVectorArray

matrixToVectorArray