Package ucar.nc2.dt.ugrid.utils

Class AsaMath

java.lang.Object

ucar.nc2.dt.ugrid.utils.AsaMath

public class AsaMath
extends Object

Utilities for common mathematical operations.

Field Summary

Fields

Modifier and Type	Field	Description
static double	DEG_2_RAD	Constant for converting from degrees to radians;
static double	RAD_2_DEG	Constant for converting from radians to degrees

Constructor Summary

Constructors

Constructor	Description
AsaMath()

Method Summary

Modifier and Type	Method	Description
static boolean	almostEqual(double val1, double val2, double tolerance)
static boolean	almostEqual(float val1, float val2, float tolerance)
static double	averageDouble(double[] vals)	Averages the values in vals ignoring any Double.NaN values.
static double	averageDouble(double[] vals, double ignoreVal)	Averages the values in vals ignoring any ignoreVal values.
static float	averageFloat(float[] vals)	Averages the values in vals ignoring any Float.NaN values.
static float	averageFloat(float[] vals, float ignoreVal)	Averages the values in vals ignoring any ignoreVal values.
static double	calcDirection(double u, double v)	Calculates direction from U and V
static double	calcSpeed(double u, double v)	Calculates speed from U and V
static double[][]	calcSpeedDirection(double[] us, double[] vs)	Calculates speeds and directions from an array of U and V pairs.
static double[]	calcSpeedDirection(double u, double v)	Calculates both speed and direction from U and V
static float[]	calculateModes(float[] numbers, Float fillVal)	Returns the statistical mode of the given dataset denoted by numbers while ignoring entries whose values match fillVal.
static double[][]	calcUVFromSpeedDir(double[] speeds, double[] directions)	Calculates Us and Vs from arrays of speeds and directions.
static double[]	calcUVFromSpeedDir(double speed, double direction)	Calulates U and V from speed and direction
static long	getTimeInMilliseconds(double time, String units)	Calculates a time from time in the specified units.
static boolean	isNumeric(Object value)	Determines if the specified value can be parsed as a double
static double	roundDouble(double value, int precision)	Rounds value to the number of decimal points indicated by precision.
static float	roundFloat(float value, int precision)	Rounds value to the number of decimal points indicated by precision.
static double	roundToNearest(double value, double nearest, int roundDirection)	Rounds value to the closest multiple of nearest.
static boolean	sameSign(double val1, double val2)

Methods inherited from class java.lang.Object

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

Field Detail

RAD_2_DEG

public static final double RAD_2_DEG

Constant for converting from radians to degrees

See Also:

Constant Field Values

DEG_2_RAD

public static final double DEG_2_RAD

Constant for converting from degrees to radians;

See Also:

Constant Field Values

Constructor Detail

AsaMath

public AsaMath()

Method Detail

calcSpeed

public static double calcSpeed(double u,
                               double v)

Calculates speed from U and V

Parameters:

u - the u component

v - the v component

Returns:

the speed

calcDirection

public static double calcDirection(double u,
                                   double v)

Calculates direction from U and V

Parameters:

u - the u component

v - the v component

Returns:

the direction

calcSpeedDirection

public static double[] calcSpeedDirection(double u,
                                          double v)

Calculates both speed and direction from U and V

Parameters:

u - the u component

v - the v component

Returns:

a double[] where where [0]==speed and [1]==direction

calcSpeedDirection

public static double[][] calcSpeedDirection(double[] us,
                                            double[] vs)

Calculates speeds and directions from an array of U and V pairs. The arrays MUST be of the same length.

Parameters:

us - the array of u components

vs - the array of v components

Returns:

a double[][] where [0]==speed[] and [1]==direction[]

calcUVFromSpeedDir

public static double[] calcUVFromSpeedDir(double speed,
                                          double direction)

Calulates U and V from speed and direction

Parameters:

speed -

direction -

Returns:

a double[] where [0]==U and [1]==V

calcUVFromSpeedDir

public static double[][] calcUVFromSpeedDir(double[] speeds,
                                            double[] directions)

Calculates Us and Vs from arrays of speeds and directions. Arrays MUST be the same length.

Parameters:

speeds -

directions -

Returns:

a double[][] where [0]==U[] and [1]==V[]

getTimeInMilliseconds

public static long getTimeInMilliseconds(double time,
                                         String units)

Calculates a time from time in the specified units. Valid values for units are: "hour", "hours", "hrs", "hr", "minute", "minutes", "mins", or "min"

Parameters:

time - a double time in milliseconds

units - the String units to convert the given time to

Returns:

a long value representing the number of minutes or hours in time dependant on the units specified

isNumeric

public static boolean isNumeric(Object value)

Determines if the specified value can be parsed as a double

Parameters:

value - an Object to be parsed

Returns:

true if the specified object can be parsed as a double; false otherwise

roundDouble

public static double roundDouble(double value,
                                 int precision)

Rounds value to the number of decimal points indicated by precision.

Parameters:

value -

precision -

Returns:

roundFloat

public static float roundFloat(float value,
                               int precision)

Rounds value to the number of decimal points indicated by precision.

Parameters:

value -

precision -

Returns:

averageDouble

public static double averageDouble(double[] vals)

Averages the values in vals ignoring any Double.NaN values.

Parameters:

vals - the values to be averaged

Returns:

Double.NaN if vals is null or all values are Double.NaN, otherwise the average of vals

averageDouble

public static double averageDouble(double[] vals,
                                   double ignoreVal)

Averages the values in vals ignoring any ignoreVal values.

Parameters:

vals - the values to be averaged

ignoreVal - the value to ignore

Returns:

Double.NaN if vals is null or all values are ignoreVal, otherwise the average of vals

averageFloat

public static float averageFloat(float[] vals)

Averages the values in vals ignoring any Float.NaN values.

Parameters:

vals - the values to be averaged

Returns:

Float.NaN if vals is null or all values are Float.NaN, otherwise the average of vals

averageFloat

public static float averageFloat(float[] vals,
                                 float ignoreVal)

Averages the values in vals ignoring any ignoreVal values.

Parameters:

vals - the values to be averaged

ignoreVal - the value to ignore

Returns:

Float.NaN if vals is null or all values are ignoreVal, otherwise the average of vals

calculateModes

public static float[] calculateModes(float[] numbers,
                                     Float fillVal)

Returns the statistical mode of the given dataset denoted by numbers while ignoring entries whose values match fillVal. If multiple values yeild the same frequency of occurance, each of them will be returned.

Parameters:

numbers - a float array of numbers

fillVal - the "filling" value within numbers to be ignored in determining a statistical mode.

Returns:

an array of values which share the same frequency as the highest occuring value from the array numbers

roundToNearest

public static double roundToNearest(double value,
                                    double nearest,
                                    int roundDirection)

Rounds value to the closest multiple of nearest. The roundDirection parameter indicates which direction to force rounding. A '0' rounds naturally (up for values > 0.5, down for values < 0.5). A number > 0 forces a round up, while < 0 forces a round down.

Examples:

The code
double val = roundToNearest(102.536, 0.05, 1);
results in val having a value of: 102.55

The code
double val = roundToNearest(102.536, 50, -1);
results in val having a value of: 100

Parameters:

value - the input value.

nearest - the value of the nearest number to round to

roundDirection - the direction to force rounding. 0 uses natural rounding, <0 always rounds up, >0 always rounds down.

Returns:

the rounded number

almostEqual

public static boolean almostEqual(double val1,
                                  double val2,
                                  double tolerance)

almostEqual

public static boolean almostEqual(float val1,
                                  float val2,
                                  float tolerance)

sameSign

public static boolean sameSign(double val1,
                               double val2)