RealArray (CML Euclid 2.9 API)

java.lang.Object
- org.xmlcml.euclid.ArrayBase
- - org.xmlcml.euclid.RealArray

All Implemented Interfaces:

Iterable<Double>, EuclidConstants
```
public class RealArray
extends ArrayBase
implements Iterable<Double>
```
array of doubles RealArray represents a 1-dimensional array of doubles and is basically a wrapper for double[] in Java There are a lot of useful member functions (sorting, ranges, parallel operations The default is an array with zero points All arrays are valid objects. Attempting to create an array with < 0 points creates a default array (zero points). Since double[] knows its length (unlike C), there are many cases where double[] can be safely used. However it is not a first-class object and RealArray supplies this feature. double[] is referenceable through getArray() note that the length of the internal array may not be a useful guide to the number of elements. Use contractArray() to adjust arraySize to number of elements (useful after adding elements).

Author:

(C) P. Murray-Rust, 1996

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class RealArray.Filter
filter

static class RealArray.Monotonicity
- Nested classes/interfaces inherited from class org.xmlcml.euclid.ArrayBase
  ArrayBase.Trim

Nested Classes
Modifier and Type	Class and Description
`static class`	`RealArray.Filter` filter
`static class`	`RealArray.Monotonicity`

Field Summary
- Fields inherited from class org.xmlcml.euclid.ArrayBase
  ARRAY_REGEX
- Fields inherited from interface org.xmlcml.euclid.EuclidConstants
  C_AMP, C_APOS, C_ATSIGN, C_BACKSLASH, C_BACKSPACE, C_CARET, C_COLON, C_COMMA, C_DEL, C_DOLLAR, C_EQUALS, C_FORMFEED, C_HASH, C_LANGLE, C_LBRAK, C_LCURLY, C_LSQUARE, C_MINUS, C_NBSP, C_NEWLINE, C_NL, C_PERCENT, C_PERIOD, C_PIPE, C_PLUS, C_POUND, C_QUERY, C_QUOT, C_RANGLE, C_RBRAK, C_RCURLY, C_RETURN, C_RSQUARE, C_SEMICOLON, C_SHRIEK, C_SLASH, C_SPACE, C_STAR, C_TAB, C_TILDE, C_UNDER, EPS, F_S, NONWHITEPUNC, NONWHITEPUNC0, NONWHITEPUNC0REGEX, ONE_THIRD, PUNC, S_AMP, S_APOS, S_ATSIGN, S_BACKSLASH, S_CARET, S_COLON, S_COMMA, S_DOLLAR, S_EMPTY, S_EQUALS, S_FORMFEED, S_HASH, S_LANGLE, S_LBRAK, S_LCURLY, S_LSQUARE, S_MINUS, S_NEWLINE, S_NL, S_PERCENT, S_PERIOD, S_PIPE, S_PLUS, S_POUND, S_QUERY, S_QUOT, S_RANGLE, S_RBRAK, S_RCURLY, S_RETURN, S_RSQUARE, S_SEMICOLON, S_SHRIEK, S_SLASH, S_SPACE, S_STAR, S_TAB, S_TILDE, S_UNDER, S_WHITEREGEX, TWO_THIRDS, U_S, WHITESPACE

Constructor Summary

Constructors
Constructor and Description
`RealArray()` create default Array.
`RealArray(double[] arr)` create Array from java array.
`RealArray(int n)` creates n-element array.
`RealArray(IntArray ia)` create from IntArray.
`RealArray(int n, double elem1)` create Array initialized to constant value.
`RealArray(int n, double[] arr)` create Array from part of java array.
`RealArray(int n, double elem1, double delta)` create n-element array initialised linearly.
`RealArray(int nn, String shape, double maxval)` Create customized array.
`RealArray(RealArray m)` copy constructor.
`RealArray(RealArray ref, IntArray sub)` create mixed sliced array.
`RealArray(RealArray m, int low, int high)` create from subarray of another Array.
`RealArray(String string)` create from a space-separated string of doubles.
`RealArray(String[] strings)` construct from an array of Strings.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`double`	`absSumAllElements()` sum of all absolute element values.
`void`	`addArray(RealArray f)` append elements.
`void`	`addElement(double f)` append element.
`RealArray`	`addScalar(double f)` add a scalar to all elements.
`RealArray`	`applyFilter(RealArray filter)` apply filter.
`RealArray`	`calculateDifferences()` calculate differences between elements i and i+1
`static void`	`check(RealArray array, int size)` checks RealArray is not null and is of given size.
`void`	`clearArray()` clear all elements of array.
`Object`	`clone()` clone.
`IntArray`	`createIntArray()` converts RealArray into IntArray.
`static RealArray`	`createRealArray(int[] integers)` casts an integer array to RealArray
`static RealArray`	`createRealArray(IntArray intArray)` casts an integer array to RealArray
`static RealArray`	`createRealArray(List<String> stringList)` interprets list of Strings as numbers.
`RealArray`	`createReorderedArray(IntSet intSet)` create new reordered array.
`RealArray`	`createScaledArrayToRange(double x0, double x1)` creates scaled array so it runs spans new Range.
`RealArray`	`createScaledArrayToRange(double thisX0, double thisX1, double targetX0, double targetX1)` creates scaled array so it runs spans new Range.
`RealArray`	`cumulativeSum()` cumulative sum of array.
`void`	`deleteElement(int elem)` delete element and close up.
`static double[]`	`deleteElements(double[] f, int low, int hi)` delete elements (lo - > hi inclusive) in a float[] and close up; if hi >= float.length hi is reset to float.length-1.
`void`	`deleteElements(int low, int high)` delete elements and close up.
`double`	`dotProduct(RealArray f)` dot product of two arrays.
`double`	`elementAt(int elem)` get element by index.
`boolean`	`equals(RealArray f, double epsilon)` are two arrays equal.
`double`	`euclideanLength()` Euclidean length of vector
`double`	`findFirstLocalMaximumafter(int start, double cutoff)` if RA is an autocorrelation array find first maximum after origin.
`RealArray`	`format(int places)` round to decimal places.
`double`	`get(int elem)` get element by index.
`double[]`	`getArray()` get java array.
`double`	`getBaseLine()` find baseline.
`static RealArray`	`getFilter(int halfWidth, RealArray.Filter function)` creates a filter based on Gaussian and derivatives.
`DecimalFormat`	`getFormat()` get output format.
`double`	`getLast()` gets last element in array
`double`	`getMax()` value of largest element.
`Double`	`getMean()` calculates mean as sum of all elements divided by number of elements
`double`	`getMin()` value of smallest element.
`RealArray.Monotonicity`	`getMonotonicity()`
`RealArray`	`getNormalDistribution(double sigma)` creates a normal distribution about a mean.
`double`	`getRandomVariate(RealArray distribution, RealArray cumulativeDistribution)` gets a variate from a distribution.
`RealRange`	`getRange()` range of array.
`RealArray`	`getReorderedArray(IntSet idx)` get reordered Array.
`double[]`	`getReverseArray()` get java array in reverse order.
`String`	`getStringArray()`
`String[]`	`getStringValues()` returns values as strings.
`RealArray`	`getSubArray(int start, int end)` get array slice.
`static RealArray`	`getSymmetricalArray(double mid, int nsteps, double halfrange)` gets range distributed about a midpoint.
`int`	`indexOfLargestElement()` index of largest element.
`int`	`indexOfSmallestElement()` index of smallest element.
`IntSet`	`indexSortAscending()` get indexes of ascending sorted array.
`IntSet`	`indexSortDescending()` get indexes of descending sorted array.
`double`	`innerProduct()` inner product.
`IntSet`	`inRange(RealRange r)` get elements within a range.
`void`	`insertArray(int elem, RealArray f)` insert an array and expand.
`void`	`insertElementAt(int elem, double f)` insert element and expand.
`boolean`	`isClear()` is the array filled with zeros.
`boolean`	`isEqualTo(RealArray f)` are two arrays equal.
`static boolean`	`isFloatArray(String s, String delimiterRegex)` parse string as realArray.
`Iterator<Double>`	`iterator()`
`double`	`largestElement()` value of largest element.
`double`	`lineSearch(double probe, RealArray distribution)` binary search on monotonic increasing distribution.
`RealArray`	`multiplyBy(double f)` array multiplication by a scalar.
`void`	`negative()` change the sign of all elements.
`IntSet`	`outOfRange(RealRange r)` get elements outside a range.
`RealArray`	`plus(double f)` add a scalar to each element.
`RealArray`	`plus(RealArray f)` adds arrays.
`void`	`plusEquals(RealArray f)` adds arrays.
`void`	`replaceNaN(double d)` replace all values of NaN with given value.
`void`	`reverse()` puts array into reverse order.
`double`	`rms()` root mean square sqrt(sigma(x(i)**2)/n)
`static void`	`round(double[] dd, int ndec)` normalize to given number of places replaces each element by (nint(elem*10^ndec))/10^ndec
`RealArray`	`scaleAndInterpolate(int newNelem)` Deprecated.
`void`	`setAllElements(double f)` initialise array to given value.
`void`	`setElementAt(int elem, double f)` set element value.
`void`	`setElements(double[] a)` set array.
`void`	`setElements(int start, double[] a)` set array slice.
`void`	`setFormat(DecimalFormat f)` set output format.
`void`	`shiftArrayRight(int nplaces)` shift array and fill with end elements.
`RealArray`	`shiftOriginToRight(double delta)` assumes all elements are equally spaced with "x" separation of 1.0.
`RealArray`	`shiftOriginToRightOld(double delta)` assumes all elements are equally spaced with "x" separation of 1.0.
`int`	`size()` get actual number of elements.
`double`	`smallestElement()` value of smallest element.
`void`	`sortAscending()` sorts array into ascending order.
`void`	`sortDescending()` sorts array into descending order.
`RealArray`	`subtract(RealArray f)` subtracts arrays.
`void`	`subtractEquals(RealArray f)` array subtraction.
`double`	`sumAllElements()` sum all elements.
`double`	`sumProductOfAllElements(RealArray yarr)` sum all product of elements.
`String`	`toString()` gets values as string.
`RealArray`	`trim(ArrayBase.Trim flag, double limit)` trims array to lie within limit.
`RealArray`	`unitVector()` get unit vector

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

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Constructor Detail
  - RealArray
```
public RealArray()
```
    create default Array. default is an array of zero points
  - RealArray
```
public RealArray(int n)
```
    creates n-element array. initialised to 0
    
    Parameters:
    
    n - size of array
  - RealArray
```
public RealArray(int n,
                 double elem1,
                 double delta)
```
    create n-element array initialised linearly. values are elem1+(i-1)*delta
    
    Parameters:
    
    n - size of array
    
    elem1 - starting value
    
    delta - setpsize
  - RealArray
```
public RealArray(int n,
                 double elem1)
```
    create Array initialized to constant value. all elements of the array are set to a given value
    
    Parameters:
    
    n - size of array
    
    elem1 - value to set
  - RealArray
```
public RealArray(int n,
                 double[] arr)
          throws EuclidRuntimeException
```
    create Array from part of java array. use first n elements of array.
    
    Parameters:
    
    n - number of elements to use
    
    arr - array to read from
    
    Throws:
    
    EuclidRuntimeException - n larger than arraysize
  - RealArray
```
public RealArray(double[] arr)
```
    create Array from java array.
    
    Parameters:
    
    arr - array to read from
  - RealArray
```
public RealArray(IntArray ia)
```
    create from IntArray.
    
    Parameters:
    
    ia - IntArray to copy from
  - RealArray
```
public RealArray(RealArray m,
                 int low,
                 int high)
          throws EuclidRuntimeException
```
    create from subarray of another Array.
    
    Parameters:
    
    m - array to slice
    
    low - inclusive start index of array
    
    high - inclusive end index of array
    
    Throws:
    
    EuclidRuntimeException - low > high or negative indices or outside size of m
  - RealArray
```
public RealArray(RealArray ref,
                 IntArray sub)
          throws EuclidRuntimeException
```
    create mixed sliced array. use another IntArray to subscript this one where I(this) = I(ref) subscripted by I(sub); Result has dimension of I(sub). caller is responsible for making sure elements of sub are unique
    
    Parameters:
    
    ref - matrix to slice
    
    sub - subscripts.
    
    Throws:
    
    EuclidRuntimeException - if any of I(sub) lies outside 0...refmax-1
  - RealArray
```
public RealArray(RealArray m)
```
    copy constructor.
    
    Parameters:
    
    m - array to copy
  - RealArray
```
public RealArray(int nn,
                 String shape,
                 double maxval)
```
    Create customized array. create a given 'shape' of array for data filtering An intended use is with RealArray.arrayFilter(). The shapes (before scaling by maxval) are:
    - "TRIANGLE"; 1/nn, 2/nn, ... 1 ... 2/nn, 1/nn; nelem is set to 2*nn - 1
    - "ZIGZAG"; 1/nn, 2/nn, ... 1 ... 1/nn, 0, -1/nn, -2/nn, -1, ... -1/nn,; nelem is set to 4*nn - 1
    step is maxval / nn
    Parameters:
    
    nn - number of elements
    
    shape - TRIANGLE or ZIGZAG
    
    maxval - used to compute step
  - RealArray
```
public RealArray(String[] strings)
          throws EuclidRuntimeException
```
    construct from an array of Strings. must represent doubles
    
    Parameters:
    
    strings - values as Strings
    
    Throws:
    
    EuclidRuntimeException - a string could not be interpreted as doubles
  - RealArray
```
public RealArray(String string)
          throws NumberFormatException
```
    create from a space-separated string of doubles.
    
    Parameters:
    
    string - of form "1.1 -3.2 0.56E-04 2..."
    
    Throws:
    
    NumberFormatException - a substring could not be interpreted as double
- Method Detail
  - getSymmetricalArray
```
public static RealArray getSymmetricalArray(double mid,
                                            int nsteps,
                                            double halfrange)
```
    gets range distributed about a midpoint. array is from n steps from mid-halfrange to mid to mid+halfrange
    
    Parameters:
    
    mid - midpoint of range
    
    nsteps - odd number of steps
    
    halfrange -
    
    Returns:
    
    array
  - clone
```
public Object clone()
```
    clone.
    
    Overrides:
    
    clone in class Object
    
    Returns:
    
    the clone
  - createRealArray
```
public static RealArray createRealArray(List<String> stringList)
```
    interprets list of Strings as numbers.
    
    Parameters:
    
    stringList -
    
    Returns:
    
    null if stringList is null, zero length or has non-numbers
  - setFormat
```
public void setFormat(DecimalFormat f)
```
    set output format. doesn't yet do anything!
    
    Parameters:
    
    f -
  - getFormat
```
public DecimalFormat getFormat()
```
    get output format.
    
    Returns:
    
    format
  - replaceNaN
```
public void replaceNaN(double d)
```
    replace all values of NaN with given value. use with care as there is probably something wrong
    
    Parameters:
    
    d - default value
  - getFilter
```
public static RealArray getFilter(int halfWidth,
                                  RealArray.Filter function)
```
    creates a filter based on Gaussian and derivatives. Scaled so that approximately 2.5 sigma is included (that is value at edge is ca 0.01 of centre
    
    Parameters:
    
    halfWidth -
    
    function -
    
    Returns:
    
    array
  - getNormalDistribution
```
public RealArray getNormalDistribution(double sigma)
```
    creates a normal distribution about a mean. returns N*(exp((x-mean)^2/(2*sigma^2)) where N = 1/sigma*Math.sqrt(2*PI) The distribution is scaled to unit area over -INF to +INF so a smaller selection will not be precisely normalised however -5 sigma to + 5 sigma should be fine the x range is nsteps from maen-range to mean+range. This should be prepared using RealArray xvalues = RealArray.getSymmetricalArray(mean, nsteps, halfrange); RealArray normalDist = xvalues.getNormalDistribution(sigma); nsteps should be an odd positive integer halfrange is the range either side of the mean
    
    Parameters:
    
    sigma - standard deviation
    
    Returns:
    
    array
  - getRandomVariate
```
public double getRandomVariate(RealArray distribution,
                               RealArray cumulativeDistribution)
```
    gets a variate from a distribution. 'this' is normally a regularly spaced RealArray x (e.g. with values x[i] = x0, x0+dx, x0+2*dx, etc. distribution is a set of frequencies of occurrence of the values x[0], x[1]..., i.e. f[0], f[1]... The method uses a cumulative dictribution with a uniformaly distributed variable (e.g. math.random() to read off the interpolated value of x. the cumulativeSum is normally used as a cache, e.g. RealArray x = new RealArray(11, 20., 1.) // gives 20, 21 ...30 RealArray freq = new RealArray(new double[] {23., 3., 45....) RealArray cumulativeSum = new RealArray(); for (int i = 0, i < npoints; i++) { double random = x.getRandomVariate(freq, sumulativeSum); } the size of this and freq must be identical
    
    Parameters:
    
    distribution -
    
    cumulativeDistribution - initially clea, then used as cache
    
    Returns:
    
    a random variate
  - lineSearch
```
public double lineSearch(double probe,
                         RealArray distribution)
```
    binary search on monotonic increasing distribution. 'this' must be regular array of values (x0, x0+dx, x0+2dx...)
    
    Parameters:
    
    probe -
    
    distribution -
    
    Returns:
    
    interpolated point in this
  - elementAt
```
public double elementAt(int elem)
                 throws ArrayIndexOutOfBoundsException
```
    get element by index.
    
    Parameters:
    
    elem - the index
    
    Returns:
    
    element value
    
    Throws:
    
    ArrayIndexOutOfBoundsException - elem >= size of this
  - get
```
public double get(int elem)
           throws ArrayIndexOutOfBoundsException
```
    get element by index.
    
    Parameters:
    
    elem - the index
    
    Returns:
    
    element value
    
    Throws:
    
    ArrayIndexOutOfBoundsException - elem >= size of this
  - size
```
public int size()
```
    get actual number of elements.
    
    Returns:
    
    number of elements
  - getArray
```
public double[] getArray()
```
    get java array. always adjusted to be same length as element count
    
    Returns:
    
    the array
  - clearArray
```
public void clearArray()
```
    clear all elements of array. sets value to 0.0
  - getReverseArray
```
public double[] getReverseArray()
```
    get java array in reverse order.
    
    Returns:
    
    array
  - isEqualTo
```
public boolean isEqualTo(RealArray f)
```
    are two arrays equal.
    
    Parameters:
    
    f - array to compare
    
    Returns:
    
    true if arrays are of same size and this(i) = f(i)
  - equals
```
public boolean equals(RealArray f,
                      double epsilon)
```
    are two arrays equal.
    
    Parameters:
    
    f - array to compare
    
    epsilon - tolerance
    
    Returns:
    
    true if arrays are of same size and Real.isEqual(array[i], f.array[i], epsilon)
  - plus
```
public RealArray plus(RealArray f)
               throws EuclidRuntimeException
```
    adds arrays. does not modify this
    
    Parameters:
    
    f - array to add
    
    Returns:
    
    new array as this + f
    
    Throws:
    
    EuclidRuntimeException - f is different size from this
  - plusEquals
```
public void plusEquals(RealArray f)
                throws EuclidRuntimeException
```
    adds arrays. modifies this += f
    
    Parameters:
    
    f - array to add
    
    Throws:
    
    EuclidRuntimeException - f is different size from this
  - subtract
```
public RealArray subtract(RealArray f)
                   throws EuclidRuntimeException
```
    subtracts arrays. does not modify this
    
    Parameters:
    
    f - array to substract
    
    Returns:
    
    new array as this - f
    
    Throws:
    
    EuclidRuntimeException - f is different size from this
  - subtractEquals
```
public void subtractEquals(RealArray f)
                    throws EuclidRuntimeException
```
    array subtraction. modifies this -= f
    
    Parameters:
    
    f - array to subtract
    
    Throws:
    
    EuclidRuntimeException - f is different size from this
  - negative
```
public void negative()
```
    change the sign of all elements. MODIFIES this
  - addScalar
```
public RealArray addScalar(double f)
```
    add a scalar to all elements. creates new array; does NOT modify 'this'; for subtraction use negative scalar
    
    Parameters:
    
    f - to add
    
    Returns:
    
    new array
  - multiplyBy
```
public RealArray multiplyBy(double f)
```
    array multiplication by a scalar. creates new array; does NOT modify 'this'
    
    Parameters:
    
    f - multiplier
    
    Returns:
    
    the new array
  - plus
```
public RealArray plus(double f)
```
    add a scalar to each element. creates new array; does NOT modify 'this'
    
    Parameters:
    
    f - multiplier
    
    Returns:
    
    the new array
  - setElementAt
```
public void setElementAt(int elem,
                         double f)
                  throws ArrayIndexOutOfBoundsException
```
    set element value.
    
    Parameters:
    
    elem - index
    
    f - value
    
    Throws:
    
    ArrayIndexOutOfBoundsException - elem >= size of this
  - getSubArray
```
public RealArray getSubArray(int start,
                             int end)
```
    get array slice. creates new array; does not modify this
    
    Parameters:
    
    start - index inclusive
    
    end - index inclusive
    
    Returns:
    
    new array
  - setElements
```
public void setElements(int start,
                        double[] a)
```
    set array slice. copy whole array into the array.
    
    Parameters:
    
    start - index in this
    
    a - array to copy
    
    Throws:
    
    ArrayIndexOutOfBoundsException - start < 0 or start+a.length > this.size()
  - setElements
```
public void setElements(double[] a)
```
    set array. clears any existing arrays
    
    Parameters:
    
    a - array to copy
  - isClear
```
public boolean isClear()
```
    is the array filled with zeros.
    
    Returns:
    
    true if this(i) = 0
  - setAllElements
```
public void setAllElements(double f)
```
    initialise array to given value. this(i) = f
    
    Parameters:
    
    f - value to set
  - sumAllElements
```
public double sumAllElements()
```
    sum all elements.
    
    Returns:
    
    sigma(this(i))
  - sumProductOfAllElements
```
public double sumProductOfAllElements(RealArray yarr)
```
    sum all product of elements.
    
    Returns:
    
    sigma(this(i)*y(i)
  - absSumAllElements
```
public double absSumAllElements()
```
    sum of all absolute element values.
    
    Returns:
    
    sigma(abs(this(i)))
  - innerProduct
```
public double innerProduct()
```
    inner product. dotProduct(this)
    
    Returns:
    
    sigma(this(i)**2)
  - dotProduct
```
public double dotProduct(RealArray f)
                  throws EuclidRuntimeException
```
    dot product of two arrays. sigma(this(i)*(f(i));
    
    Parameters:
    
    f - array to multiply
    
    Returns:
    
    dot product
    
    Throws:
    
    EuclidRuntimeException - f is different size from this
  - euclideanLength
```
public double euclideanLength()
```
    Euclidean length of vector
    
    Returns:
    
    length
  - rms
```
public double rms()
           throws EuclidRuntimeException
```
    root mean square sqrt(sigma(x(i)**2)/n)
    
    Returns:
    
    rms
    
    Throws:
    
    EuclidRuntimeException - must have at least 1 point
  - unitVector
```
public RealArray unitVector()
                     throws EuclidRuntimeException
```
    get unit vector
    
    Returns:
    
    the unit vector
    
    Throws:
    
    EuclidRuntimeException - elements of this are all zero
  - cumulativeSum
```
public RealArray cumulativeSum()
```
    cumulative sum of array. create new array as elem[i] = sum(k = 0 to i) f[k] does not modify 'this'
    
    Returns:
    
    each element is cumulative sum to that point
  - applyFilter
```
public RealArray applyFilter(RealArray filter)
```
    apply filter. convolute array with another array. This is 1-D image processing. If filter has <= 1 element, return this unchanged. filter should have an odd number of elements. The filter can be created with a IntArray constructor filter is moved along stepwise
    
    Parameters:
    
    filter - to apply normally smaller than this
    
    Returns:
    
    filtered array
  - trim
```
public RealArray trim(ArrayBase.Trim flag,
                      double limit)
```
    trims array to lie within limit. if flag == BELOW values below limit are set to limit. if flag == ABOVE values above limit are set to limit. by repeated use of trim() values can be constrained to lie within or outside a window does not modify this.
    
    Parameters:
    
    flag - BELOW or ABOVE
    
    limit - value to constrain
    
    Returns:
    
    new array
  - indexOfLargestElement
```
public int indexOfLargestElement()
```
    index of largest element.
    
    Returns:
    
    index
    
    Throws:
    
    ArrayIndexOutOfBoundsException - array is zero length
  - indexOfSmallestElement
```
public int indexOfSmallestElement()
```
    index of smallest element.
    
    Returns:
    
    index
    
    Throws:
    
    ArrayIndexOutOfBoundsException - array is zero length
  - largestElement
```
public double largestElement()
                      throws ArrayIndexOutOfBoundsException
```
    value of largest element.
    
    Returns:
    
    value
    
    Throws:
    
    ArrayIndexOutOfBoundsException - array is zero length
  - getMax
```
public double getMax()
              throws ArrayIndexOutOfBoundsException
```
    value of largest element. synonym for largestElement();
    
    Returns:
    
    value
    
    Throws:
    
    ArrayIndexOutOfBoundsException - array is zero length
  - smallestElement
```
public double smallestElement()
                       throws ArrayIndexOutOfBoundsException
```
    value of smallest element.
    
    Returns:
    
    index
    
    Throws:
    
    ArrayIndexOutOfBoundsException - array is zero length
  - getMin
```
public double getMin()
              throws ArrayIndexOutOfBoundsException
```
    value of smallest element. synonym for smallestElement();
    
    Returns:
    
    value
    
    Throws:
    
    ArrayIndexOutOfBoundsException - array is zero length
  - getMean
```
public Double getMean()
```
    calculates mean as sum of all elements divided by number of elements
    
    Returns:
    
    null if zero-length array.
  - getRange
```
public RealRange getRange()
                   throws ArrayIndexOutOfBoundsException
```
    range of array.
    
    Returns:
    
    (minValue, maxValue)
    
    Throws:
    
    ArrayIndexOutOfBoundsException - array is zero length
  - deleteElement
```
public void deleteElement(int elem)
                   throws ArrayIndexOutOfBoundsException
```
    delete element and close up. modifies this.
    
    Parameters:
    
    elem - to delete
    
    Throws:
    
    ArrayIndexOutOfBoundsException - elem out of range
  - deleteElements
```
public void deleteElements(int low,
                           int high)
                    throws ArrayIndexOutOfBoundsException
```
    delete elements and close up. modifies this.
    
    Parameters:
    
    low - lowest index inclusive
    
    high - highest index inclusive
    
    Throws:
    
    ArrayIndexOutOfBoundsException - low or high out of range or low > high
  - insertElementAt
```
public void insertElementAt(int elem,
                            double f)
                     throws ArrayIndexOutOfBoundsException
```
    insert element and expand. modifies this.
    
    Parameters:
    
    elem - index of element to insert
    
    f - value of element
    
    Throws:
    
    ArrayIndexOutOfBoundsException - elem out of range
  - insertArray
```
public void insertArray(int elem,
                        RealArray f)
                 throws ArrayIndexOutOfBoundsException
```
    insert an array and expand. modifies this.
    
    Parameters:
    
    elem - index of element to insert
    
    f - value of element
    
    Throws:
    
    ArrayIndexOutOfBoundsException - elem out of range
  - addElement
```
public void addElement(double f)
```
    append element. modifies this.
    
    Parameters:
    
    f - element to append
  - addArray
```
public void addArray(RealArray f)
```
    append elements. modifies this.
    
    Parameters:
    
    f - elements to append
  - getReorderedArray
```
public RealArray getReorderedArray(IntSet idx)
                            throws EuclidRuntimeException
```
    get reordered Array. reorder by index in IntSet new(i) = this(idx(i)) does NOT modify array
    
    Parameters:
    
    idx - array of indexes
    
    Returns:
    
    array
    
    Throws:
    
    EuclidRuntimeException - an element of idx is outside range of this
  - round
```
public static void round(double[] dd,
                         int ndec)
```
    normalize to given number of places replaces each element by (nint(elem*10^ndec))/10^ndec
    
    Parameters:
    
    dd - array
    
    ndec - number of places
  - inRange
```
public IntSet inRange(RealRange r)
```
    get elements within a range.
    
    Parameters:
    
    r - within which element values must lie
    
    Returns:
    
    indexes of conforming elements
  - outOfRange
```
public IntSet outOfRange(RealRange r)
```
    get elements outside a range.
    
    Parameters:
    
    r - outside which element values must lie
    
    Returns:
    
    indexes of conforming elements
  - getStringValues
```
public String[] getStringValues()
```
    returns values as strings.
    
    Returns:
    
    string values of elements
  - getStringArray
```
public String getStringArray()
```
  - toString
```
public String toString()
```
    gets values as string. within brackets and including commas
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    element values separated with spaces
  - deleteElements
```
public static double[] deleteElements(double[] f,
                                      int low,
                                      int hi)
```
    delete elements (lo - > hi inclusive) in a float[] and close up; if hi >= float.length hi is reset to float.length-1.
    
    Parameters:
    
    f -
    
    hi -
    
    low -
    
    Returns:
    
    new array
  - findFirstLocalMaximumafter
```
public double findFirstLocalMaximumafter(int start,
                                         double cutoff)
```
    if RA is an autocorrelation array find first maximum after origin. rather hairy so not generally recommended runs through array till value below cutoff then runs till value above cutoff then aggregates values until drops below cutoff
    
    Parameters:
    
    cutoff -
    
    Returns:
    
    the maximum element (may be non-integral)
  - getBaseLine
```
public double getBaseLine()
```
    find baseline. experimental approach to finding baseline and adjusting to it. Finds peak of distribution read source code if you need to use this
    
    Returns:
    
    base offset
  - format
```
public RealArray format(int places)
```
    round to decimal places.
    
    Parameters:
    
    places -
    
    Returns:
    
    this
  - sortAscending
```
public void sortAscending()
```
    sorts array into ascending order. MODIFIES this
  - sortDescending
```
public void sortDescending()
```
    sorts array into descending order. MODIFIES this
  - reverse
```
public void reverse()
```
    puts array into reverse order. MODIFIES this
  - createReorderedArray
```
public RealArray createReorderedArray(IntSet intSet)
```
    create new reordered array.
    
    Parameters:
    
    intSet -
    
    Returns:
  - indexSortAscending
```
public IntSet indexSortAscending()
```
    get indexes of ascending sorted array. this array NOT MODIFIED
    
    Returns:
    
    indexes idx so that element(idx(0)) is lowest
  - indexSortDescending
```
public IntSet indexSortDescending()
```
    get indexes of descending sorted array. this array NOT MODIFIED
    
    Returns:
    
    indexes idx so that element(idx(0)) is highest
  - getMonotonicity
```
public RealArray.Monotonicity getMonotonicity()
```
    Returns:
    
    monotonicity
  - check
```
public static void check(RealArray array,
                         int size)
                  throws EuclidRuntimeException
```
    checks RealArray is not null and is of given size.
    
    Parameters:
    
    array - to check
    
    size - required size
    
    Throws:
    
    EuclidRuntimeException - if null or wrong size
  - isFloatArray
```
public static boolean isFloatArray(String s,
                                   String delimiterRegex)
```
    parse string as realArray.
    
    Parameters:
    
    s -
    
    delimiterRegex -
    
    Returns:
    
    true if can be parsed.
  - createScaledArrayToRange
```
public RealArray createScaledArrayToRange(double thisX0,
                                          double thisX1,
                                          double targetX0,
                                          double targetX1)
```
    creates scaled array so it runs spans new Range. e.g. array = {1,2,3} thisx0, thisx1 = {0.5, 2.5} targetx0, targetx1 = {100, 200} would create {125., 175., 225.} allows for x0 > x1
    
    Parameters:
    
    thisX0 - low map point of this
    
    thisX1 - high map point of this
    
    targetX0 - low map point of target
    
    targetX1 - high map point of target
    
    Returns:
  - createScaledArrayToRange
```
public RealArray createScaledArrayToRange(double x0,
                                          double x1)
```
    creates scaled array so it runs spans new Range. e.g. array = {1,2,3} newRange = {5, 9} would create (5, 7, 9} allows for x0 > x1
    
    Returns:
  - createRealArray
```
public static RealArray createRealArray(int[] integers)
```
    casts an integer array to RealArray
    
    Parameters:
    
    integers -
    
    Returns:
  - createRealArray
```
public static RealArray createRealArray(IntArray intArray)
```
    casts an integer array to RealArray
    
    Parameters:
    
    intArray - integer array
    
    Returns:
  - calculateDifferences
```
public RealArray calculateDifferences()
```
    calculate differences between elements i and i+1
    
    Returns:
    
    array of n-1 differences elem[i+1] - elem[i].
  - createIntArray
```
public IntArray createIntArray()
```
    converts RealArray into IntArray. casts to (int).
    
    Returns:
    
    new IntArray
  - iterator
```
public Iterator<Double> iterator()
```
    Specified by:
    
    iterator in interface Iterable<Double>
  - shiftOriginToRight
```
public RealArray shiftOriginToRight(double delta)
```
    assumes all elements are equally spaced with "x" separation of 1.0. a linear interpolation approach. calculates new values of cells. x may be gt or lt 0 and may have integer arts (e.g. 1.23) // FIXME not yet working for large negative shifts
    
    Parameters:
    
    delta - distance to shift by
    
    Returns:
    
    shifted array
  - scaleAndInterpolate
```
@Deprecated
public RealArray scaleAndInterpolate(int newNelem)
```
    Deprecated.
    
    interpolate array into new array of different length.
    
    Parameters:
    
    newNelem - new array length
    
    Returns:
    
    inerpolated array
  - shiftOriginToRightOld
```
public RealArray shiftOriginToRightOld(double delta)
```
    assumes all elements are equally spaced with "x" separation of 1.0. a linear interpolation approach. calculates new values of cells. x may be gt or lt 0 and may have integer arts (e.g. 1.23) Not fully tested for all cases.
    
    Parameters:
    
    delta - distance to shift by
    
    Returns:
    
    shifted array
  - shiftArrayRight
```
public void shiftArrayRight(int nplaces)
```
    shift array and fill with end elements.
    
    Parameters:
    
    nplaces - if positive sift right; if negative shift left
  - getLast
```
public double getLast()
```
    gets last element in array
    
    Returns:
    
    element ; Double.NaN for zero length array

Class RealArray

Nested Class Summary

Nested classes/interfaces inherited from class org.xmlcml.euclid.ArrayBase

Field Summary

Fields inherited from class org.xmlcml.euclid.ArrayBase

Fields inherited from interface org.xmlcml.euclid.EuclidConstants

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Constructor Detail

RealArray

RealArray

RealArray

RealArray

RealArray

RealArray

RealArray

RealArray

RealArray

RealArray

RealArray

RealArray

RealArray

Method Detail

getSymmetricalArray

clone

createRealArray

setFormat

getFormat

replaceNaN

getFilter

getNormalDistribution

getRandomVariate

lineSearch

elementAt

get

size

getArray

clearArray

getReverseArray

isEqualTo

equals

plus

plusEquals

subtract

subtractEquals

negative

addScalar

multiplyBy

plus

setElementAt

getSubArray

setElements

setElements

isClear

setAllElements

sumAllElements

sumProductOfAllElements

absSumAllElements

innerProduct

dotProduct

euclideanLength

rms

unitVector

cumulativeSum

applyFilter

trim

indexOfLargestElement

indexOfSmallestElement

largestElement

getMax

smallestElement

getMin

getMean

getRange

deleteElement

deleteElements

insertElementAt

insertArray