unal.od.jdiffraction.cpu.utils

Class ArrayUtils

java.lang.Object

unal.od.jdiffraction.cpu.utils.ArrayUtils

public class ArrayUtils
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:

a[i][2 * j] = Re[i][j], a[i][2 * j + 1] = Im[i][j]; 0 <= i < M, 0 <= j < N

Since:

JDiffraction 1.1

Author:

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

Method Summary

Modifier and Type	Method and Description
static double[][]	complexAmplitude(double[][] phase, double amp) Creates a complex array pointwise.
static double[][]	complexAmplitude(double[][] phase, double[][] amp) Creates a complex array pointwise.
static double[][]	complexAmplitude(double phase, double[][] amp) Creates a complex array pointwise.
static float[][]	complexAmplitude(float[][] phase, float amp) Creates a complex array element by element.
static float[][]	complexAmplitude(float[][] phase, float[][] amp) Creates a complex array pointwise.
static float[][]	complexAmplitude(float phase, float[][] amp) Creates a complex array pointwise.
static double[][]	complexAmplitude2(double[][] real, double[][] imaginary) Takes the real and imaginary parts and returns a complex array.
static float[][]	complexAmplitude2(float[][] real, float[][] imaginary) Takes the real and imaginary parts and returns a complex array.
static double[][]	complexMultiplication(double[][] a, double[][] b) Computes the pointwise complex multiplication of 2 arrays.
static float[][]	complexMultiplication(float[][] a, float[][] b) Computes the pointwise complex multiplication of 2 arrays.
static void	complexMultiplication2(double[][] a, double[][] b) Computes the pointwise complex multiplication of 2 arrays leaving the result in a.
static void	complexMultiplication2(float[][] a, float[][] b) Computes the pointwise complex multiplication of 2 arrays leaving the result in a.
static void	complexShift(double[][] a) Performs the circular shifting of a complex array, leaving the result in a.
static void	complexShift(float[][] a) Performs the circular shifting of a complex array, leaving the result in a.
static void	divide(double[][] a, double num) Computes the pointwise division of an array by num, leaving the result in a.
static void	divide(float[][] a, float num) Computes the pointwise division of an array by num, leaving the result in a.
static double[][]	imaginary(double[][] a) Extracts the imaginary part of a complex array.
static float[][]	imaginary(float[][] a) Extracts the imaginary part of a complex array.
static java.lang.String	jDiffractionVersion() Returns the library version as a String.
static double[][]	log10(double[][] a) Computes log10 of a real array.
static 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.
static double	max(double[][] a) Gets the max value of a real array.
static float	max(float[][] a) Gets the max value of a real array.
static double	min(double[][] a) Gets the min value of a real array.
static float	min(float[][] a) Gets the min value of a real array.
static double[][]	modulus(double[][] a) Computes the modulus of a complex array.
static float[][]	modulus(float[][] a) Computes the modulus of a complex array.
static double[][]	modulusSq(double[][] a) Computes the squared modulus of a complex array.
static float[][]	modulusSq(float[][] a) Computes the squared modulus of a complex array.
static void	multiply(double[][] a, double num) Computes the pointwise multiplication of an array by num, leaving the result in a.
static void	multiply(float[][] a, float num) Computes the pointwise multiplication of an array by num, leaving the result in a.
static double[][]	phase(double[][] a) Computes the phase (angle) of a complex array.
static float[][]	phase(float[][] a) Computes the phase (angle) of a complex array.
static double[][]	real(double[][] a) Extracts the real part of a complex array.
static float[][]	real(float[][] a) Extracts the real part of a complex array.
static void	realShift(double[][] a) Performs the circular shifting of a real array, leaving the result in a.
static void	realShift(float[][] a) Performs the circular shifting of a real array, leaving the result in a.
static double[][]	scale(double[][] a, double maxScale) Scales a real array to [0, maxScale].
static double[][]	scale(double[][] a, double max, double min, double maxScale) Scales a real array to [0, maxScale].
static float[][]	scale(float[][] a, float maxScale) Scales a real array to [0, maxScale].
static float[][]	scale(float[][] a, float max, float min, float maxScale) Scales a real array to [0, maxScale].
static void	scale2(double[][] a, double maxScale) Scales a real array to [0, maxScale] leaving the result in a.
static void	scale2(double[][] a, double max, double min, double maxScale) Scales a real array to [0, maxScale] leaving the result in a.
static void	scale2(float[][] a, float maxScale) Scales a real array to [0, maxScale] leaving the result in a.
static 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

jDiffractionVersion

public static java.lang.String jDiffractionVersion()

Returns the library version as a String.

Returns:

library version

Since:

JDiffraction 1.2

phase

public static float[][] phase(float[][] a)

Computes the phase (angle) of a complex array.

phase[i][j] = atan(Im[i][j] / Re[i][j])

Parameters:

a - complex array

Returns:

phase (angle) array

phase

public static double[][] phase(double[][] a)

Computes the phase (angle) of a complex array.

phase[i][j] = atan(Im[i][j] / Re[i][j])

Parameters:

a - complex array

Returns:

phase (angle) array

modulus

public static float[][] modulus(float[][] a)

Computes the modulus of a complex array.

modulus[i][j] = sqrt(Re[i][j]^2 + Im[i][j]^2)

Parameters:

a - complex array

Returns:

modulus array

modulus

public static double[][] modulus(double[][] a)

Computes the modulus of a complex array.

modulus[i][j] = sqrt(Re[i][j]^2 + Im[i][j]^2)

Parameters:

a - complex array

Returns:

modulus array

modulusSq

public static float[][] modulusSq(float[][] a)

Computes the squared modulus of a complex array.

modulusSq[i][j] = Re[i][j]^2 + Im[i][j]^2

Parameters:

a - complex array

Returns:

modulus squared array

modulusSq

public static double[][] modulusSq(double[][] a)

Computes the squared modulus of a complex array.

modulusSq[i][j] = Re[i][j]^2 + Im[i][j]^2

Parameters:

a - complex array

Returns:

modulus squared array

complexMultiplication

public static float[][] complexMultiplication(float[][] a,
                                              float[][] b)

Computes the pointwise complex multiplication of 2 arrays.

Parameters:

a - complex array

b - complex array

Returns:

multiplication

complexMultiplication

public static double[][] complexMultiplication(double[][] a,
                                               double[][] b)

Computes the pointwise complex multiplication of 2 arrays.

Parameters:

a - complex array

b - complex array

Returns:

multiplication

complexMultiplication2

public static void complexMultiplication2(float[][] a,
                                          float[][] b)

Computes the pointwise complex multiplication of 2 arrays leaving the result in a.

Parameters:

a - complex array

b - complex array

complexMultiplication2

public static void complexMultiplication2(double[][] a,
                                          double[][] b)

Computes the pointwise complex multiplication of 2 arrays leaving the result in a.

Parameters:

a - complex array

b - complex array

complexAmplitude

public static float[][] complexAmplitude(float[][] phase,
                                         float[][] amp)

Creates a complex array pointwise. The computation is done calculating amp * exp(i * phase).

Parameters:

phase - phase array

amp - amplitude array

Returns:

complex array

complexAmplitude

public static double[][] complexAmplitude(double[][] phase,
                                          double[][] amp)

Creates a complex array pointwise. The computation is done calculating amp * exp(i * phase).

Parameters:

phase - phase array

amp - amplitude array

Returns:

complex array

complexAmplitude

public static float[][] complexAmplitude(float[][] phase,
                                         float amp)

Creates a complex array element by element. The computation is done calculating amp * exp(i * phase)

Parameters:

phase - phase array

amp - amplitude

Returns:

complex array

complexAmplitude

public static double[][] complexAmplitude(double[][] phase,
                                          double amp)

Creates a complex array pointwise. The computation is done calculating amp * exp(i * phase).

Parameters:

phase - phase array

amp - amplitude

Returns:

complex array

complexAmplitude

public static float[][] complexAmplitude(float phase,
                                         float[][] amp)

Creates a complex array pointwise. The computation is done calculating amp * exp(i * phase).

Parameters:

phase - phase

amp - amplitude array

Returns:

complex array

complexAmplitude

public static double[][] complexAmplitude(double phase,
                                          double[][] amp)

Creates a complex array pointwise. The computation is done calculating amp * exp(i * phase).

Parameters:

phase - phase

amp - amplitude array

Returns:

complex array

complexAmplitude2

public static float[][] complexAmplitude2(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:

real - real part array

imaginary - imaginary part array

Returns:

complex array

complexAmplitude2

public static double[][] complexAmplitude2(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:

real - real part array

imaginary - imaginary part array

Returns:

complex array

real

public static float[][] real(float[][] a)

Extracts the real part of a complex array.

Parameters:

a - complex array

Returns:

real array

real

public static double[][] real(double[][] a)

Extracts the real part of a complex array.

Parameters:

a - complex array

Returns:

real array

imaginary

public static float[][] imaginary(float[][] a)

Extracts the imaginary part of a complex array.

Parameters:

a - complex array

Returns:

imaginary array

imaginary

public static double[][] imaginary(double[][] a)

Extracts the imaginary part of a complex array.

Parameters:

a - complex array

Returns:

imaginary array

complexShift

public static void complexShift(float[][] a)

Performs the circular shifting of a complex array, leaving the result in a.

a b -> d c c d b a

Parameters:

a - complex array

complexShift

public static void complexShift(double[][] a)

Performs the circular shifting of a complex array, leaving the result in a.

a b -> d c c d b a

Parameters:

a - complex array

realShift

public static void realShift(float[][] a)

Performs the circular shifting of a real array, leaving the result in a.

a b -> d c c d b a

Parameters:

a - real array

realShift

public static void realShift(double[][] a)

Performs the circular shifting of a real array, leaving the result in a.

a b -> d c c d b a

Parameters:

a - real array

multiply

public static 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

Since:

JDiffraction 1.2

multiply

public static 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

Since:

JDiffraction 1.2

divide

public static 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

Since:

JDiffraction 1.2

divide

public static 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

Since:

JDiffraction 1.2

log10

public static float[][] log10(float[][] a)

Computes log10 of a real array.

Parameters:

a - array

Returns:

array containing log10(a)

log10

public static double[][] log10(double[][] a)

Computes log10 of a real array.

Parameters:

a - array

Returns:

array containing log10(a)

max

public static float max(float[][] a)

Gets the max value of a real array.

Parameters:

a - array

Returns:

max

max

public static double max(double[][] a)

Gets the max value of a real array.

Parameters:

a - array

Returns:

max

min

public static float min(float[][] a)

Gets the min value of a real array.

Parameters:

a - array

Returns:

min

min

public static double min(double[][] a)

Gets the min value of a real array.

Parameters:

a - array

Returns:

min

scale

public static 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 static 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 static 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 static 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 static 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 static 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 static 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 static 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