AbstractRealArray

java.lang.Object
- org.shared.array.ProtoArray<T,double[],E>
- - org.shared.array.AbstractArray<R,C,R,Double>
  - - org.shared.array.AbstractRealArray<R,C>

Type Parameters:
R - the real array type.
C - the complex array type.

All Implemented Interfaces:

Cloneable, Array<R,Double>

Direct Known Subclasses:

RealArray
```
public abstract class AbstractRealArray<R extends AbstractRealArray<R,C>,C extends AbstractComplexArray<C,R>>
extends AbstractArray<R,C,R,Double>
```
An abstract base class for arrays of real values.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`AbstractRealArray.RealMap` Defines an elementwise "map" operation over real-valued multidimensional arrays.
`static interface`	`AbstractRealArray.RealReduce` Defines an elementwise "reduce" operation over real-valued multidimensional arrays.

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`	`AbstractRealArray(double[] values, Array.IndexingOrder order, int[] dims, int[] strides)` Default constructor.

Method Summary

Methods
Modifier and Type	Method and Description
`double`	`aEnt()` Computes the entropy over the elements.
`double`	`aMax()` Computes the maximum over the elements.
`double`	`aMean()` Computes the mean over the elements.
`double`	`aMin()` Computes the minimum over the elements.
`protected R`	`applyKernelElementwiseOperation(R b, int type)` Supports the e* series of operations.
`protected R`	`applyKernelLeftElementwiseOperation(R b, int type)` Supports the l* series of operations.
`protected double`	`applyKernelRealAccumulatorOperation(int type)` Supports the a* series of operations.
`protected R`	`applyKernelRealDimensionOperation(int type, int[] opDims)` Supports the d* series of operations.
`protected IntegerArray`	`applyKernelRealIndexOperation(int type, int dim)` Supports the i* series of operations.
`protected R`	`applyKernelRealReduceOperation(int type, int[] opDims)` Supports the r* series of operations.
`protected C`	`applyKernelRealToComplexOperation(int type)` Supports the toc* series of operations.
`protected R`	`applyKernelRealUnaryOperation(double a, int type)` Supports the u* series of operations.
`double`	`aProd()` Computes the product over the elements.
`double`	`aSum()` Computes the sum over the elements.
`double`	`aVar()` Computes the variance over the elements.
`R`	`dProd(int... opDims)` Takes the product along the given dimensions.
`R`	`dSum(int... opDims)` Takes the sum along the given dimensions.
`R`	`eAdd(R array)` Computes the elementwise addition.
`R`	`eDiv(R array)` Computes the elementwise division.
`R`	`eMax(R array)` Computes the elementwise maximum.
`R`	`eMin(R array)` Computes the elementwise minimum.
`R`	`eMul(R array)` Computes the elementwise multiplication.
`R`	`eSub(R array)` Computes the elementwise subtraction.
`Class<Double>`	`getComponentType()` Gets the component type.
`IntegerArray`	`iGZero()` Equates to calling `iGZero(int)` with argument `-1`.
`IntegerArray`	`iGZero(int dim)` Finds all greater-than-zeros along the given dimension.
`IntegerArray`	`iLZero()` Equates to calling `iLZero(int)` with argument `-1`.
`IntegerArray`	`iLZero(int dim)` Finds all less-than-zeros along the given dimension.
`IntegerArray`	`iMax()` Equates to calling `iMax(int)` with argument `-1`.
`IntegerArray`	`iMax(int dim)` Finds the maximum values along the given dimension.
`IntegerArray`	`iMin()` Equates to calling `iMin(int)` with argument `-1`.
`IntegerArray`	`iMin(int dim)` Finds the minimum values along the given dimension.
`IntegerArray`	`iSort()` Equates to calling `iSort(int)` with argument `-1`.
`IntegerArray`	`iSort(int dim)` Sorts along the given dimension.
`IntegerArray`	`iZero()` Equates to calling `iZero(int)` with argument `-1`.
`IntegerArray`	`iZero(int dim)` Finds all zeros along the given dimension.
`R`	`lAdd(R array)` Computes the left elementwise addition.
`R`	`lDiv(R array)` Computes the left elementwise division.
`R`	`lMax(R array)` Computes the left elementwise maximum.
`R`	`lMin(R array)` Computes the left elementwise minimum.
`R`	`lMul(R array)` Computes the left elementwise multiplication.
`R`	`lSub(R array)` Computes the left elementwise subtraction.
`R`	`map(AbstractRealArray.RealMap rm)` Mutatively maps the elements.
`double`	`reduce(AbstractRealArray.RealReduce rr)` Reduces the elements.
`C`	`rfft()` Computes the reduced FFT of this array.
`int[]`	`rfftDimensions()` Gets the reduced FFT dimensions.
`R`	`rMax(int... opDims)` Computes the maximum along the given dimensions.
`R`	`rMean(int... opDims)` Computes the mean along the given dimensions.
`R`	`rMin(int... opDims)` Computes the minimum along the given dimensions.
`R`	`rProd(int... opDims)` Computes the product along the given dimensions.
`R`	`rSum(int... opDims)` Computes the sum along the given dimensions.
`R`	`rVar(int... opDims)` Computes the variance along the given dimensions.
`C`	`tocIm()` Creates an `AbstractComplexArray` with the imaginary parts set to this array's elements.
`C`	`tocRe()` Creates an `AbstractComplexArray` with the real parts set to this array's elements.
`R`	`uAbs()` Mutatively takes the absolute value of the elements.
`R`	`uAdd(double a)` Mutatively adds the argument to the elements.
`R`	`uAtan()` Mutatively takes the arctangent of the elements.
`R`	`uCos()` Mutatively takes the cosine of the elements.
`R`	`uExp()` Mutatively exponentiates the elements to the base `Math.E`.
`R`	`uFill(double a)` Mutatively fills this array with the argument.
`R`	`uInv(double a)` Mutatively takes the multiplicative inverse of the elements.
`R`	`uLog()` Mutatively takes the natural logarithm of the elements.
`R`	`uMul(double a)` Mutatively multiplies the elements by the argument.
`R`	`uPow(double a)` Mutatively takes the elements to the power of the argument.
`R`	`uRnd(double a)` Mutatively randomizes the elements.
`R`	`uShuffle()` Mutatively shuffles this array.
`R`	`uSin()` Mutatively takes the sine of the elements.
`R`	`uSqr()` Mutatively squares the elements.
`R`	`uSqrt()` Mutatively takes the square root of the elements.
`protected R`	`wrap(Double value, Array.IndexingOrder order, int[] dims, int[] strides)` Allocates a new array initialized to the given value.
`protected R`	`wrapDown(int parity, Array.IndexingOrder order, int[] dims, int[] strides)` Creates an instance of the "down" type after a backward FFT.

Methods inherited from class org.shared.array.AbstractArray
checkInvalidParity, checkMatrixOrder, checkShape, fft, get, ifft, rifft, rifftDimensions, set, toString, transform, wrap, wrap, wrapUp

Methods inherited from class org.shared.array.ProtoArray
clone, concat, dims, getBytes, map, nDims, order, physical, reshape, reverse, reverseOrder, shift, size, slice, slice, slice, slice, splice, stride, strides, subarray, tile, transpose, values

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

- Constructor Detail
  - AbstractRealArray
```
protected AbstractRealArray(double[] values,
                 Array.IndexingOrder order,
                 int[] dims,
                 int[] strides)
```
    Default constructor.
- Method Detail
  - wrap
```
protected R wrap(Double 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<R extends AbstractRealArray<R,C>,double[],Double>
    
    Parameters:
    value - the initial value.
    order - the storage order.
    dims - the dimensions.
    strides - the strides.
    
    Returns:
    the new array.
  - wrapDown
```
protected R wrapDown(int parity,
         Array.IndexingOrder order,
         int[] dims,
         int[] strides)
```
    Description copied from class: AbstractArray
    
    Creates an instance of the "down" type after a backward FFT.
    
    Specified by:
    
    wrapDown in class AbstractArray<R extends AbstractRealArray<R,C>,C extends AbstractComplexArray<C,R>,R extends AbstractRealArray<R,C>,Double>
  - rfftDimensions
```
public int[] rfftDimensions()
```
    Description copied from class: AbstractArray
    
    Gets the reduced FFT dimensions.
    
    Overrides:
    
    rfftDimensions in class AbstractArray<R extends AbstractRealArray<R,C>,C extends AbstractComplexArray<C,R>,R extends AbstractRealArray<R,C>,Double>
  - rfft
```
public C rfft()
```
    Description copied from class: AbstractArray
    
    Computes the reduced FFT of this array.
    
    Overrides:
    
    rfft in class AbstractArray<R extends AbstractRealArray<R,C>,C extends AbstractComplexArray<C,R>,R extends AbstractRealArray<R,C>,Double>
  - getComponentType
```
public Class<Double> getComponentType()
```
    Description copied from interface: Array
    
    Gets the component type.
  - tocRe
```
public C tocRe()
```
    Creates an AbstractComplexArray with the real parts set to this array's elements.
  - tocIm
```
public C tocIm()
```
    Creates an AbstractComplexArray with the imaginary parts set to this array's elements.
  - uExp
```
public R uExp()
```
    Mutatively exponentiates the elements to the base Math.E.
  - uCos
```
public R uCos()
```
    Mutatively takes the cosine of the elements.
  - uSin
```
public R uSin()
```
    Mutatively takes the sine of the elements.
  - uAtan
```
public R uAtan()
```
    Mutatively takes the arctangent of the elements.
  - uRnd
```
public R uRnd(double a)
```
    Mutatively randomizes the elements.
  - uLog
```
public R uLog()
```
    Mutatively takes the natural logarithm of the elements.
  - uAbs
```
public R uAbs()
```
    Mutatively takes the absolute value of the elements.
  - uPow
```
public R uPow(double a)
```
    Mutatively takes the elements to the power of the argument.
  - uAdd
```
public R uAdd(double a)
```
    Mutatively adds the argument to the elements.
  - uMul
```
public R uMul(double a)
```
    Mutatively multiplies the elements by the argument.
  - uSqrt
```
public R uSqrt()
```
    Mutatively takes the square root of the elements.
  - uSqr
```
public R uSqr()
```
    Mutatively squares the elements.
  - uInv
```
public R uInv(double a)
```
    Mutatively takes the multiplicative inverse of the elements.
  - uFill
```
public R uFill(double a)
```
    Mutatively fills this array with the argument.
  - uShuffle
```
public R uShuffle()
```
    Mutatively shuffles this array.
  - eAdd
```
public R eAdd(R array)
```
    Computes the elementwise addition.
  - eSub
```
public R eSub(R array)
```
    Computes the elementwise subtraction.
  - eMul
```
public R eMul(R array)
```
    Computes the elementwise multiplication.
  - eDiv
```
public R eDiv(R array)
```
    Computes the elementwise division.
  - eMax
```
public R eMax(R array)
```
    Computes the elementwise maximum.
  - eMin
```
public R eMin(R array)
```
    Computes the elementwise minimum.
  - lAdd
```
public R lAdd(R array)
```
    Computes the left elementwise addition.
  - lSub
```
public R lSub(R array)
```
    Computes the left elementwise subtraction.
  - lMul
```
public R lMul(R array)
```
    Computes the left elementwise multiplication.
  - lDiv
```
public R lDiv(R array)
```
    Computes the left elementwise division.
  - lMax
```
public R lMax(R array)
```
    Computes the left elementwise maximum.
  - lMin
```
public R lMin(R array)
```
    Computes the left elementwise minimum.
  - aSum
```
public double aSum()
```
    Computes the sum over the elements.
  - aProd
```
public double aProd()
```
    Computes the product over the elements.
  - aMax
```
public double aMax()
```
    Computes the maximum over the elements.
  - aVar
```
public double aVar()
```
    Computes the variance over the elements.
  - aEnt
```
public double aEnt()
```
    Computes the entropy over the elements.
  - aMin
```
public double aMin()
```
    Computes the minimum over the elements.
  - aMean
```
public double aMean()
```
    Computes the mean over the elements.
  - rSum
```
public R rSum(int... opDims)
```
    Computes the sum along the given dimensions.
  - rProd
```
public R rProd(int... opDims)
```
    Computes the product along the given dimensions.
  - rMax
```
public R rMax(int... opDims)
```
    Computes the maximum along the given dimensions.
  - rMin
```
public R rMin(int... opDims)
```
    Computes the minimum along the given dimensions.
  - rMean
```
public R rMean(int... opDims)
```
    Computes the mean along the given dimensions.
  - rVar
```
public R rVar(int... opDims)
```
    Computes the variance along the given dimensions.
  - iMax
```
public IntegerArray iMax(int dim)
```
    Finds the maximum values along the given dimension.
  - iMin
```
public IntegerArray iMin(int dim)
```
    Finds the minimum values along the given dimension.
  - iZero
```
public IntegerArray iZero(int dim)
```
    Finds all zeros along the given dimension.
  - iGZero
```
public IntegerArray iGZero(int dim)
```
    Finds all greater-than-zeros along the given dimension.
  - iLZero
```
public IntegerArray iLZero(int dim)
```
    Finds all less-than-zeros along the given dimension.
  - iSort
```
public IntegerArray iSort(int dim)
```
    Sorts along the given dimension.
  - iMax
```
public IntegerArray iMax()
```
    Equates to calling iMax(int) with argument -1.
  - iMin
```
public IntegerArray iMin()
```
    Equates to calling iMin(int) with argument -1.
  - iZero
```
public IntegerArray iZero()
```
    Equates to calling iZero(int) with argument -1.
  - iGZero
```
public IntegerArray iGZero()
```
    Equates to calling iGZero(int) with argument -1.
  - iLZero
```
public IntegerArray iLZero()
```
    Equates to calling iLZero(int) with argument -1.
  - iSort
```
public IntegerArray iSort()
```
    Equates to calling iSort(int) with argument -1.
  - dSum
```
public R dSum(int... opDims)
```
    Takes the sum along the given dimensions.
  - dProd
```
public R dProd(int... opDims)
```
    Takes the product along the given dimensions.
  - applyKernelRealAccumulatorOperation
```
protected double applyKernelRealAccumulatorOperation(int type)
```
    Supports the a* series of operations.
  - applyKernelElementwiseOperation
```
protected R applyKernelElementwiseOperation(R b,
                                int type)
```
    Supports the e* series of operations.
  - applyKernelLeftElementwiseOperation
```
protected R applyKernelLeftElementwiseOperation(R b,
                                    int type)
```
    Supports the l* series of operations.
  - applyKernelRealToComplexOperation
```
protected C applyKernelRealToComplexOperation(int type)
```
    Supports the toc* series of operations.
  - applyKernelRealUnaryOperation
```
protected R applyKernelRealUnaryOperation(double a,
                              int type)
```
    Supports the u* series of operations.
  - applyKernelRealReduceOperation
```
protected R applyKernelRealReduceOperation(int type,
                               int[] opDims)
```
    Supports the r* series of operations.
  - applyKernelRealIndexOperation
```
protected IntegerArray applyKernelRealIndexOperation(int type,
                                         int dim)
```
    Supports the i* series of operations.
  - applyKernelRealDimensionOperation
```
protected R applyKernelRealDimensionOperation(int type,
                                  int[] opDims)
```
    Supports the d* series of operations.
  - map
```
public R map(AbstractRealArray.RealMap rm)
```
    Mutatively maps the elements.
    
    Parameters:
    rm - the AbstractRealArray.RealMap.
  - reduce
```
public double reduce(AbstractRealArray.RealReduce rr)
```
    Reduces the elements.
    
    Parameters:
    rr - the AbstractRealArray.RealReduce.
    
    Returns:
    the reduction result.

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

Nested Class Summary

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

Field Summary

Fields inherited from class org.shared.array.AbstractArray

Fields inherited from class org.shared.array.ProtoArray

Constructor Summary

Method Summary

Methods inherited from class org.shared.array.AbstractArray

Methods inherited from class org.shared.array.ProtoArray

Methods inherited from class java.lang.Object

Constructor Detail

AbstractRealArray

Method Detail

wrap

wrapDown

rfftDimensions

rfft

getComponentType

tocRe

tocIm

uExp

uCos

uSin

uAtan

uRnd

uLog

uAbs

uPow

uAdd

uMul

uSqrt

uSqr

uInv

uFill

uShuffle

eAdd

eSub

eMul

eDiv

eMax

eMin

lAdd

lSub

lMul

lDiv

lMax

lMin

aSum

aProd

aMax

aVar

aEnt

aMin

aMean

rSum

rProd

rMax

rMin

rMean

rVar

iMax

iMin

iZero

iGZero

iLZero

iSort

iMax

iMin

iZero

iGZero

iLZero

iSort

dSum

dProd

applyKernelRealAccumulatorOperation

applyKernelElementwiseOperation

applyKernelLeftElementwiseOperation

applyKernelRealToComplexOperation

applyKernelRealUnaryOperation