org.eclipse.january.dataset

## Class Maths

- java.lang.Object
- - org.eclipse.january.dataset.Maths

-     public class Maths
      extends Object

  Mathematics class

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `Maths()`

  - ### Method Summary

    All Methods Static Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `static Dataset` | `abs(Object a)` abs - absolute value of each element
    `static Dataset` | `abs(Object a, Dataset o)` abs - absolute value of each element
    `static Dataset` | `add(Collection<IDataset> sets, boolean requireClone)` Adds all sets passed in together The first IDataset must cast to Dataset For memory efficiency sake if add(...) is called with a set of size one, no clone is done, the original object is returned directly.
    `static Dataset` | `add(Object a, Object b)` add operator
    `static Dataset` | `add(Object a, Object b, Dataset o)` add operator
    `protected static void` | `addBinaryOperatorName(Dataset a, Dataset b, Dataset dataset, String oname)`
    `protected static void` | `addFunctionName(Dataset a, Dataset b, Dataset dataset, String fname)`
    `protected static void` | `addFunctionName(Dataset dataset, String fname)`
    `static Dataset` | `angle(Object a)` Create a dataset of the arguments from a complex dataset
    `static Dataset` | `angle(Object a, boolean inDegrees)` Create a dataset of the arguments from a complex dataset
    `static Dataset` | `angle(Object a, boolean inDegrees, Dataset o)` Create a dataset of the arguments from a complex dataset
    `static Dataset` | `angle(Object a, Dataset o)` Create a dataset of the arguments from a complex dataset
    `static Dataset` | `arccos(Object a)` arccos - evaluate the inverse cosine function on each element of the dataset
    `static Dataset` | `arccos(Object a, Dataset o)` arccos - evaluate the inverse cosine function on each element of the dataset
    `static Dataset` | `arccosh(Object a)` arccosh - evaluate the inverse hyperbolic cosine function on each element of the dataset
    `static Dataset` | `arccosh(Object a, Dataset o)` arccosh - evaluate the inverse hyperbolic cosine function on each element of the dataset
    `static Dataset` | `arcsin(Object a)` arcsin - evaluate the inverse sine function on each element of the dataset
    `static Dataset` | `arcsin(Object a, Dataset o)` arcsin - evaluate the inverse sine function on each element of the dataset
    `static Dataset` | `arcsinh(Object a)` arcsinh - evaluate the inverse hyperbolic sine function on each element of the dataset
    `static Dataset` | `arcsinh(Object a, Dataset o)` arcsinh - evaluate the inverse hyperbolic sine function on each element of the dataset
    `static Dataset` | `arctan(Object a)` arctan - evaluate the inverse tangent function on each element of the dataset
    `static Dataset` | `arctan(Object a, Dataset o)` arctan - evaluate the inverse tangent function on each element of the dataset
    `static Dataset` | `arctan2(Object a, Object b)`
    `static Dataset` | `arctan2(Object a, Object b, Dataset o)`
    `static Dataset` | `arctanh(Object a)` arctanh - evaluate the inverse hyperbolic tangent function on each element of the dataset
    `static Dataset` | `arctanh(Object a, Dataset o)` arctanh - evaluate the inverse hyperbolic tangent function on each element of the dataset
    `static Dataset` | `bitwiseAnd(Object a, Object b)` bitwiseAnd operator
    `static Dataset` | `bitwiseAnd(Object a, Object b, Dataset o)` bitwiseAnd operator
    `static Dataset` | `bitwiseInvert(Object a)` bitwiseInvert - `~a`, bitwise invert (or NOT) each element
    `static Dataset` | `bitwiseInvert(Object a, Dataset o)` bitwiseInvert - `~a`, bitwise invert (or NOT) each element
    `static Dataset` | `bitwiseOr(Object a, Object b)` bitwiseOr operator
    `static Dataset` | `bitwiseOr(Object a, Object b, Dataset o)` bitwiseOr operator
    `static Dataset` | `bitwiseXor(Object a, Object b)` bitwiseXor operator
    `static Dataset` | `bitwiseXor(Object a, Object b, Dataset o)` bitwiseXor operator
    `static Dataset` | `cbrt(Object a)` cbrt - evaluate the cube root function on each element of the dataset
    `static Dataset` | `cbrt(Object a, Dataset o)` cbrt - evaluate the cube root function on each element of the dataset
    `static Dataset` | `ceil(Object a)` ceil - evaluate the ceiling function on each element of the dataset
    `static Dataset` | `ceil(Object a, Dataset o)` ceil - evaluate the ceiling function on each element of the dataset
    `static Dataset` | `centralDifference(Dataset a, int axis)` Discrete difference of dataset along axis using finite central difference
    `static Dataset` | `clip(Object a, Dataset o, Object pa, Object pb)` clip - clip elements to limits
    `static Dataset` | `clip(Object a, Object pa, Object pb)` clip - clip elements to limits
    `static Dataset` | `conjugate(Object a)`
    `static Dataset` | `conjugate(Object a, Dataset o)`
    `static Dataset` | `cos(Object a)` cos - evaluate the cosine function on each element of the dataset
    `static Dataset` | `cos(Object a, Dataset o)` cos - evaluate the cosine function on each element of the dataset
    `static Dataset` | `cosh(Object a)` cosh - evaluate the hyperbolic cosine function on each element of the dataset
    `static Dataset` | `cosh(Object a, Dataset o)` cosh - evaluate the hyperbolic cosine function on each element of the dataset
    `static Dataset` | `derivative(Dataset x, Dataset y, int n)` Calculates the derivative of a line described by two datasets (x,y) given a spread of n either side of the point
    `static Dataset` | `difference(Dataset a, int n, int axis)` Discrete difference of dataset along axis using finite difference
    `static Dataset` | `divide(Object a, Object b)` divide operator
    `static Dataset` | `divide(Object a, Object b, Dataset o)` divide operator
    `static Dataset` | `divideTowardsFloor(Object a, Object b)` divideTowardsFloor operator
    `static Dataset` | `divideTowardsFloor(Object a, Object b, Dataset o)` divideTowardsFloor operator
    `static Dataset` | `dividez(Object a, Object b)` dividez operator
    `static Dataset` | `dividez(Object a, Object b, Dataset o)` dividez operator
    `static Dataset` | `exp(Object a)` exp - evaluate the exponential function on each element of the dataset
    `static Dataset` | `exp(Object a, Dataset o)` exp - evaluate the exponential function on each element of the dataset
    `static Dataset` | `expm1(Object a)` expm1 - evaluate the exponential function - 1 on each element of the dataset
    `static Dataset` | `expm1(Object a, Dataset o)` expm1 - evaluate the exponential function - 1 on each element of the dataset
    `static Dataset` | `floor(Object a)` floor - evaluate the floor function on each element of the dataset
    `static Dataset` | `floor(Object a, Dataset o)` floor - evaluate the floor function on each element of the dataset
    `static Dataset` | `floorDivide(Object a, Object b)`
    `static Dataset` | `floorDivide(Object a, Object b, Dataset o)`
    `static Dataset` | `floorRemainder(Object a, Object b)`
    `static Dataset` | `floorRemainder(Object a, Object b, Dataset o)`
    `static void` | `getBilinear(double[] values, CompoundDataset d, double x0, double x1)` Deprecated. Use `interpolate(double[], CompoundDataset, double, double)`
    `static double` | `getBilinear(IDataset d, double x0, double x1)` Deprecated. Use `interpolate(Dataset, double, double)`
    `static double` | `getBilinear(IDataset d, IDataset m, double x0, double x1)` Deprecated. Use `interpolate(Dataset, Dataset, double, double)`
    `static void` | `getLinear(double[] values, CompoundDataset d, double x0)` Deprecated. Use `interpolate(double[], CompoundDataset, double)`
    `static double` | `getLinear(IDataset d, double x0)` Deprecated. Use `interpolate(Dataset, double)`
    `static List<Dataset>` | `gradient(Dataset y, Dataset... x)` Calculate gradient (or partial derivatives) by central difference
    `static Dataset` | `hypot(Object a, Object b)`
    `static Dataset` | `hypot(Object a, Object b, Dataset o)`
    `static double` | `interpolate(Dataset d, Dataset m, double... x)` Linearly interpolate a value at a point in an n-D dataset with a mask.
    `static double` | `interpolate(Dataset d, Dataset m, double x0)` Linearly interpolate a value at a point in a 1D dataset with a mask.
    `static double` | `interpolate(Dataset d, Dataset m, double x0, double x1)` Linearly interpolate a value at a point in a 2D dataset with a mask.
    `static Dataset` | `interpolate(Dataset x, Dataset d, IDataset x0, Number left, Number right)` Linearly interpolate values at points in a 1D dataset corresponding to given coordinates.
    `static double` | `interpolate(Dataset d, double... x)` Linearly interpolate a value at a point in an n-D dataset.
    `static double` | `interpolate(Dataset d, double x0)` Linearly interpolate a value at a point in a 1D dataset.
    `static double` | `interpolate(Dataset d, double x0, double x1)` Linearly interpolate a value at a point in a 2D dataset.
    `static void` | `interpolate(double[] values, CompoundDataset d, double... x)` Linearly interpolate an array of values at a point in a compound n-D dataset.
    `static void` | `interpolate(double[] values, CompoundDataset d, double x0)` Linearly interpolate an array of values at a point in a compound 1D dataset.
    `static void` | `interpolate(double[] values, CompoundDataset d, double x0, double x1)` Linearly interpolate an array of values at a point in a compound 2D dataset.
    `static Dataset` | `leftShift(Object a, Object b)` leftShift operator
    `static Dataset` | `leftShift(Object a, Object b, Dataset o)` leftShift operator
    `static Dataset` | `log(Object a)` log - evaluate the logarithm function on each element of the dataset
    `static Dataset` | `log(Object a, Dataset o)` log - evaluate the logarithm function on each element of the dataset
    `static Dataset` | `log10(Object a)` log10 - evaluate the logarithm function on each element of the dataset
    `static Dataset` | `log10(Object a, Dataset o)` log10 - evaluate the logarithm function on each element of the dataset
    `static Dataset` | `log1p(Object a)` log1p - evaluate the logarithm function of 1 plus on each element of the dataset
    `static Dataset` | `log1p(Object a, Dataset o)` log1p - evaluate the logarithm function of 1 plus on each element of the dataset
    `static Dataset` | `log2(Object a)` log2 - evaluate the logarithm function on each element of the dataset
    `static Dataset` | `log2(Object a, Dataset o)` log2 - evaluate the logarithm function on each element of the dataset
    `static Dataset` | `lowerClip(Object a, Dataset o, Object pa)` lowerClip - clip elements to lower limit
    `static Dataset` | `lowerClip(Object a, Object pa)` lowerClip - clip elements to lower limit
    `static Dataset` | `maximum(Object a, Object b)` maximum operator
    `static Dataset` | `maximum(Object a, Object b, Dataset o)` maximum operator
    `static Dataset` | `minimum(Object a, Object b)` minimum operator
    `static Dataset` | `minimum(Object a, Object b, Dataset o)` minimum operator
    `static Dataset` | `multiply(Collection<IDataset> sets, boolean requireClone)` Multiplies all sets passed in together The first IDataset must cast to Dataset
    `static Dataset` | `multiply(Object a, Object b)` multiply operator
    `static Dataset` | `multiply(Object a, Object b, Dataset o)` multiply operator
    `static Dataset` | `negative(Object a)` negative - negative value of each element
    `static Dataset` | `negative(Object a, Dataset o)` negative - negative value of each element
    `static Dataset` | `phaseAsComplexNumber(Object a, boolean keepZeros)` Create a phase only dataset.
    `static Dataset` | `phaseAsComplexNumber(Object a, Dataset o, boolean keepZeros)` Create a phase only dataset.
    `static Dataset` | `power(Object a, Object b)` power operator
    `static Dataset` | `power(Object a, Object b, Dataset o)` power operator
    `static Dataset` | `reciprocal(Object a)` Find reciprocal from dataset
    `static Dataset` | `reciprocal(Object a, Dataset o)` Find reciprocal from dataset
    `static Dataset` | `remainder(Object a, Object b)` remainder operator
    `static Dataset` | `remainder(Object a, Object b, Dataset o)` remainder operator
    `static Dataset` | `rightShift(Object a, Object b)` rightShift operator
    `static Dataset` | `rightShift(Object a, Object b, Dataset o)` rightShift operator
    `static Dataset` | `rint(Object a)` rint - round each element of the dataset
    `static Dataset` | `rint(Object a, Dataset o)` rint - round each element of the dataset
    `static Dataset` | `signum(Object a)` signum - sign of each element
    `static Dataset` | `signum(Object a, Dataset o)` signum - sign of each element
    `static Dataset` | `sin(Object a)` sin - evaluate the sine function on each element of the dataset
    `static Dataset` | `sin(Object a, Dataset o)` sin - evaluate the sine function on each element of the dataset
    `static Dataset` | `sinh(Object a)` sinh - evaluate the hyperbolic sine function on each element of the dataset
    `static Dataset` | `sinh(Object a, Dataset o)` sinh - evaluate the hyperbolic sine function on each element of the dataset
    `static Dataset` | `sqrt(Object a)` sqrt - evaluate the square root function on each element of the dataset
    `static Dataset` | `sqrt(Object a, Dataset o)` sqrt - evaluate the square root function on each element of the dataset
    `static Dataset` | `square(Object a)` square - square each element
    `static Dataset` | `square(Object a, Dataset o)` square - square each element
    `static Dataset` | `subtract(Object a, Object b)` subtract operator
    `static Dataset` | `subtract(Object a, Object b, Dataset o)` subtract operator
    `static Dataset` | `tan(Object a)` tan - evaluate the tangent function on each element of the dataset
    `static Dataset` | `tan(Object a, Dataset o)` tan - evaluate the tangent function on each element of the dataset
    `static Dataset` | `tanh(Object a)` tanh - evaluate the tangent hyperbolic function on each element of the dataset
    `static Dataset` | `tanh(Object a, Dataset o)` tanh - evaluate the tangent hyperbolic function on each element of the dataset
    `static Dataset` | `toDegrees(Object a)` toDegrees - convert to degrees
    `static Dataset` | `toDegrees(Object a, Dataset o)` toDegrees - convert to degrees
    `protected static long` | `toLong(double d)`
    `static Dataset` | `toRadians(Object a)` toRadians - convert to radians
    `static Dataset` | `toRadians(Object a, Dataset o)` toRadians - convert to radians
    `static Dataset` | `truncate(Object a)` truncate - truncate each element to integers of the dataset
    `static Dataset` | `truncate(Object a, Dataset o)` truncate - truncate each element to integers of the dataset
    `static Dataset` | `unsignedRightShift(Object a, Object b)` unsignedRightShift operator
    `static Dataset` | `unsignedRightShift(Object a, Object b, Dataset o)` unsignedRightShift operator
    `static Object` | `unwrap(Dataset o, Object... a)` Unwrap result from mathematical methods if necessary
    `static Object` | `unwrap(Dataset o, Object a)` Unwrap result from mathematical methods if necessary
    `static Object` | `unwrap(Dataset o, Object a, Object b)` Unwrap result from mathematical methods if necessary
    `static Dataset` | `upperClip(Object a, Dataset o, Object pa)` upperClip - clip elements to upper limit
    `static Dataset` | `upperClip(Object a, Object pa)` upperClip - clip elements to upper limit

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### Maths

          public Maths()

  - ### Method Detail

    - #### unwrap

          public static Object unwrap(Dataset o,
                                      Object a)

      Unwrap result from mathematical methods if necessary
      Parameters:
        `o` - dataset
        `a` - input
      Returns:
        a dataset if a is a dataset or an object of the same class as o

    - #### unwrap

          public static Object unwrap(Dataset o,
                                      Object a,
                                      Object b)

      Unwrap result from mathematical methods if necessary
      Parameters:
        `o` - dataset
        `a` - first input
        `b` - second input
      Returns:
        a dataset if either a and b are datasets or an object of the same class as o

    - #### unwrap

          public static Object unwrap(Dataset o,
                                      Object... a)

      Unwrap result from mathematical methods if necessary
      Parameters:
        `o` - dataset
        `a` - inputs
      Returns:
        a dataset if any inputs are datasets or an object of the same class as o

    - #### floorDivide

          public static Dataset floorDivide(Object a,
                                            Object b)

      Parameters:
        `a` - first operand
        `b` - second operand
      Returns:
        floor divide of a and b

    - #### floorDivide

          public static Dataset floorDivide(Object a,
                                            Object b,
                                            Dataset o)

      Parameters:
        `a` - first operand
        `b` - second operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        floor divide of a and b

    - #### floorRemainder

          public static Dataset floorRemainder(Object a,
                                               Object b)

      Parameters:
        `a` - first operand
        `b` - second operand
      Returns:
        floor remainder of a and b

    - #### floorRemainder

          public static Dataset floorRemainder(Object a,
                                               Object b,
                                               Dataset o)

      Parameters:
        `a` - first operand
        `b` - second operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        floor remainder of a and b

    - #### reciprocal

          public static Dataset reciprocal(Object a)

      Find reciprocal from dataset
      Parameters:
        `a` - single operand
      Returns:
        reciprocal dataset

    - #### reciprocal

          public static Dataset reciprocal(Object a,
                                           Dataset o)

      Find reciprocal from dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        reciprocal dataset

    - #### abs

          public static Dataset abs(Object a)

      abs - absolute value of each element
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### abs

          public static Dataset abs(Object a,
                                    Dataset o)

      abs - absolute value of each element
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### conjugate

          public static Dataset conjugate(Object a)

      Parameters:
        `a` - single operand
      Returns:
        a^*, complex conjugate of a

    - #### conjugate

          public static Dataset conjugate(Object a,
                                          Dataset o)

      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        a^*, complex conjugate of a

    - #### hypot

          public static Dataset hypot(Object a,
                                      Object b)

      Parameters:
        `a` - side of right-angled triangle
        `b` - side of right-angled triangle
      Returns:
        hypotenuse of right-angled triangle: sqrt(a^2 + a^2)

    - #### hypot

          public static Dataset hypot(Object a,
                                      Object b,
                                      Dataset o)

      Parameters:
        `a` - side of right-angled triangle
        `b` - side of right-angled triangle
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        hypotenuse of right-angled triangle: sqrt(a^2 + a^2)

    - #### arctan2

          public static Dataset arctan2(Object a,
                                        Object b)

      Parameters:
        `a` - opposite side of right-angled triangle
        `b` - adjacent side of right-angled triangle
      Returns:
        angle of triangle: atan(b/a)

    - #### arctan2

          public static Dataset arctan2(Object a,
                                        Object b,
                                        Dataset o)

      Parameters:
        `a` - opposite side of right-angled triangle
        `b` - adjacent side of right-angled triangle
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        angle of triangle: atan(b/a)

    - #### angle

          public static Dataset angle(Object a)

      Create a dataset of the arguments from a complex dataset
      Parameters:
        `a` - single operand
      Returns:
        dataset of angles in radians

    - #### angle

          public static Dataset angle(Object a,
                                      boolean inDegrees)

      Create a dataset of the arguments from a complex dataset
      Parameters:
        `a` - single operand
        `inDegrees` - if true then return angles in degrees else in radians
      Returns:
        dataset of angles

    - #### angle

          public static Dataset angle(Object a,
                                      Dataset o)

      Create a dataset of the arguments from a complex dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset of angles in radians

    - #### angle

          public static Dataset angle(Object a,
                                      boolean inDegrees,
                                      Dataset o)

      Create a dataset of the arguments from a complex dataset
      Parameters:
        `a` - single operand
        `inDegrees` - if true then return angles in degrees else in radians
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset of angles

    - #### phaseAsComplexNumber

          public static Dataset phaseAsComplexNumber(Object a,
                                                     boolean keepZeros)

      Create a phase only dataset. NB it will contain NaNs if there are any items with zero amplitude
      Parameters:
        `a` - single operand
        `keepZeros` - if true then zero items are returned as zero rather than NaNs
      Returns:
        complex dataset where items have unit amplitude

    - #### phaseAsComplexNumber

          public static Dataset phaseAsComplexNumber(Object a,
                                                     Dataset o,
                                                     boolean keepZeros)

      Create a phase only dataset. NB it will contain NaNs if there are any items with zero amplitude
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
        `keepZeros` - if true then zero items are returned as zero rather than NaNs
      Returns:
        complex dataset where items have unit amplitude

    - #### add

          public static Dataset add(Collection<IDataset> sets,
                                    boolean requireClone)

      Adds all sets passed in together The first IDataset must cast to Dataset For memory efficiency sake if add(...) is called with a set of size one, no clone is done, the original object is returned directly. Otherwise a new data set is returned, the sum of those passed in.
      Parameters:
        `sets` - datasets
        `requireClone` - if true, clone destination to hold sum
      Returns:
        sum of collection

    - #### multiply

          public static Dataset multiply(Collection<IDataset> sets,
                                         boolean requireClone)

      Multiplies all sets passed in together The first IDataset must cast to Dataset
      Parameters:
        `sets` - datasets
        `requireClone` - if true, clone destination to hold product
      Returns:
        product of collection

    - #### interpolate

          public static Dataset interpolate(Dataset x,
                                            Dataset d,
                                            IDataset x0,
                                            Number left,
                                            Number right)

      Linearly interpolate values at points in a 1D dataset corresponding to given coordinates.
      Parameters:
        `x` - input 1-D coordinate dataset (must be ordered)
        `d` - input 1-D dataset
        `x0` - coordinate values
        `left` - value to use when x0 lies left of domain. If null, then interpolate to zero by using leftmost interval
        `right` - value to use when x0 lies right of domain. If null, then interpolate to zero by using rightmost interval
      Returns:
        interpolated values

    - #### interpolate

          public static double interpolate(Dataset d,
                                           double x0)

      Linearly interpolate a value at a point in a 1D dataset. The dataset is considered to have zero support outside its bounds. Thus points just outside are interpolated from the boundary value to zero.
      Parameters:
        `d` - input dataset
        `x0` - coordinate
      Returns:
        interpolated value

    - #### interpolate

          public static double interpolate(Dataset d,
                                           Dataset m,
                                           double x0)

      Linearly interpolate a value at a point in a 1D dataset with a mask. The dataset is considered to have zero support outside its bounds. Thus points just outside are interpolated from the boundary value to zero.
      Parameters:
        `d` - input dataset
        `m` - mask dataset
        `x0` - coordinate
      Returns:
        interpolated value

    - #### interpolate

          public static void interpolate(double[] values,
                                         CompoundDataset d,
                                         double x0)

      Linearly interpolate an array of values at a point in a compound 1D dataset. The dataset is considered to have zero support outside its bounds. Thus points just outside are interpolated from the boundary value to zero.
      Parameters:
        `values` - interpolated array
        `d` - input dataset
        `x0` - coordinate

    - #### interpolate

          public static double interpolate(Dataset d,
                                           double x0,
                                           double x1)

      Linearly interpolate a value at a point in a 2D dataset. The dataset is considered to have zero support outside its bounds. Thus points just outside are interpolated from the boundary value to zero.
      Parameters:
        `d` - input dataset
        `x0` - coordinate
        `x1` - coordinate
      Returns:
        bilinear interpolation

    - #### interpolate

          public static double interpolate(Dataset d,
                                           Dataset m,
                                           double x0,
                                           double x1)

      Linearly interpolate a value at a point in a 2D dataset with a mask. The dataset is considered to have zero support outside its bounds. Thus points just outside are interpolated from the boundary value to zero.
      Parameters:
        `d` - input dataset
        `m` - mask dataset
        `x0` - coordinate
        `x1` - coordinate
      Returns:
        bilinear interpolation

    - #### interpolate

          public static void interpolate(double[] values,
                                         CompoundDataset d,
                                         double x0,
                                         double x1)

      Linearly interpolate an array of values at a point in a compound 2D dataset. The dataset is considered to have zero support outside its bounds. Thus points just outside are interpolated from the boundary value to zero.
      Parameters:
        `values` - bilinear interpolated array
        `d` - input dataset
        `x0` - coordinate
        `x1` - coordinate

    - #### interpolate

          public static double interpolate(Dataset d,
                                           double... x)

      Linearly interpolate a value at a point in an n-D dataset. The dataset is considered to have zero support outside its bounds. Thus points just outside are interpolated from the boundary value to zero. The number of coordinates must match the rank of the dataset.
      Parameters:
        `d` - input dataset
        `x` - coordinates
      Returns:
        interpolated value

    - #### interpolate

          public static double interpolate(Dataset d,
                                           Dataset m,
                                           double... x)

      Linearly interpolate a value at a point in an n-D dataset with a mask. The dataset is considered to have zero support outside its bounds. Thus points just outside are interpolated from the boundary value to zero. The number of coordinates must match the rank of the dataset.
      Parameters:
        `d` - input dataset
        `m` - mask dataset (can be null)
        `x` - coordinates
      Returns:
        interpolated value

    - #### interpolate

          public static void interpolate(double[] values,
                                         CompoundDataset d,
                                         double... x)

      Linearly interpolate an array of values at a point in a compound n-D dataset. The dataset is considered to have zero support outside its bounds. Thus points just outside are interpolated from the boundary value to zero.
      Parameters:
        `values` - linearly interpolated array
        `d` - input dataset
        `x` - coordinates

    - #### getLinear

          @Deprecated
          public static double getLinear(IDataset d,
                                                     double x0)

      Deprecated. Use `interpolate(Dataset, double)`
      Linearly interpolate a value at a point in a 1D dataset. The dataset is considered to have zero support outside its bounds. Thus points just outside are interpolated from the boundary value to zero.
      Parameters:
        `d` - input dataset
        `x0` - coordinate
      Returns:
        interpolated value

    - #### getLinear

          @Deprecated
          public static void getLinear(double[] values,
                                                   CompoundDataset d,
                                                   double x0)

      Deprecated. Use `interpolate(double[], CompoundDataset, double)`
      Linearly interpolate a value at a point in a compound 1D dataset. The dataset is considered to have zero support outside its bounds. Thus points just outside are interpolated from the boundary value to zero.
      Parameters:
        `values` - interpolated array
        `d` - input dataset
        `x0` - coordinate

    - #### getBilinear

          @Deprecated
          public static double getBilinear(IDataset d,
                                                       double x0,
                                                       double x1)

      Deprecated. Use `interpolate(Dataset, double, double)`
      Interpolated a value from 2D dataset
      Parameters:
        `d` - input dataset
        `x0` - coordinate
        `x1` - coordinate
      Returns:
        bilinear interpolation

    - #### getBilinear

          @Deprecated
          public static double getBilinear(IDataset d,
                                                       IDataset m,
                                                       double x0,
                                                       double x1)

      Deprecated. Use `interpolate(Dataset, Dataset, double, double)`
      Interpolated a value from 2D dataset with mask
      Parameters:
        `d` - input dataset
        `m` - mask dataset
        `x0` - coordinate
        `x1` - coordinate
      Returns:
        bilinear interpolation

    - #### getBilinear

          @Deprecated
          public static void getBilinear(double[] values,
                                                     CompoundDataset d,
                                                     double x0,
                                                     double x1)

      Deprecated. Use `interpolate(double[], CompoundDataset, double, double)`
      Interpolated a value from 2D compound dataset
      Parameters:
        `values` - bilinear interpolated array
        `d` - input dataset
        `x0` - coordinate
        `x1` - coordinate

    - #### difference

          public static Dataset difference(Dataset a,
                                           int n,
                                           int axis)

      Discrete difference of dataset along axis using finite difference
      Parameters:
        `a` - dataset
        `n` - order of difference
        `axis` - to take difference along
      Returns:
        difference

    - #### derivative

          public static Dataset derivative(Dataset x,
                                           Dataset y,
                                           int n)

      Calculates the derivative of a line described by two datasets (x,y) given a spread of n either side of the point
      Parameters:
        `x` - The x values of the function to take the derivative of.
        `y` - The y values of the function to take the derivative of.
        `n` - The spread the derivative is calculated from, i.e. the smoothing, the higher the value, the more smoothing occurs.
      Returns:
        A dataset which contains all the derivative point for point.

    - #### centralDifference

          public static Dataset centralDifference(Dataset a,
                                                  int axis)

      Discrete difference of dataset along axis using finite central difference
      Parameters:
        `a` - dataset
        `axis` - to take difference along
      Returns:
        difference

    - #### gradient

          public static List<Dataset> gradient(Dataset y,
                                               Dataset... x)

      Calculate gradient (or partial derivatives) by central difference
      Parameters:
        `y` - dataset
        `x` - one or more datasets for dependent variables
      Returns:
        a list of datasets (one for each dimension in y)

    - #### addFunctionName

          protected static void addFunctionName(Dataset a,
                                                Dataset b,
                                                Dataset dataset,
                                                String fname)

    - #### addFunctionName

          protected static void addFunctionName(Dataset dataset,
                                                String fname)

    - #### addBinaryOperatorName

          protected static void addBinaryOperatorName(Dataset a,
                                                      Dataset b,
                                                      Dataset dataset,
                                                      String oname)

    - #### toLong

          protected static final long toLong(double d)

    - #### add

          public static Dataset add(Object a,
                                    Object b)

      add operator
      Parameters:
        `a` - first operand
        `b` - second operand
      Returns:
        `a + b`, addition of a and b

    - #### add

          public static Dataset add(Object a,
                                    Object b,
                                    Dataset o)

      add operator
      Parameters:
        `a` - first operand
        `b` - second operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        `a + b`, addition of a and b

    - #### subtract

          public static Dataset subtract(Object a,
                                         Object b)

      subtract operator
      Parameters:
        `a` - first operand
        `b` - second operand
      Returns:
        `a - b`, subtraction of a by b

    - #### subtract

          public static Dataset subtract(Object a,
                                         Object b,
                                         Dataset o)

      subtract operator
      Parameters:
        `a` - first operand
        `b` - second operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        `a - b`, subtraction of a by b

    - #### multiply

          public static Dataset multiply(Object a,
                                         Object b)

      multiply operator
      Parameters:
        `a` - first operand
        `b` - second operand
      Returns:
        `a * b`, product of a and b

    - #### multiply

          public static Dataset multiply(Object a,
                                         Object b,
                                         Dataset o)

      multiply operator
      Parameters:
        `a` - first operand
        `b` - second operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        `a * b`, product of a and b

    - #### divide

          public static Dataset divide(Object a,
                                       Object b)

      divide operator
      Parameters:
        `a` - first operand
        `b` - second operand
      Returns:
        `a / b`, division of a by b

    - #### divide

          public static Dataset divide(Object a,
                                       Object b,
                                       Dataset o)

      divide operator
      Parameters:
        `a` - first operand
        `b` - second operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        `a / b`, division of a by b

    - #### dividez

          public static Dataset dividez(Object a,
                                        Object b)

      dividez operator
      Parameters:
        `a` - first operand
        `b` - second operand
      Returns:
        `a / b`, division of a by b

    - #### dividez

          public static Dataset dividez(Object a,
                                        Object b,
                                        Dataset o)

      dividez operator
      Parameters:
        `a` - first operand
        `b` - second operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        `a / b`, division of a by b

    - #### divideTowardsFloor

          public static Dataset divideTowardsFloor(Object a,
                                                   Object b)

      divideTowardsFloor operator
      Parameters:
        `a` - first operand
        `b` - second operand
      Returns:
        `a / b`, division of a by b but rounded towards negative infinity

    - #### divideTowardsFloor

          public static Dataset divideTowardsFloor(Object a,
                                                   Object b,
                                                   Dataset o)

      divideTowardsFloor operator
      Parameters:
        `a` - first operand
        `b` - second operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        `a / b`, division of a by b but rounded towards negative infinity

    - #### power

          public static Dataset power(Object a,
                                      Object b)

      power operator
      Parameters:
        `a` - first operand
        `b` - second operand
      Returns:
        `a ** b`, raise a to power of b

    - #### power

          public static Dataset power(Object a,
                                      Object b,
                                      Dataset o)

      power operator
      Parameters:
        `a` - first operand
        `b` - second operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        `a ** b`, raise a to power of b

    - #### remainder

          public static Dataset remainder(Object a,
                                          Object b)

      remainder operator
      Parameters:
        `a` - first operand
        `b` - second operand
      Returns:
        `a % b`, remainder of division of a by b

    - #### remainder

          public static Dataset remainder(Object a,
                                          Object b,
                                          Dataset o)

      remainder operator
      Parameters:
        `a` - first operand
        `b` - second operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        `a % b`, remainder of division of a by b

    - #### maximum

          public static Dataset maximum(Object a,
                                        Object b)

      maximum operator
      Parameters:
        `a` - first operand
        `b` - second operand
      Returns:
        return maximum of a and b

    - #### maximum

          public static Dataset maximum(Object a,
                                        Object b,
                                        Dataset o)

      maximum operator
      Parameters:
        `a` - first operand
        `b` - second operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        return maximum of a and b

    - #### minimum

          public static Dataset minimum(Object a,
                                        Object b)

      minimum operator
      Parameters:
        `a` - first operand
        `b` - second operand
      Returns:
        return minimum of a and b

    - #### minimum

          public static Dataset minimum(Object a,
                                        Object b,
                                        Dataset o)

      minimum operator
      Parameters:
        `a` - first operand
        `b` - second operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        return minimum of a and b

    - #### bitwiseAnd

          public static Dataset bitwiseAnd(Object a,
                                           Object b)

      bitwiseAnd operator
      Parameters:
        `a` - first operand
        `b` - second operand
      Returns:
        `a & b`, bitwise AND of a and b

    - #### bitwiseAnd

          public static Dataset bitwiseAnd(Object a,
                                           Object b,
                                           Dataset o)

      bitwiseAnd operator
      Parameters:
        `a` - first operand
        `b` - second operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        `a & b`, bitwise AND of a and b

    - #### bitwiseOr

          public static Dataset bitwiseOr(Object a,
                                          Object b)

      bitwiseOr operator
      Parameters:
        `a` - first operand
        `b` - second operand
      Returns:
        `a | b`, bitwise inclusive OR of a and b

    - #### bitwiseOr

          public static Dataset bitwiseOr(Object a,
                                          Object b,
                                          Dataset o)

      bitwiseOr operator
      Parameters:
        `a` - first operand
        `b` - second operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        `a | b`, bitwise inclusive OR of a and b

    - #### bitwiseXor

          public static Dataset bitwiseXor(Object a,
                                           Object b)

      bitwiseXor operator
      Parameters:
        `a` - first operand
        `b` - second operand
      Returns:
        `a ^ b`, bitwise exclusive OR of a and b

    - #### bitwiseXor

          public static Dataset bitwiseXor(Object a,
                                           Object b,
                                           Dataset o)

      bitwiseXor operator
      Parameters:
        `a` - first operand
        `b` - second operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        `a ^ b`, bitwise exclusive OR of a and b

    - #### leftShift

          public static Dataset leftShift(Object a,
                                          Object b)

      leftShift operator
      Parameters:
        `a` - first operand
        `b` - second operand
      Returns:
        `a << b`, bitwise left shift of a by b

    - #### leftShift

          public static Dataset leftShift(Object a,
                                          Object b,
                                          Dataset o)

      leftShift operator
      Parameters:
        `a` - first operand
        `b` - second operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        `a << b`, bitwise left shift of a by b

    - #### rightShift

          public static Dataset rightShift(Object a,
                                           Object b)

      rightShift operator
      Parameters:
        `a` - first operand
        `b` - second operand
      Returns:
        `a >> b`, bitwise right shift of a by b

    - #### rightShift

          public static Dataset rightShift(Object a,
                                           Object b,
                                           Dataset o)

      rightShift operator
      Parameters:
        `a` - first operand
        `b` - second operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        `a >> b`, bitwise right shift of a by b

    - #### unsignedRightShift

          public static Dataset unsignedRightShift(Object a,
                                                   Object b)

      unsignedRightShift operator
      Parameters:
        `a` - first operand
        `b` - second operand
      Returns:
        `a >>> b`, bitwise right shift of a by b with zeros added

    - #### unsignedRightShift

          public static Dataset unsignedRightShift(Object a,
                                                   Object b,
                                                   Dataset o)

      unsignedRightShift operator
      Parameters:
        `a` - first operand
        `b` - second operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        `a >>> b`, bitwise right shift of a by b with zeros added

    - #### bitwiseInvert

          public static Dataset bitwiseInvert(Object a)

      bitwiseInvert - `~a`, bitwise invert (or NOT) each element
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### bitwiseInvert

          public static Dataset bitwiseInvert(Object a,
                                              Dataset o)

      bitwiseInvert - `~a`, bitwise invert (or NOT) each element
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### sin

          public static Dataset sin(Object a)

      sin - evaluate the sine function on each element of the dataset
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### sin

          public static Dataset sin(Object a,
                                    Dataset o)

      sin - evaluate the sine function on each element of the dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### cos

          public static Dataset cos(Object a)

      cos - evaluate the cosine function on each element of the dataset
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### cos

          public static Dataset cos(Object a,
                                    Dataset o)

      cos - evaluate the cosine function on each element of the dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### tan

          public static Dataset tan(Object a)

      tan - evaluate the tangent function on each element of the dataset
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### tan

          public static Dataset tan(Object a,
                                    Dataset o)

      tan - evaluate the tangent function on each element of the dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### arcsin

          public static Dataset arcsin(Object a)

      arcsin - evaluate the inverse sine function on each element of the dataset
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### arcsin

          public static Dataset arcsin(Object a,
                                       Dataset o)

      arcsin - evaluate the inverse sine function on each element of the dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### arccos

          public static Dataset arccos(Object a)

      arccos - evaluate the inverse cosine function on each element of the dataset
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### arccos

          public static Dataset arccos(Object a,
                                       Dataset o)

      arccos - evaluate the inverse cosine function on each element of the dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### arctan

          public static Dataset arctan(Object a)

      arctan - evaluate the inverse tangent function on each element of the dataset
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### arctan

          public static Dataset arctan(Object a,
                                       Dataset o)

      arctan - evaluate the inverse tangent function on each element of the dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### sinh

          public static Dataset sinh(Object a)

      sinh - evaluate the hyperbolic sine function on each element of the dataset
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### sinh

          public static Dataset sinh(Object a,
                                     Dataset o)

      sinh - evaluate the hyperbolic sine function on each element of the dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### cosh

          public static Dataset cosh(Object a)

      cosh - evaluate the hyperbolic cosine function on each element of the dataset
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### cosh

          public static Dataset cosh(Object a,
                                     Dataset o)

      cosh - evaluate the hyperbolic cosine function on each element of the dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### tanh

          public static Dataset tanh(Object a)

      tanh - evaluate the tangent hyperbolic function on each element of the dataset
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### tanh

          public static Dataset tanh(Object a,
                                     Dataset o)

      tanh - evaluate the tangent hyperbolic function on each element of the dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### arcsinh

          public static Dataset arcsinh(Object a)

      arcsinh - evaluate the inverse hyperbolic sine function on each element of the dataset
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### arcsinh

          public static Dataset arcsinh(Object a,
                                        Dataset o)

      arcsinh - evaluate the inverse hyperbolic sine function on each element of the dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### arccosh

          public static Dataset arccosh(Object a)

      arccosh - evaluate the inverse hyperbolic cosine function on each element of the dataset
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### arccosh

          public static Dataset arccosh(Object a,
                                        Dataset o)

      arccosh - evaluate the inverse hyperbolic cosine function on each element of the dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### arctanh

          public static Dataset arctanh(Object a)

      arctanh - evaluate the inverse hyperbolic tangent function on each element of the dataset
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### arctanh

          public static Dataset arctanh(Object a,
                                        Dataset o)

      arctanh - evaluate the inverse hyperbolic tangent function on each element of the dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### log

          public static Dataset log(Object a)

      log - evaluate the logarithm function on each element of the dataset
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### log

          public static Dataset log(Object a,
                                    Dataset o)

      log - evaluate the logarithm function on each element of the dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### log2

          public static Dataset log2(Object a)

      log2 - evaluate the logarithm function on each element of the dataset
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### log2

          public static Dataset log2(Object a,
                                     Dataset o)

      log2 - evaluate the logarithm function on each element of the dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### log10

          public static Dataset log10(Object a)

      log10 - evaluate the logarithm function on each element of the dataset
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### log10

          public static Dataset log10(Object a,
                                      Dataset o)

      log10 - evaluate the logarithm function on each element of the dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### log1p

          public static Dataset log1p(Object a)

      log1p - evaluate the logarithm function of 1 plus on each element of the dataset
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### log1p

          public static Dataset log1p(Object a,
                                      Dataset o)

      log1p - evaluate the logarithm function of 1 plus on each element of the dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### exp

          public static Dataset exp(Object a)

      exp - evaluate the exponential function on each element of the dataset
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### exp

          public static Dataset exp(Object a,
                                    Dataset o)

      exp - evaluate the exponential function on each element of the dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### expm1

          public static Dataset expm1(Object a)

      expm1 - evaluate the exponential function - 1 on each element of the dataset
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### expm1

          public static Dataset expm1(Object a,
                                      Dataset o)

      expm1 - evaluate the exponential function - 1 on each element of the dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### sqrt

          public static Dataset sqrt(Object a)

      sqrt - evaluate the square root function on each element of the dataset
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### sqrt

          public static Dataset sqrt(Object a,
                                     Dataset o)

      sqrt - evaluate the square root function on each element of the dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### cbrt

          public static Dataset cbrt(Object a)

      cbrt - evaluate the cube root function on each element of the dataset
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### cbrt

          public static Dataset cbrt(Object a,
                                     Dataset o)

      cbrt - evaluate the cube root function on each element of the dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### square

          public static Dataset square(Object a)

      square - square each element
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### square

          public static Dataset square(Object a,
                                       Dataset o)

      square - square each element
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### floor

          public static Dataset floor(Object a)

      floor - evaluate the floor function on each element of the dataset
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### floor

          public static Dataset floor(Object a,
                                      Dataset o)

      floor - evaluate the floor function on each element of the dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### ceil

          public static Dataset ceil(Object a)

      ceil - evaluate the ceiling function on each element of the dataset
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### ceil

          public static Dataset ceil(Object a,
                                     Dataset o)

      ceil - evaluate the ceiling function on each element of the dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### rint

          public static Dataset rint(Object a)

      rint - round each element of the dataset
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### rint

          public static Dataset rint(Object a,
                                     Dataset o)

      rint - round each element of the dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### truncate

          public static Dataset truncate(Object a)

      truncate - truncate each element to integers of the dataset
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### truncate

          public static Dataset truncate(Object a,
                                         Dataset o)

      truncate - truncate each element to integers of the dataset
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### toDegrees

          public static Dataset toDegrees(Object a)

      toDegrees - convert to degrees
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### toDegrees

          public static Dataset toDegrees(Object a,
                                          Dataset o)

      toDegrees - convert to degrees
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### toRadians

          public static Dataset toRadians(Object a)

      toRadians - convert to radians
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### toRadians

          public static Dataset toRadians(Object a,
                                          Dataset o)

      toRadians - convert to radians
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### signum

          public static Dataset signum(Object a)

      signum - sign of each element
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### signum

          public static Dataset signum(Object a,
                                       Dataset o)

      signum - sign of each element
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### negative

          public static Dataset negative(Object a)

      negative - negative value of each element
      Parameters:
        `a` - single operand
      Returns:
        dataset

    - #### negative

          public static Dataset negative(Object a,
                                         Dataset o)

      negative - negative value of each element
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
      Returns:
        dataset

    - #### lowerClip

          public static Dataset lowerClip(Object a,
                                          Object pa)

      lowerClip - clip elements to lower limit
      Parameters:
        `a` - single operand
        `pa` - first parameter
      Returns:
        dataset
      Since:
        2.3

    - #### lowerClip

          public static Dataset lowerClip(Object a,
                                          Dataset o,
                                          Object pa)

      lowerClip - clip elements to lower limit
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
        `pa` - first parameter
      Returns:
        dataset
      Since:
        2.3

    - #### upperClip

          public static Dataset upperClip(Object a,
                                          Object pa)

      upperClip - clip elements to upper limit
      Parameters:
        `a` - single operand
        `pa` - first parameter
      Returns:
        dataset
      Since:
        2.3

    - #### upperClip

          public static Dataset upperClip(Object a,
                                          Dataset o,
                                          Object pa)

      upperClip - clip elements to upper limit
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
        `pa` - first parameter
      Returns:
        dataset
      Since:
        2.3

    - #### clip

          public static Dataset clip(Object a,
                                     Object pa,
                                     Object pb)

      clip - clip elements to limits
      Parameters:
        `a` - single operand
        `pa` - first parameter
        `pb` - second parameter
      Returns:
        dataset

    - #### clip

          public static Dataset clip(Object a,
                                     Dataset o,
                                     Object pa,
                                     Object pb)

      clip - clip elements to limits
      Parameters:
        `a` - single operand
        `o` - output can be null - in which case, a new dataset is created
        `pa` - first parameter
        `pb` - second parameter
      Returns:
        dataset

Copyright © 2014–2022 Eclipse Foundation. All rights reserved.