MAMath (NetCDF-Java CDM Public API v5.4.2)

java.lang.Object
- ucar.ma2.MAMath

```
public class MAMath
extends Object
```
Element by element algebra on Arrays

See Also:

Index

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class MAMath.MinMax
Holds a minimum and maximum value.

static class MAMath.ScaleOffset
Holds a scale and offset.

Nested Classes
Modifier and Type	Class and Description
`static class`	`MAMath.MinMax` Holds a minimum and maximum value.
`static class`	`MAMath.ScaleOffset` Holds a scale and offset.

Constructor Summary

Constructors
Constructor and Description

MAMath()

Constructors
Constructor and Description
`MAMath()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static Array`	`add(Array a, Array b)` Add elements of two arrays together, allocating the result array.
`static void`	`addDouble(Array result, Array a, Array b)` Add elements of two arrays together as doubles, place sum in the result array.
`static MAMath.ScaleOffset`	`calcScaleOffsetSkipMissingData(Array a, double missingValue, int nbits)` Calculate the scale/offset for an array of numbers.
`static boolean`	`conformable(Array a, Array b)` Check that two arrays are conformable.
`static boolean`	`conformable(int[] shapeA, int[] shapeB)` Check that two array shapes are conformable.
`static Array`	`convert(Array org, DataType wantType)` Convert original array to desired type
`static Array`	`convert2packed(Array unpacked, double missingValue, int nbits, DataType packedType)`
`static Array`	`convert2Unpacked(Array packed, MAMath.ScaleOffset scaleOffset)`
`static void`	`copy(Array result, Array a)` Copy array a to array result, the result array will be in canonical order The operation type is taken from the type of a.
`static void`	`copy(DataType dataType, IndexIterator from, IndexIterator to)` Copy using iterators.
`static void`	`copyBoolean(Array result, Array a)` copy array a to array result as bytes The array a and result must be type boolean
`static void`	`copyByte(Array result, Array a)` copy array a to array result as bytes The values from the array a are converted to byte (if needed), and then converted to the type of result (if needed).
`static void`	`copyChar(Array result, Array a)` copy array a to array result as char The values from the array a are converted to char (if needed), and then converted to the type of result (if needed).
`static void`	`copyDouble(Array result, Array a)` copy array a to array result as doubles The values from the arrays a are converted to double (if needed), and then converted to the type of result (if needed).
`static void`	`copyFloat(Array result, Array a)` copy array a to array result as floats The values from the arrays a are converted to float (if needed), and then converted to the type of result (if needed).
`static void`	`copyInt(Array result, Array a)` copy array a to array result as integers The values from the arrays a are converted to integer (if needed), and then converted to the type of result (if needed).
`static void`	`copyLong(Array result, Array a)` copy array a to array result as longs The values from the array a are converted to long (if needed), and then converted to the type of result (if needed).
`static void`	`copyObject(Array result, Array a)` copy array a to array result as an Object The array a and result must be type object
`static void`	`copyShort(Array result, Array a)` copy array a to array result as shorts The values from the array a are converted to short (if needed), and then converted to the type of result (if needed).
`static boolean`	`equals(Array array1, Array array2)` Returns true if the specified arrays have the same data type, shape, and equal corresponding elements.
`static double`	`getMaximum(Array a)`
`static double`	`getMaximumSkipMissingData(Array a, double missingValue)`
`static double`	`getMinimum(Array a)`
`static double`	`getMinimumSkipMissingData(Array a, double missingValue)`
`static MAMath.MinMax`	`getMinMax(Array a)` Find min and max value in this array, getting values as doubles.
`static MAMath.MinMax`	`getMinMaxSkipMissingData(Array a, double missingValue)`
`static MAMath.MinMax`	`getMinMaxSkipMissingData(Array a, IsMissingEvaluator eval)`
`static int`	`hashCode(Array array)` An implementation of `Object.hashCode()` that is consistent with `equals(Array, Array)`.
`static boolean`	`nearlyEquals(Array data1, Array data2)` Returns true if the specified arrays have the same size, signedness, and approximately equal corresponding elements.
`static int`	`reducedRank(int[] shape)` Calculate the reduced rank of this shape, by subtracting dimensions with length 1
`static void`	`setDouble(Array result, double val)` Set all the elements of this array to the given double value.
`static double`	`sumDouble(Array a)` sum all of the elements of array a as doubles.
`static double`	`sumDoubleSkipMissingData(Array a, double missingValue)` sum all of the elements of array a as doubles.

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

- Constructor Detail
  - MAMath
```
public MAMath()
```
- Method Detail
  - add
```
public static Array add(Array a,
                        Array b)
                 throws IllegalArgumentException
```
    Add elements of two arrays together, allocating the result array. The result type and the operation type are taken from the type of a.
    
    Parameters:
    
    a - add values from here
    
    b - add values from here
    
    Returns:
    
    result = a + b
    
    Throws:
    
    IllegalArgumentException - a and b are not conformable
    
    UnsupportedOperationException - dont support this data type yet
  - addDouble
```
public static void addDouble(Array result,
                             Array a,
                             Array b)
                      throws IllegalArgumentException
```
    Add elements of two arrays together as doubles, place sum in the result array. The values from the arrays a and b are converted to double (if needed), and the sum is converted to the type of result (if needed).
    
    Parameters:
    
    result - result array
    
    a - operand
    
    b - operand
    
    Throws:
    
    IllegalArgumentException - a,b,and result are not conformable
  - calcScaleOffsetSkipMissingData
```
public static MAMath.ScaleOffset calcScaleOffsetSkipMissingData(Array a,
                                                                double missingValue,
                                                                int nbits)
```
    Calculate the scale/offset for an array of numbers.
```
 If signed:
   then
     max value unpacked = 2^(n-1) - 1 packed
     min value unpacked = -(2^(n-1) - 1) packed
   note that -2^(n-1) is unused, and a good place to map missing values
   by solving 2 eq in 2 unknowns, we get:
     scale = (max - min) / (2^n - 2)
     offset = (max + min) / 2
 If unsigned then
     max value unpacked = 2^n - 1 packed
     min value unpacked = 0 packed
   and:
     scale = (max - min) / (2^n - 1)
     offset = min
   One could modify this to allow a holder for missing values.
 
```
    Parameters:
    
    a - array to convert (not changed)
    
    missingValue - skip these
    
    nbits - map into this many bits
    
    Returns:
    
    ScaleOffset, calculated as above.
  - conformable
```
public static boolean conformable(Array a,
                                  Array b)
```
    Check that two arrays are conformable.
    
    Parameters:
    
    a - operand
    
    b - operand
    
    Returns:
    
    true if conformable
  - conformable
```
public static boolean conformable(int[] shapeA,
                                  int[] shapeB)
```
    Check that two array shapes are conformable. The shapes must match exactly, except that dimensions of length 1 are ignored.
    
    Parameters:
    
    shapeA - shape of array 1
    
    shapeB - shape of array 2
    
    Returns:
    
    true if conformable
  - convert
```
public static Array convert(Array org,
                            DataType wantType)
```
    Convert original array to desired type
    
    Parameters:
    
    org - original array
    
    wantType - desired type
    
    Returns:
    
    converted data of desired type, or original array if it is already
  - convert2packed
```
public static Array convert2packed(Array unpacked,
                                   double missingValue,
                                   int nbits,
                                   DataType packedType)
```
  - convert2Unpacked
```
public static Array convert2Unpacked(Array packed,
                                     MAMath.ScaleOffset scaleOffset)
```
  - copy
```
public static void copy(Array result,
                        Array a)
                 throws IllegalArgumentException
```
    Copy array a to array result, the result array will be in canonical order The operation type is taken from the type of a.
    
    Parameters:
    
    result - copy to here
    
    a - copy from here
    
    Throws:
    
    IllegalArgumentException - a and b are not conformable
    
    UnsupportedOperationException - dont support this data type yet
  - copy
```
public static void copy(DataType dataType,
                        IndexIterator from,
                        IndexIterator to)
                 throws IllegalArgumentException
```
    Copy using iterators. Will copy until !from.hasNext().
    
    Parameters:
    
    dataType - use this operation type (eg DataType.DOUBLE uses getDoubleNext())
    
    from - copy from here
    
    to - copy to here
    
    Throws:
    
    IllegalArgumentException - a and b are not conformable
    
    UnsupportedOperationException - dont support this data type
  - copyBoolean
```
public static void copyBoolean(Array result,
                               Array a)
                        throws IllegalArgumentException
```
    copy array a to array result as bytes The array a and result must be type boolean
    
    Parameters:
    
    result - copy to here
    
    a - copy from here
    
    Throws:
    
    IllegalArgumentException - a and result are not conformable
  - copyByte
```
public static void copyByte(Array result,
                            Array a)
                     throws IllegalArgumentException
```
    copy array a to array result as bytes The values from the array a are converted to byte (if needed), and then converted to the type of result (if needed).
    
    Parameters:
    
    result - copy to here
    
    a - copy from here
    
    Throws:
    
    IllegalArgumentException - a and result are not conformable
  - copyChar
```
public static void copyChar(Array result,
                            Array a)
                     throws IllegalArgumentException
```
    copy array a to array result as char The values from the array a are converted to char (if needed), and then converted to the type of result (if needed).
    
    Parameters:
    
    result - copy to here
    
    a - copy from here
    
    Throws:
    
    IllegalArgumentException - a and result are not conformable
  - copyDouble
```
public static void copyDouble(Array result,
                              Array a)
                       throws IllegalArgumentException
```
    copy array a to array result as doubles The values from the arrays a are converted to double (if needed), and then converted to the type of result (if needed).
    
    Parameters:
    
    result - copy to here
    
    a - copy from here
    
    Throws:
    
    IllegalArgumentException - a and result are not conformable
  - copyFloat
```
public static void copyFloat(Array result,
                             Array a)
                      throws IllegalArgumentException
```
    copy array a to array result as floats The values from the arrays a are converted to float (if needed), and then converted to the type of result (if needed).
    
    Parameters:
    
    result - copy to here
    
    a - copy from here
    
    Throws:
    
    IllegalArgumentException - a and result are not conformable
  - copyInt
```
public static void copyInt(Array result,
                           Array a)
                    throws IllegalArgumentException
```
    copy array a to array result as integers The values from the arrays a are converted to integer (if needed), and then converted to the type of result (if needed).
    
    Parameters:
    
    result - copy to here
    
    a - copy from here
    
    Throws:
    
    IllegalArgumentException - a and result are not conformable
  - copyLong
```
public static void copyLong(Array result,
                            Array a)
                     throws IllegalArgumentException
```
    copy array a to array result as longs The values from the array a are converted to long (if needed), and then converted to the type of result (if needed).
    
    Parameters:
    
    result - copy to here
    
    a - copy from here
    
    Throws:
    
    IllegalArgumentException - a and result are not conformable
  - copyObject
```
public static void copyObject(Array result,
                              Array a)
                       throws IllegalArgumentException
```
    copy array a to array result as an Object The array a and result must be type object
    
    Parameters:
    
    result - copy to here
    
    a - copy from here
    
    Throws:
    
    IllegalArgumentException - a and result are not conformable
  - copyShort
```
public static void copyShort(Array result,
                             Array a)
                      throws IllegalArgumentException
```
    copy array a to array result as shorts The values from the array a are converted to short (if needed), and then converted to the type of result (if needed).
    
    Parameters:
    
    result - copy to here
    
    a - copy from here
    
    Throws:
    
    IllegalArgumentException - a and result are not conformable
  - equals
```
public static boolean equals(Array array1,
                             Array array2)
```
    Returns true if the specified arrays have the same data type, shape, and equal corresponding elements. This method is suitable for use in Object.equals(java.lang.Object) implementations.
    Note that floating-point elements must be exactly equal, not merely within some epsilon of each other. This is because it's impossible to write a strictly-conforming Object.equals(java.lang.Object) implementation when an epsilon is incorporated, due to the transitivity requirement.
    nearlyEquals(ucar.ma2.Array, ucar.ma2.Array) is an alternative to this method that returns true if the corresponding elements are "approximately" equal to each other.
    
    Parameters:
    
    array1 - one array to be tested for equality.
    
    array2 - the other array to be tested for equality.
    
    Returns:
    
    true if the specified arrays have the same data type, shape, and equal corresponding elements.
    
    See Also:
    
    Is there a way to get a hashcode of a float with epsilon? - Stack Overflow
  - getMaximum
```
public static double getMaximum(Array a)
```
  - getMaximumSkipMissingData
```
public static double getMaximumSkipMissingData(Array a,
                                               double missingValue)
```
  - getMinimum
```
public static double getMinimum(Array a)
```
  - getMinimumSkipMissingData
```
public static double getMinimumSkipMissingData(Array a,
                                               double missingValue)
```
  - getMinMax
```
public static MAMath.MinMax getMinMax(Array a)
```
    Find min and max value in this array, getting values as doubles. Skip Double.NaN.
    
    Parameters:
    
    a - the array.
    
    Returns:
    
    MinMax
  - getMinMaxSkipMissingData
```
public static MAMath.MinMax getMinMaxSkipMissingData(Array a,
                                                     double missingValue)
```
  - getMinMaxSkipMissingData
```
public static MAMath.MinMax getMinMaxSkipMissingData(Array a,
                                                     IsMissingEvaluator eval)
```
  - hashCode
```
public static int hashCode(Array array)
```
    An implementation of Object.hashCode() that is consistent with equals(Array, Array).
    
    Parameters:
    
    array - an array to hash.
    
    Returns:
    
    a hash code value for the array.
  - nearlyEquals
```
public static boolean nearlyEquals(Array data1,
                                   Array data2)
```
    Returns true if the specified arrays have the same size, signedness, and approximately equal corresponding elements. float elements must be within Misc.defaultMaxRelativeDiffFloat of each other, as determined by Misc.nearlyEquals(double, double, double). Similarly, double elements must be within Misc.defaultMaxRelativeDiffDouble of each other.
    equals(Array, Array) is an alternative to this method that requires that corresponding elements be exactly equal. It is suitable for use in Object.equals(java.lang.Object) implementations, whereas this method isn't.
    
    Parameters:
    
    data1 - one array to be tested for equality.
    
    data2 - the other array to be tested for equality.
    
    Returns:
    
    true if the specified arrays have the same size, signedness, and approximately equal corresponding elems.
  - reducedRank
```
public static int reducedRank(int[] shape)
```
    Calculate the reduced rank of this shape, by subtracting dimensions with length 1
    
    Parameters:
    
    shape - shape of the array
    
    Returns:
    
    rank without dimensions of length 1
  - setDouble
```
public static void setDouble(Array result,
                             double val)
```
    Set all the elements of this array to the given double value. The value is converted to the element type of the array, if needed.
    
    Parameters:
    
    result - change this Array
    
    val - set all elements to this value
  - sumDouble
```
public static double sumDouble(Array a)
```
    sum all of the elements of array a as doubles. The values from the array a are converted to double (if needed).
    
    Parameters:
    
    a - read values from this Array
    
    Returns:
    
    sum of elements
  - sumDoubleSkipMissingData
```
public static double sumDoubleSkipMissingData(Array a,
                                              double missingValue)
```
    sum all of the elements of array a as doubles. The values from the array a are converted to double (if needed).
    
    Parameters:
    
    a - read values from this Array
    
    missingValue - skip values equal to this, or which are NaNs
    
    Returns:
    
    sum of elements

Class MAMath

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

MAMath

Method Detail

add

addDouble

calcScaleOffsetSkipMissingData

conformable

conformable

convert

convert2packed

convert2Unpacked

copy

copy

copyBoolean

copyByte

copyChar

copyDouble

copyFloat

copyInt

copyLong

copyObject

copyShort

equals

getMaximum

getMaximumSkipMissingData

getMinimum

getMinimumSkipMissingData

getMinMax

getMinMaxSkipMissingData

getMinMaxSkipMissingData

hashCode

nearlyEquals

reducedRank

setDouble

sumDouble

sumDoubleSkipMissingData