org.shared.array

Class AbstractComplexArray<C extends AbstractComplexArray<C,R>,R extends AbstractRealArray<R,C>>

java.lang.Object

org.shared.array.ProtoArray<T,double[],E>

org.shared.array.AbstractArray<C,C,R,AbstractComplexArray.Complex>

org.shared.array.AbstractComplexArray<C,R>

Type Parameters:

C - the complex array type.

R - the real array type.

All Implemented Interfaces:

Cloneable, Array<C,AbstractComplexArray.Complex>

Direct Known Subclasses:

ComplexArray

public abstract class AbstractComplexArray<C extends AbstractComplexArray<C,R>,R extends AbstractRealArray<R,C>>
extends AbstractArray<C,C,R,AbstractComplexArray.Complex>

An abstract base class for arrays of complex values.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	AbstractComplexArray.Complex A representation of complex numbers.

Nested classes/interfaces inherited from interface org.shared.array.Array

Array.IndexingOrder

Field Summary

Fields inherited from class org.shared.array.AbstractArray

INVALID_PARITY, parity

Fields inherited from class org.shared.array.ProtoArray

dims, order, strides, values

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	AbstractComplexArray(double[] values, int parity, int[] dims, int[] strides) Default constructor.

Method Summary

Methods

Modifier and Type	Method and Description
double[]	aMean() Computes the mean over the elements.
protected double[]	applyKernelComplexAccumulatorOperation(int type) Supports the a* series of operations.
protected R	applyKernelComplexToRealOperation(int type) Supports the tor* series of operations.
protected C	applyKernelComplexUnaryOperation(double aRe, double aIm, int type) Supports the u* series of operations.
protected C	applyKernelElementwiseOperation(C b, int type) Supports the e* series of operations.
protected C	applyKernelLeftElementwiseOperation(C b, int type) Supports the l* series of operations.
double[]	aProd() Computes the product over the elements.
double[]	aSum() Computes the sum over the elements.
C	eAdd(C array) Computes the elementwise addition.
C	eDiv(C array) Computes the elementwise division.
C	eMul(C array) Computes the elementwise multiplication.
C	eSub(C array) Computes the elementwise subtraction.
C	fft() Computes the full FFT of this array.
C	fftShift() Shifts the entries of this array to the zero frequency component.
protected C	fftShift(int direction) Depending on the direction, performs an fftShift() or ifftShift() of this array.
Class<AbstractComplexArray.Complex>	getComponentType() Gets the component type.
C	ifft() Computes the full IFFT of this array.
C	ifftShift() Undoes the effects of fftShift().
C	lAdd(C array) Computes the left elementwise addition.
C	lDiv(C array) Computes the left elementwise division.
C	lMul(C array) Computes the left elementwise multiplication.
C	lSub(C array) Computes the left elementwise subtraction.
C	reshape(int... dims) Reshapes this array.
C	reverseOrder() Creates an array where the storage order is reversed.
R	rifft() Computes the reduced IFFT of this array.
int[]	rifftDimensions() Gets the reduced IFFT dimensions.
C	subarray(int... bounds) Gets a subarray delimited by the given bounds.
C	tile(int... repetitions) Tiles this array according to the given number repetitions along each dimension.
R	torAbs() Creates an AbstractRealArray from the complex magnitudes of this array's elements.
R	torIm() Creates an AbstractRealArray from the imaginary parts of this array's elements.
R	torRe() Creates an AbstractRealArray from the real parts of this array's elements.
String	toString() Creates a human-readable representation of this array.
C	transpose(int... permutation) Transposes (permutes) the dimensions of this array.
C	uAdd(double aRe, double aIm) Mutatively adds the argument to the elements.
C	uConj() Mutatively takes the complex conjugates of the elements.
C	uCos() Mutatively takes the cosine of the elements.
C	uExp() Mutatively exponentiates the elements to the base Math.E.
C	uFill(double aRe, double aIm) Mutatively fills this array with the argument.
C	uMul(double aRe, double aIm) Mutatively multiplies the elements by the argument.
C	uRnd(double aRe, double aIm) Mutatively randomizes the elements.
C	uShuffle() Mutatively shuffles this array.
C	uSin() Mutatively takes the sine of the elements.
protected C	wrap(AbstractComplexArray.Complex value, Array.IndexingOrder order, int[] dims, int[] strides) Allocates a new array initialized to the given value.
protected C	wrapUp(int parity, Array.IndexingOrder order, int[] dims, int[] strides) Creates an instance of the "up" type after a forward FFT.

Methods inherited from class org.shared.array.AbstractArray

checkInvalidParity, checkMatrixOrder, checkShape, get, rfft, rfftDimensions, set, transform, wrap, wrap, wrapDown

Methods inherited from class org.shared.array.ProtoArray

clone, concat, dims, getBytes, map, nDims, order, physical, reverse, shift, size, slice, slice, slice, slice, splice, stride, strides, values

Methods inherited from class java.lang.Object

equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

AbstractComplexArray

protected AbstractComplexArray(double[] values,
                    int parity,
                    int[] dims,
                    int[] strides)

Default constructor.

Method Detail

fftShift

public C fftShift()

Shifts the entries of this array to the zero frequency component.

ifftShift

public C ifftShift()

Undoes the effects of fftShift().

fftShift

protected C fftShift(int direction)

Depending on the direction, performs an fftShift() or ifftShift() of this array.

Parameters:

direction - the shift direction.

Returns:

the shifted array.

toString

public String toString()

Description copied from interface: Array

Creates a human-readable representation of this array.

Specified by:

toString in interface Array<C extends AbstractComplexArray<C,R>,AbstractComplexArray.Complex>

Overrides:

toString in class AbstractArray<C extends AbstractComplexArray<C,R>,C extends AbstractComplexArray<C,R>,R extends AbstractRealArray<R,C>,AbstractComplexArray.Complex>

wrap

protected C wrap(AbstractComplexArray.Complex value,
     Array.IndexingOrder order,
     int[] dims,
     int[] strides)

Description copied from class: ProtoArray

Allocates a new array initialized to the given value.

Specified by:

wrap in class ProtoArray<C extends AbstractComplexArray<C,R>,double[],AbstractComplexArray.Complex>

Parameters:

value - the initial value.

order - the storage order.

dims - the dimensions.

strides - the strides.

Returns:

the new array.

wrapUp

protected C wrapUp(int parity,
       Array.IndexingOrder order,
       int[] dims,
       int[] strides)

Description copied from class: AbstractArray

Creates an instance of the "up" type after a forward FFT.

Specified by:

wrapUp in class AbstractArray<C extends AbstractComplexArray<C,R>,C extends AbstractComplexArray<C,R>,R extends AbstractRealArray<R,C>,AbstractComplexArray.Complex>

rifftDimensions

public int[] rifftDimensions()

Description copied from class: AbstractArray

Gets the reduced IFFT dimensions.

Overrides:

rifftDimensions in class AbstractArray<C extends AbstractComplexArray<C,R>,C extends AbstractComplexArray<C,R>,R extends AbstractRealArray<R,C>,AbstractComplexArray.Complex>

rifft

public R rifft()

Description copied from class: AbstractArray

Computes the reduced IFFT of this array.

Overrides:

rifft in class AbstractArray<C extends AbstractComplexArray<C,R>,C extends AbstractComplexArray<C,R>,R extends AbstractRealArray<R,C>,AbstractComplexArray.Complex>

fft

public C fft()

Description copied from class: AbstractArray

Computes the full FFT of this array.

Overrides:

fft in class AbstractArray<C extends AbstractComplexArray<C,R>,C extends AbstractComplexArray<C,R>,R extends AbstractRealArray<R,C>,AbstractComplexArray.Complex>

ifft

public C ifft()

Description copied from class: AbstractArray

Computes the full IFFT of this array.

Overrides:

ifft in class AbstractArray<C extends AbstractComplexArray<C,R>,C extends AbstractComplexArray<C,R>,R extends AbstractRealArray<R,C>,AbstractComplexArray.Complex>

subarray

public C subarray(int... bounds)

Description copied from interface: Array

Gets a subarray delimited by the given bounds.

Specified by:

subarray in interface Array<C extends AbstractComplexArray<C,R>,AbstractComplexArray.Complex>

Overrides:

subarray in class ProtoArray<C extends AbstractComplexArray<C,R>,double[],AbstractComplexArray.Complex>

Parameters:

bounds - the subarray bounds as an array of two-tuples. Given the ith tuple, the first component is the (inclusive) lower range and the second component is the (exclusive) upper range.

Returns:

the subarray.

tile

public C tile(int... repetitions)

Description copied from interface: Array

Tiles this array according to the given number repetitions along each dimension.

Specified by:

tile in interface Array<C extends AbstractComplexArray<C,R>,AbstractComplexArray.Complex>

Overrides:

tile in class ProtoArray<C extends AbstractComplexArray<C,R>,double[],AbstractComplexArray.Complex>

Parameters:

repetitions - the number times to repeat along each dimension.

Returns:

the tiled result.

transpose

public C transpose(int... permutation)

Description copied from interface: Array

Transposes (permutes) the dimensions of this array.

Specified by:

transpose in interface Array<C extends AbstractComplexArray<C,R>,AbstractComplexArray.Complex>

Overrides:

transpose in class ProtoArray<C extends AbstractComplexArray<C,R>,double[],AbstractComplexArray.Complex>

Parameters:

permutation - the dimension permutation.

Returns:

the transposed result.

reshape

public C reshape(int... dims)

Description copied from interface: Array

Reshapes this array.

Specified by:

reshape in interface Array<C extends AbstractComplexArray<C,R>,AbstractComplexArray.Complex>

Overrides:

reshape in class ProtoArray<C extends AbstractComplexArray<C,R>,double[],AbstractComplexArray.Complex>

Parameters:

dims - the reshaped dimensions.

Returns:

the reshaped array.

reverseOrder

public C reverseOrder()

Description copied from interface: Array

Creates an array where the storage order is reversed.

Specified by:

reverseOrder in interface Array<C extends AbstractComplexArray<C,R>,AbstractComplexArray.Complex>

Overrides:

reverseOrder in class ProtoArray<C extends AbstractComplexArray<C,R>,double[],AbstractComplexArray.Complex>

getComponentType

public Class<AbstractComplexArray.Complex> getComponentType()

Description copied from interface: Array

Gets the component type.

torAbs

public R torAbs()

Creates an AbstractRealArray from the complex magnitudes of this array's elements.

torRe

public R torRe()

Creates an AbstractRealArray from the real parts of this array's elements.

torIm

public R torIm()

Creates an AbstractRealArray from the imaginary parts of this array's elements.

eAdd

public C eAdd(C array)

Computes the elementwise addition.

eSub

public C eSub(C array)

Computes the elementwise subtraction.

eMul

public C eMul(C array)

Computes the elementwise multiplication.

eDiv

public C eDiv(C array)

Computes the elementwise division.

lAdd

public C lAdd(C array)

Computes the left elementwise addition.

lSub

public C lSub(C array)

Computes the left elementwise subtraction.

lMul

public C lMul(C array)

Computes the left elementwise multiplication.

lDiv

public C lDiv(C array)

Computes the left elementwise division.

uExp

public C uExp()

Mutatively exponentiates the elements to the base Math.E.

uRnd

public C uRnd(double aRe,
     double aIm)

Mutatively randomizes the elements.

uConj

public C uConj()

Mutatively takes the complex conjugates of the elements.

uCos

public C uCos()

Mutatively takes the cosine of the elements.

uSin

public C uSin()

Mutatively takes the sine of the elements.

uAdd

public C uAdd(double aRe,
     double aIm)

Mutatively adds the argument to the elements.

uMul

public C uMul(double aRe,
     double aIm)

Mutatively multiplies the elements by the argument.

uFill

public C uFill(double aRe,
      double aIm)

Mutatively fills this array with the argument.

uShuffle

public C uShuffle()

Mutatively shuffles this array.

aSum

public double[] aSum()

Computes the sum over the elements.

aProd

public double[] aProd()

Computes the product over the elements.

aMean

public double[] aMean()

Computes the mean over the elements.

applyKernelComplexAccumulatorOperation

protected double[] applyKernelComplexAccumulatorOperation(int type)

Supports the a* series of operations.

applyKernelComplexToRealOperation

protected R applyKernelComplexToRealOperation(int type)

Supports the tor* series of operations.

applyKernelElementwiseOperation

protected C applyKernelElementwiseOperation(C b,
                                int type)

Supports the e* series of operations.

applyKernelLeftElementwiseOperation

protected C applyKernelLeftElementwiseOperation(C b,
                                    int type)

Supports the l* series of operations.

applyKernelComplexUnaryOperation

protected C applyKernelComplexUnaryOperation(double aRe,
                                 double aIm,
                                 int type)

Supports the u* series of operations.