Package io.deephaven.libs

Class GroovyStaticImports

java.lang.Object

io.deephaven.libs.GroovyStaticImports

public class GroovyStaticImports
extends Object

Functions statically imported into Groovy.

See Also:

• io.deephaven.function

Constructor Summary

Constructors

Constructor	Description
GroovyStaticImports()

Method Summary

Modifier and Type	Method	Description
static byte	abs(byte value)
static double	abs(double value)
static float	abs(float value)
static int	abs(int value)
static long	abs(long value)
static short	abs(short value)
static double	absAvg(byte... values)
static double	absAvg(double... values)
static double	absAvg(float... values)
static double	absAvg(int... values)
static double	absAvg(long... values)
static double	absAvg(short... values)
static double	absAvg(ByteVector values)
static double	absAvg(DoubleVector values)
static double	absAvg(FloatVector values)
static double	absAvg(IntVector values)
static double	absAvg(LongVector values)
static double	absAvg(ShortVector values)
static double	absAvg(Byte[] values)
static double	absAvg(Double[] values)
static double	absAvg(Float[] values)
static double	absAvg(Integer[] values)
static double	absAvg(Long[] values)
static double	absAvg(Short[] values)
static double	acos(byte value)
static double	acos(double value)
static double	acos(float value)
static double	acos(int value)
static double	acos(long value)
static double	acos(short value)
static byte	addExact(byte x, byte y)
static int	addExact(int x, int y)
static long	addExact(long x, long y)
static short	addExact(short x, short y)
static Boolean	and(boolean... values)
static Boolean	and(ObjectVector<Boolean> values)
static Boolean	and(ObjectVector<Boolean> values, Boolean nullValue)
static Boolean	and(Boolean... values)
static Boolean	and(Boolean[] values, Boolean nullValue)
static byte[]	array(ByteVector values)
static char[]	array(CharVector values)
static double[]	array(DoubleVector values)
static float[]	array(FloatVector values)
static int[]	array(IntVector values)
static long[]	array(LongVector values)
static short[]	array(ShortVector values)
static <T> T[]	arrayObj(ObjectVector<T> values)
static double	asin(byte value)
static double	asin(double value)
static double	asin(float value)
static double	asin(int value)
static double	asin(long value)
static double	asin(short value)
static double	atan(byte value)
static double	atan(double value)
static double	atan(float value)
static double	atan(int value)
static double	atan(long value)
static double	atan(short value)
static double	atan2(byte y, byte x)
static double	atan2(double y, double x)
static double	atan2(float y, float x)
static double	atan2(int y, int x)
static double	atan2(long y, long x)
static double	atan2(short y, short x)
static double	avg(byte... values)
static double	avg(double... values)
static double	avg(float... values)
static double	avg(int... values)
static double	avg(long... values)
static double	avg(short... values)
static double	avg(ByteVector values)
static double	avg(DoubleVector values)
static double	avg(FloatVector values)
static double	avg(IntVector values)
static double	avg(LongVector values)
static double	avg(ShortVector values)
static double	avg(Byte[] values)
static double	avg(Double[] values)
static double	avg(Float[] values)
static double	avg(Integer[] values)
static double	avg(Long[] values)
static double	avg(Short[] values)
static int	binSearchIndex(byte[] values, byte key, BinSearchAlgo choiceWhenEquals)
static int	binSearchIndex(char[] values, char key, BinSearchAlgo choiceWhenEquals)
static int	binSearchIndex(double[] values, double key, BinSearchAlgo choiceWhenEquals)
static int	binSearchIndex(float[] values, float key, BinSearchAlgo choiceWhenEquals)
static int	binSearchIndex(int[] values, int key, BinSearchAlgo choiceWhenEquals)
static int	binSearchIndex(long[] values, long key, BinSearchAlgo choiceWhenEquals)
static int	binSearchIndex(short[] values, short key, BinSearchAlgo choiceWhenEquals)
static int	binSearchIndex(ByteVector values, byte key, BinSearchAlgo choiceWhenEquals)
static int	binSearchIndex(CharVector values, char key, BinSearchAlgo choiceWhenEquals)
static int	binSearchIndex(DoubleVector values, double key, BinSearchAlgo choiceWhenEquals)
static int	binSearchIndex(FloatVector values, float key, BinSearchAlgo choiceWhenEquals)
static int	binSearchIndex(IntVector values, int key, BinSearchAlgo choiceWhenEquals)
static int	binSearchIndex(LongVector values, long key, BinSearchAlgo choiceWhenEquals)
static <T extends Comparable<? super T>> int	binSearchIndex(ObjectVector<T> values, T key, BinSearchAlgo choiceWhenEquals)
static int	binSearchIndex(ShortVector values, short key, BinSearchAlgo choiceWhenEquals)
static <T extends Comparable<? super T>> int	binSearchIndex(T[] values, T key, BinSearchAlgo choiceWhenEquals)
static double	castDouble(byte value)
static double[]	castDouble(byte... values)
static double[]	castDouble(byte[] values, boolean checkFidelity)
static double	castDouble(byte value, boolean checkFidelity)
static double	castDouble(double value)
static double[]	castDouble(double... values)
static double[]	castDouble(double[] values, boolean checkFidelity)
static double	castDouble(double value, boolean checkFidelity)
static double	castDouble(float value)
static double[]	castDouble(float... values)
static double[]	castDouble(float[] values, boolean checkFidelity)
static double	castDouble(float value, boolean checkFidelity)
static double	castDouble(int value)
static double[]	castDouble(int... values)
static double[]	castDouble(int[] values, boolean checkFidelity)
static double	castDouble(int value, boolean checkFidelity)
static double	castDouble(long value)
static double[]	castDouble(long... values)
static double[]	castDouble(long[] values, boolean checkFidelity)
static double	castDouble(long value, boolean checkFidelity)
static double	castDouble(short value)
static double[]	castDouble(short... values)
static double[]	castDouble(short[] values, boolean checkFidelity)
static double	castDouble(short value, boolean checkFidelity)
static double[]	castDouble(ByteVector values)
static double[]	castDouble(ByteVector values, boolean checkFidelity)
static double[]	castDouble(DoubleVector values)
static double[]	castDouble(DoubleVector values, boolean checkFidelity)
static double[]	castDouble(FloatVector values)
static double[]	castDouble(FloatVector values, boolean checkFidelity)
static double[]	castDouble(IntVector values)
static double[]	castDouble(IntVector values, boolean checkFidelity)
static double[]	castDouble(LongVector values)
static double[]	castDouble(LongVector values, boolean checkFidelity)
static double[]	castDouble(ShortVector values)
static double[]	castDouble(ShortVector values, boolean checkFidelity)
static int	castInt(byte value)
static int[]	castInt(byte... values)
static int[]	castInt(byte[] values, boolean checkFidelity)
static int	castInt(byte value, boolean checkFidelity)
static int	castInt(int value)
static int[]	castInt(int... values)
static int[]	castInt(int[] values, boolean checkFidelity)
static int	castInt(int value, boolean checkFidelity)
static int	castInt(long value)
static int[]	castInt(long... values)
static int[]	castInt(long[] values, boolean checkFidelity)
static int	castInt(long value, boolean checkFidelity)
static int	castInt(short value)
static int[]	castInt(short... values)
static int[]	castInt(short[] values, boolean checkFidelity)
static int	castInt(short value, boolean checkFidelity)
static int[]	castInt(ByteVector values)
static int[]	castInt(ByteVector values, boolean checkFidelity)
static int[]	castInt(IntVector values)
static int[]	castInt(IntVector values, boolean checkFidelity)
static int[]	castInt(LongVector values)
static int[]	castInt(LongVector values, boolean checkFidelity)
static int[]	castInt(ShortVector values)
static int[]	castInt(ShortVector values, boolean checkFidelity)
static long	castLong(byte value)
static long[]	castLong(byte... values)
static long[]	castLong(byte[] values, boolean checkFidelity)
static long	castLong(byte value, boolean checkFidelity)
static long	castLong(int value)
static long[]	castLong(int... values)
static long[]	castLong(int[] values, boolean checkFidelity)
static long	castLong(int value, boolean checkFidelity)
static long	castLong(long value)
static long[]	castLong(long... values)
static long[]	castLong(long[] values, boolean checkFidelity)
static long	castLong(long value, boolean checkFidelity)
static long	castLong(short value)
static long[]	castLong(short... values)
static long[]	castLong(short[] values, boolean checkFidelity)
static long	castLong(short value, boolean checkFidelity)
static long[]	castLong(ByteVector values)
static long[]	castLong(ByteVector values, boolean checkFidelity)
static long[]	castLong(IntVector values)
static long[]	castLong(IntVector values, boolean checkFidelity)
static long[]	castLong(LongVector values)
static long[]	castLong(LongVector values, boolean checkFidelity)
static long[]	castLong(ShortVector values)
static long[]	castLong(ShortVector values, boolean checkFidelity)
static double	cbrt(byte x)
static double	cbrt(double x)
static double	cbrt(float x)
static double	cbrt(int x)
static double	cbrt(long x)
static double	cbrt(short x)
static double	ceil(byte value)
static double	ceil(double value)
static double	ceil(float value)
static double	ceil(int value)
static double	ceil(long value)
static double	ceil(short value)
static byte	clamp(byte value, byte min, byte max)
static double	clamp(double value, double min, double max)
static float	clamp(float value, float min, float max)
static int	clamp(int value, int min, int max)
static long	clamp(long value, long min, long max)
static short	clamp(short value, short min, short max)
static int	compare(byte v1, byte v2)
static int	compare(double v1, double v2)
static int	compare(float v1, float v2)
static int	compare(int v1, int v2)
static int	compare(long v1, long v2)
static int	compare(short v1, short v2)
static int	compare(Byte v1, Byte v2)
static int	compare(Double v1, Double v2)
static int	compare(Float v1, Float v2)
static int	compare(Integer v1, Integer v2)
static int	compare(Long v1, Long v2)
static int	compare(Short v1, Short v2)
static byte[]	concat(byte[]... values)
static char[]	concat(char[]... values)
static double[]	concat(double[]... values)
static float[]	concat(float[]... values)
static int[]	concat(int[]... values)
static long[]	concat(long[]... values)
static short[]	concat(short[]... values)
static byte[]	concat(ByteVector... values)
static char[]	concat(CharVector... values)
static double[]	concat(DoubleVector... values)
static float[]	concat(FloatVector... values)
static int[]	concat(IntVector... values)
static long[]	concat(LongVector... values)
static <T> T[]	concat(ObjectVector<T>... values)
static short[]	concat(ShortVector... values)
static <T> T[]	concat(T[]... values)
static boolean	containsNonFinite(byte... values)
static boolean	containsNonFinite(double... values)
static boolean	containsNonFinite(float... values)
static boolean	containsNonFinite(int... values)
static boolean	containsNonFinite(long... values)
static boolean	containsNonFinite(short... values)
static boolean	containsNonFinite(Byte[] values)
static boolean	containsNonFinite(Double[] values)
static boolean	containsNonFinite(Float[] values)
static boolean	containsNonFinite(Integer[] values)
static boolean	containsNonFinite(Long[] values)
static boolean	containsNonFinite(Short[] values)
static byte	copySign(byte magnitude, byte sign)
static double	copySign(double magnitude, double sign)
static float	copySign(float magnitude, float sign)
static int	copySign(int magnitude, int sign)
static long	copySign(long magnitude, long sign)
static short	copySign(short magnitude, short sign)
static double	cor(byte[] values0, byte[] values1)
static double	cor(byte[] values0, double[] values1)
static double	cor(byte[] values0, float[] values1)
static double	cor(byte[] values0, int[] values1)
static double	cor(byte[] values0, long[] values1)
static double	cor(byte[] values0, short[] values1)
static double	cor(byte[] values0, ByteVector values1)
static double	cor(byte[] values0, DoubleVector values1)
static double	cor(byte[] values0, FloatVector values1)
static double	cor(byte[] values0, IntVector values1)
static double	cor(byte[] values0, LongVector values1)
static double	cor(byte[] values0, ShortVector values1)
static double	cor(double[] values0, byte[] values1)
static double	cor(double[] values0, double[] values1)
static double	cor(double[] values0, float[] values1)
static double	cor(double[] values0, int[] values1)
static double	cor(double[] values0, long[] values1)
static double	cor(double[] values0, short[] values1)
static double	cor(double[] values0, ByteVector values1)
static double	cor(double[] values0, DoubleVector values1)
static double	cor(double[] values0, FloatVector values1)
static double	cor(double[] values0, IntVector values1)
static double	cor(double[] values0, LongVector values1)
static double	cor(double[] values0, ShortVector values1)
static double	cor(float[] values0, byte[] values1)
static double	cor(float[] values0, double[] values1)
static double	cor(float[] values0, float[] values1)
static double	cor(float[] values0, int[] values1)
static double	cor(float[] values0, long[] values1)
static double	cor(float[] values0, short[] values1)
static double	cor(float[] values0, ByteVector values1)
static double	cor(float[] values0, DoubleVector values1)
static double	cor(float[] values0, FloatVector values1)
static double	cor(float[] values0, IntVector values1)
static double	cor(float[] values0, LongVector values1)
static double	cor(float[] values0, ShortVector values1)
static double	cor(int[] values0, byte[] values1)
static double	cor(int[] values0, double[] values1)
static double	cor(int[] values0, float[] values1)
static double	cor(int[] values0, int[] values1)
static double	cor(int[] values0, long[] values1)
static double	cor(int[] values0, short[] values1)
static double	cor(int[] values0, ByteVector values1)
static double	cor(int[] values0, DoubleVector values1)
static double	cor(int[] values0, FloatVector values1)
static double	cor(int[] values0, IntVector values1)
static double	cor(int[] values0, LongVector values1)
static double	cor(int[] values0, ShortVector values1)
static double	cor(long[] values0, byte[] values1)
static double	cor(long[] values0, double[] values1)
static double	cor(long[] values0, float[] values1)
static double	cor(long[] values0, int[] values1)
static double	cor(long[] values0, long[] values1)
static double	cor(long[] values0, short[] values1)
static double	cor(long[] values0, ByteVector values1)
static double	cor(long[] values0, DoubleVector values1)
static double	cor(long[] values0, FloatVector values1)
static double	cor(long[] values0, IntVector values1)
static double	cor(long[] values0, LongVector values1)
static double	cor(long[] values0, ShortVector values1)
static double	cor(short[] values0, byte[] values1)
static double	cor(short[] values0, double[] values1)
static double	cor(short[] values0, float[] values1)
static double	cor(short[] values0, int[] values1)
static double	cor(short[] values0, long[] values1)
static double	cor(short[] values0, short[] values1)
static double	cor(short[] values0, ByteVector values1)
static double	cor(short[] values0, DoubleVector values1)
static double	cor(short[] values0, FloatVector values1)
static double	cor(short[] values0, IntVector values1)
static double	cor(short[] values0, LongVector values1)
static double	cor(short[] values0, ShortVector values1)
static double	cor(ByteVector values0, byte[] values1)
static double	cor(ByteVector values0, double[] values1)
static double	cor(ByteVector values0, float[] values1)
static double	cor(ByteVector values0, int[] values1)
static double	cor(ByteVector values0, long[] values1)
static double	cor(ByteVector values0, short[] values1)
static double	cor(ByteVector values0, ByteVector values1)
static double	cor(ByteVector values0, DoubleVector values1)
static double	cor(ByteVector values0, FloatVector values1)
static double	cor(ByteVector values0, IntVector values1)
static double	cor(ByteVector values0, LongVector values1)
static double	cor(ByteVector values0, ShortVector values1)
static double	cor(DoubleVector values0, byte[] values1)
static double	cor(DoubleVector values0, double[] values1)
static double	cor(DoubleVector values0, float[] values1)
static double	cor(DoubleVector values0, int[] values1)
static double	cor(DoubleVector values0, long[] values1)
static double	cor(DoubleVector values0, short[] values1)
static double	cor(DoubleVector values0, ByteVector values1)
static double	cor(DoubleVector values0, DoubleVector values1)
static double	cor(DoubleVector values0, FloatVector values1)
static double	cor(DoubleVector values0, IntVector values1)
static double	cor(DoubleVector values0, LongVector values1)
static double	cor(DoubleVector values0, ShortVector values1)
static double	cor(FloatVector values0, byte[] values1)
static double	cor(FloatVector values0, double[] values1)
static double	cor(FloatVector values0, float[] values1)
static double	cor(FloatVector values0, int[] values1)
static double	cor(FloatVector values0, long[] values1)
static double	cor(FloatVector values0, short[] values1)
static double	cor(FloatVector values0, ByteVector values1)
static double	cor(FloatVector values0, DoubleVector values1)
static double	cor(FloatVector values0, FloatVector values1)
static double	cor(FloatVector values0, IntVector values1)
static double	cor(FloatVector values0, LongVector values1)
static double	cor(FloatVector values0, ShortVector values1)
static double	cor(IntVector values0, byte[] values1)
static double	cor(IntVector values0, double[] values1)
static double	cor(IntVector values0, float[] values1)
static double	cor(IntVector values0, int[] values1)
static double	cor(IntVector values0, long[] values1)
static double	cor(IntVector values0, short[] values1)
static double	cor(IntVector values0, ByteVector values1)
static double	cor(IntVector values0, DoubleVector values1)
static double	cor(IntVector values0, FloatVector values1)
static double	cor(IntVector values0, IntVector values1)
static double	cor(IntVector values0, LongVector values1)
static double	cor(IntVector values0, ShortVector values1)
static double	cor(LongVector values0, byte[] values1)
static double	cor(LongVector values0, double[] values1)
static double	cor(LongVector values0, float[] values1)
static double	cor(LongVector values0, int[] values1)
static double	cor(LongVector values0, long[] values1)
static double	cor(LongVector values0, short[] values1)
static double	cor(LongVector values0, ByteVector values1)
static double	cor(LongVector values0, DoubleVector values1)
static double	cor(LongVector values0, FloatVector values1)
static double	cor(LongVector values0, IntVector values1)
static double	cor(LongVector values0, LongVector values1)
static double	cor(LongVector values0, ShortVector values1)
static double	cor(ShortVector values0, byte[] values1)
static double	cor(ShortVector values0, double[] values1)
static double	cor(ShortVector values0, float[] values1)
static double	cor(ShortVector values0, int[] values1)
static double	cor(ShortVector values0, long[] values1)
static double	cor(ShortVector values0, short[] values1)
static double	cor(ShortVector values0, ByteVector values1)
static double	cor(ShortVector values0, DoubleVector values1)
static double	cor(ShortVector values0, FloatVector values1)
static double	cor(ShortVector values0, IntVector values1)
static double	cor(ShortVector values0, LongVector values1)
static double	cor(ShortVector values0, ShortVector values1)
static double	cos(byte value)
static double	cos(double value)
static double	cos(float value)
static double	cos(int value)
static double	cos(long value)
static double	cos(short value)
static double	cosh(byte x)
static double	cosh(double x)
static double	cosh(float x)
static double	cosh(int x)
static double	cosh(long x)
static double	cosh(short x)
static long	count(byte... values)
static long	count(char... values)
static long	count(double... values)
static long	count(float... values)
static long	count(int... values)
static long	count(long... values)
static long	count(short... values)
static long	count(ByteVector values)
static long	count(CharVector values)
static long	count(DoubleVector values)
static long	count(FloatVector values)
static long	count(IntVector values)
static long	count(LongVector values)
static long	count(ShortVector values)
static long	countDistinct(byte... values)
static long	countDistinct(byte[] values, boolean countNull)
static long	countDistinct(char... values)
static long	countDistinct(char[] values, boolean countNull)
static long	countDistinct(double... values)
static long	countDistinct(double[] values, boolean countNull)
static long	countDistinct(float... values)
static long	countDistinct(float[] values, boolean countNull)
static long	countDistinct(int... values)
static long	countDistinct(int[] values, boolean countNull)
static long	countDistinct(long... values)
static long	countDistinct(long[] values, boolean countNull)
static long	countDistinct(short... values)
static long	countDistinct(short[] values, boolean countNull)
static long	countDistinct(ByteVector values)
static long	countDistinct(ByteVector values, boolean countNull)
static long	countDistinct(CharVector values)
static long	countDistinct(CharVector values, boolean countNull)
static long	countDistinct(DoubleVector values)
static long	countDistinct(DoubleVector values, boolean countNull)
static long	countDistinct(FloatVector values)
static long	countDistinct(FloatVector values, boolean countNull)
static long	countDistinct(IntVector values)
static long	countDistinct(IntVector values, boolean countNull)
static long	countDistinct(LongVector values)
static long	countDistinct(LongVector values, boolean countNull)
static long	countDistinct(ShortVector values)
static long	countDistinct(ShortVector values, boolean countNull)
static <T extends Comparable<? super T>> long	countDistinctObj(ObjectVector<T> values)
static <T extends Comparable<? super T>> long	countDistinctObj(ObjectVector<T> values, boolean countNull)
static <T extends Comparable<? super T>> long	countDistinctObj(T... values)
static <T extends Comparable<? super T>> long	countDistinctObj(T[] values, boolean countNull)
static long	countNeg(byte... values)
static long	countNeg(double... values)
static long	countNeg(float... values)
static long	countNeg(int... values)
static long	countNeg(long... values)
static long	countNeg(short... values)
static long	countNeg(ByteVector values)
static long	countNeg(DoubleVector values)
static long	countNeg(FloatVector values)
static long	countNeg(IntVector values)
static long	countNeg(LongVector values)
static long	countNeg(ShortVector values)
static long	countNeg(Byte[] values)
static long	countNeg(Double[] values)
static long	countNeg(Float[] values)
static long	countNeg(Integer[] values)
static long	countNeg(Long[] values)
static long	countNeg(Short[] values)
static <T> long	countObj(ObjectVector<T> values)
static <T> long	countObj(T... values)
static long	countPos(byte... values)
static long	countPos(double... values)
static long	countPos(float... values)
static long	countPos(int... values)
static long	countPos(long... values)
static long	countPos(short... values)
static long	countPos(ByteVector values)
static long	countPos(DoubleVector values)
static long	countPos(FloatVector values)
static long	countPos(IntVector values)
static long	countPos(LongVector values)
static long	countPos(ShortVector values)
static long	countPos(Byte[] values)
static long	countPos(Double[] values)
static long	countPos(Float[] values)
static long	countPos(Integer[] values)
static long	countPos(Long[] values)
static long	countPos(Short[] values)
static long	countZero(byte... values)
static long	countZero(double... values)
static long	countZero(float... values)
static long	countZero(int... values)
static long	countZero(long... values)
static long	countZero(short... values)
static long	countZero(ByteVector values)
static long	countZero(DoubleVector values)
static long	countZero(FloatVector values)
static long	countZero(IntVector values)
static long	countZero(LongVector values)
static long	countZero(ShortVector values)
static long	countZero(Byte[] values)
static long	countZero(Double[] values)
static long	countZero(Float[] values)
static long	countZero(Integer[] values)
static long	countZero(Long[] values)
static long	countZero(Short[] values)
static double	cov(byte[] values0, byte[] values1)
static double	cov(byte[] values0, double[] values1)
static double	cov(byte[] values0, float[] values1)
static double	cov(byte[] values0, int[] values1)
static double	cov(byte[] values0, long[] values1)
static double	cov(byte[] values0, short[] values1)
static double	cov(byte[] values0, ByteVector values1)
static double	cov(byte[] values0, DoubleVector values1)
static double	cov(byte[] values0, FloatVector values1)
static double	cov(byte[] values0, IntVector values1)
static double	cov(byte[] values0, LongVector values1)
static double	cov(byte[] values0, ShortVector values1)
static double	cov(double[] values0, byte[] values1)
static double	cov(double[] values0, double[] values1)
static double	cov(double[] values0, float[] values1)
static double	cov(double[] values0, int[] values1)
static double	cov(double[] values0, long[] values1)
static double	cov(double[] values0, short[] values1)
static double	cov(double[] values0, ByteVector values1)
static double	cov(double[] values0, DoubleVector values1)
static double	cov(double[] values0, FloatVector values1)
static double	cov(double[] values0, IntVector values1)
static double	cov(double[] values0, LongVector values1)
static double	cov(double[] values0, ShortVector values1)
static double	cov(float[] values0, byte[] values1)
static double	cov(float[] values0, double[] values1)
static double	cov(float[] values0, float[] values1)
static double	cov(float[] values0, int[] values1)
static double	cov(float[] values0, long[] values1)
static double	cov(float[] values0, short[] values1)
static double	cov(float[] values0, ByteVector values1)
static double	cov(float[] values0, DoubleVector values1)
static double	cov(float[] values0, FloatVector values1)
static double	cov(float[] values0, IntVector values1)
static double	cov(float[] values0, LongVector values1)
static double	cov(float[] values0, ShortVector values1)
static double	cov(int[] values0, byte[] values1)
static double	cov(int[] values0, double[] values1)
static double	cov(int[] values0, float[] values1)
static double	cov(int[] values0, int[] values1)
static double	cov(int[] values0, long[] values1)
static double	cov(int[] values0, short[] values1)
static double	cov(int[] values0, ByteVector values1)
static double	cov(int[] values0, DoubleVector values1)
static double	cov(int[] values0, FloatVector values1)
static double	cov(int[] values0, IntVector values1)
static double	cov(int[] values0, LongVector values1)
static double	cov(int[] values0, ShortVector values1)
static double	cov(long[] values0, byte[] values1)
static double	cov(long[] values0, double[] values1)
static double	cov(long[] values0, float[] values1)
static double	cov(long[] values0, int[] values1)
static double	cov(long[] values0, long[] values1)
static double	cov(long[] values0, short[] values1)
static double	cov(long[] values0, ByteVector values1)
static double	cov(long[] values0, DoubleVector values1)
static double	cov(long[] values0, FloatVector values1)
static double	cov(long[] values0, IntVector values1)
static double	cov(long[] values0, LongVector values1)
static double	cov(long[] values0, ShortVector values1)
static double	cov(short[] values0, byte[] values1)
static double	cov(short[] values0, double[] values1)
static double	cov(short[] values0, float[] values1)
static double	cov(short[] values0, int[] values1)
static double	cov(short[] values0, long[] values1)
static double	cov(short[] values0, short[] values1)
static double	cov(short[] values0, ByteVector values1)
static double	cov(short[] values0, DoubleVector values1)
static double	cov(short[] values0, FloatVector values1)
static double	cov(short[] values0, IntVector values1)
static double	cov(short[] values0, LongVector values1)
static double	cov(short[] values0, ShortVector values1)
static double	cov(ByteVector values0, byte[] values1)
static double	cov(ByteVector values0, double[] values1)
static double	cov(ByteVector values0, float[] values1)
static double	cov(ByteVector values0, int[] values1)
static double	cov(ByteVector values0, long[] values1)
static double	cov(ByteVector values0, short[] values1)
static double	cov(ByteVector values0, ByteVector values1)
static double	cov(ByteVector values0, DoubleVector values1)
static double	cov(ByteVector values0, FloatVector values1)
static double	cov(ByteVector values0, IntVector values1)
static double	cov(ByteVector values0, LongVector values1)
static double	cov(ByteVector values0, ShortVector values1)
static double	cov(DoubleVector values0, byte[] values1)
static double	cov(DoubleVector values0, double[] values1)
static double	cov(DoubleVector values0, float[] values1)
static double	cov(DoubleVector values0, int[] values1)
static double	cov(DoubleVector values0, long[] values1)
static double	cov(DoubleVector values0, short[] values1)
static double	cov(DoubleVector values0, ByteVector values1)
static double	cov(DoubleVector values0, DoubleVector values1)
static double	cov(DoubleVector values0, FloatVector values1)
static double	cov(DoubleVector values0, IntVector values1)
static double	cov(DoubleVector values0, LongVector values1)
static double	cov(DoubleVector values0, ShortVector values1)
static double	cov(FloatVector values0, byte[] values1)
static double	cov(FloatVector values0, double[] values1)
static double	cov(FloatVector values0, float[] values1)
static double	cov(FloatVector values0, int[] values1)
static double	cov(FloatVector values0, long[] values1)
static double	cov(FloatVector values0, short[] values1)
static double	cov(FloatVector values0, ByteVector values1)
static double	cov(FloatVector values0, DoubleVector values1)
static double	cov(FloatVector values0, FloatVector values1)
static double	cov(FloatVector values0, IntVector values1)
static double	cov(FloatVector values0, LongVector values1)
static double	cov(FloatVector values0, ShortVector values1)
static double	cov(IntVector values0, byte[] values1)
static double	cov(IntVector values0, double[] values1)
static double	cov(IntVector values0, float[] values1)
static double	cov(IntVector values0, int[] values1)
static double	cov(IntVector values0, long[] values1)
static double	cov(IntVector values0, short[] values1)
static double	cov(IntVector values0, ByteVector values1)
static double	cov(IntVector values0, DoubleVector values1)
static double	cov(IntVector values0, FloatVector values1)
static double	cov(IntVector values0, IntVector values1)
static double	cov(IntVector values0, LongVector values1)
static double	cov(IntVector values0, ShortVector values1)
static double	cov(LongVector values0, byte[] values1)
static double	cov(LongVector values0, double[] values1)
static double	cov(LongVector values0, float[] values1)
static double	cov(LongVector values0, int[] values1)
static double	cov(LongVector values0, long[] values1)
static double	cov(LongVector values0, short[] values1)
static double	cov(LongVector values0, ByteVector values1)
static double	cov(LongVector values0, DoubleVector values1)
static double	cov(LongVector values0, FloatVector values1)
static double	cov(LongVector values0, IntVector values1)
static double	cov(LongVector values0, LongVector values1)
static double	cov(LongVector values0, ShortVector values1)
static double	cov(ShortVector values0, byte[] values1)
static double	cov(ShortVector values0, double[] values1)
static double	cov(ShortVector values0, float[] values1)
static double	cov(ShortVector values0, int[] values1)
static double	cov(ShortVector values0, long[] values1)
static double	cov(ShortVector values0, short[] values1)
static double	cov(ShortVector values0, ByteVector values1)
static double	cov(ShortVector values0, DoubleVector values1)
static double	cov(ShortVector values0, FloatVector values1)
static double	cov(ShortVector values0, IntVector values1)
static double	cov(ShortVector values0, LongVector values1)
static double	cov(ShortVector values0, ShortVector values1)
static byte[]	cummax(byte... values)
static double[]	cummax(double... values)
static float[]	cummax(float... values)
static int[]	cummax(int... values)
static long[]	cummax(long... values)
static short[]	cummax(short... values)
static byte[]	cummax(ByteVector values)
static double[]	cummax(DoubleVector values)
static float[]	cummax(FloatVector values)
static int[]	cummax(IntVector values)
static long[]	cummax(LongVector values)
static short[]	cummax(ShortVector values)
static byte[]	cummax(Byte[] values)
static double[]	cummax(Double[] values)
static float[]	cummax(Float[] values)
static int[]	cummax(Integer[] values)
static long[]	cummax(Long[] values)
static short[]	cummax(Short[] values)
static byte[]	cummin(byte... values)
static double[]	cummin(double... values)
static float[]	cummin(float... values)
static int[]	cummin(int... values)
static long[]	cummin(long... values)
static short[]	cummin(short... values)
static byte[]	cummin(ByteVector values)
static double[]	cummin(DoubleVector values)
static float[]	cummin(FloatVector values)
static int[]	cummin(IntVector values)
static long[]	cummin(LongVector values)
static short[]	cummin(ShortVector values)
static byte[]	cummin(Byte[] values)
static double[]	cummin(Double[] values)
static float[]	cummin(Float[] values)
static int[]	cummin(Integer[] values)
static long[]	cummin(Long[] values)
static short[]	cummin(Short[] values)
static long[]	cumprod(byte... values)
static double[]	cumprod(double... values)
static double[]	cumprod(float... values)
static long[]	cumprod(int... values)
static long[]	cumprod(long... values)
static long[]	cumprod(short... values)
static long[]	cumprod(ByteVector values)
static double[]	cumprod(DoubleVector values)
static double[]	cumprod(FloatVector values)
static long[]	cumprod(IntVector values)
static long[]	cumprod(LongVector values)
static long[]	cumprod(ShortVector values)
static long[]	cumprod(Byte[] values)
static double[]	cumprod(Double[] values)
static double[]	cumprod(Float[] values)
static long[]	cumprod(Integer[] values)
static long[]	cumprod(Long[] values)
static long[]	cumprod(Short[] values)
static long[]	cumsum(byte... values)
static double[]	cumsum(double... values)
static double[]	cumsum(float... values)
static long[]	cumsum(int... values)
static long[]	cumsum(long... values)
static long[]	cumsum(short... values)
static long[]	cumsum(ByteVector values)
static double[]	cumsum(DoubleVector values)
static double[]	cumsum(FloatVector values)
static long[]	cumsum(IntVector values)
static long[]	cumsum(LongVector values)
static long[]	cumsum(ShortVector values)
static long[]	cumsum(Byte[] values)
static double[]	cumsum(Double[] values)
static double[]	cumsum(Float[] values)
static long[]	cumsum(Integer[] values)
static long[]	cumsum(Long[] values)
static long[]	cumsum(Short[] values)
static byte	decrementExact(byte x)
static int	decrementExact(int x)
static long	decrementExact(long x)
static short	decrementExact(short x)
static byte[]	diff(int stride, byte... values)
static double[]	diff(int stride, double... values)
static float[]	diff(int stride, float... values)
static int[]	diff(int stride, int... values)
static long[]	diff(int stride, long... values)
static short[]	diff(int stride, short... values)
static byte[]	diff(int stride, ByteVector values)
static double[]	diff(int stride, DoubleVector values)
static float[]	diff(int stride, FloatVector values)
static int[]	diff(int stride, IntVector values)
static long[]	diff(int stride, LongVector values)
static short[]	diff(int stride, ShortVector values)
static byte[]	diff(int stride, Byte[] values)
static double[]	diff(int stride, Double[] values)
static float[]	diff(int stride, Float[] values)
static int[]	diff(int stride, Integer[] values)
static long[]	diff(int stride, Long[] values)
static short[]	diff(int stride, Short[] values)
static byte[]	distinct(byte... values)
static byte[]	distinct(byte[] values, boolean includeNull)
static char[]	distinct(char... values)
static char[]	distinct(char[] values, boolean includeNull)
static double[]	distinct(double... values)
static double[]	distinct(double[] values, boolean includeNull)
static float[]	distinct(float... values)
static float[]	distinct(float[] values, boolean includeNull)
static int[]	distinct(int... values)
static int[]	distinct(int[] values, boolean includeNull)
static long[]	distinct(long... values)
static long[]	distinct(long[] values, boolean includeNull)
static short[]	distinct(short... values)
static short[]	distinct(short[] values, boolean includeNull)
static byte[]	distinct(ByteVector values)
static byte[]	distinct(ByteVector values, boolean includeNull)
static char[]	distinct(CharVector values)
static char[]	distinct(CharVector values, boolean includeNull)
static double[]	distinct(DoubleVector values)
static double[]	distinct(DoubleVector values, boolean includeNull)
static float[]	distinct(FloatVector values)
static float[]	distinct(FloatVector values, boolean includeNull)
static int[]	distinct(IntVector values)
static int[]	distinct(IntVector values, boolean includeNull)
static long[]	distinct(LongVector values)
static long[]	distinct(LongVector values, boolean includeNull)
static short[]	distinct(ShortVector values)
static short[]	distinct(ShortVector values, boolean includeNull)
static <T extends Comparable<? super T>> T[]	distinctObj(ObjectVector<T> values)
static <T extends Comparable<? super T>> T[]	distinctObj(ObjectVector<T> values, boolean includeNull)
static <T extends Comparable<? super T>> T[]	distinctObj(T... values)
static <T extends Comparable<? super T>> T[]	distinctObj(T[] values, boolean includeNull)
static byte[]	enlist(byte... values)
static char[]	enlist(char... values)
static double[]	enlist(double... values)
static float[]	enlist(float... values)
static int[]	enlist(int... values)
static long[]	enlist(long... values)
static short[]	enlist(short... values)
static double	exp(byte value)
static double	exp(double value)
static double	exp(float value)
static double	exp(int value)
static double	exp(long value)
static double	exp(short value)
static double	expm1(byte x)
static double	expm1(double x)
static double	expm1(float x)
static double	expm1(int x)
static double	expm1(long x)
static double	expm1(short x)
static byte	first(byte... values)
static char	first(char... values)
static double	first(double... values)
static float	first(float... values)
static int	first(int... values)
static long	first(long... values)
static short	first(short... values)
static byte	first(ByteVector values)
static char	first(CharVector values)
static double	first(DoubleVector values)
static float	first(FloatVector values)
static int	first(IntVector values)
static long	first(LongVector values)
static short	first(ShortVector values)
static long	firstIndexOf(byte val, byte... values)
static long	firstIndexOf(byte val, ByteVector values)
static long	firstIndexOf(char val, char... values)
static long	firstIndexOf(char val, CharVector values)
static long	firstIndexOf(double val, double... values)
static long	firstIndexOf(double val, DoubleVector values)
static long	firstIndexOf(float val, float... values)
static long	firstIndexOf(float val, FloatVector values)
static long	firstIndexOf(int val, int... values)
static long	firstIndexOf(int val, IntVector values)
static long	firstIndexOf(long val, long... values)
static long	firstIndexOf(long val, LongVector values)
static long	firstIndexOf(short val, short... values)
static long	firstIndexOf(short val, ShortVector values)
static <T> long	firstIndexOfObj(T val, ObjectVector<T> values)
static <T> long	firstIndexOfObj(T val, T... values)
static <T> T	firstObj(ObjectVector<T> values)
static <T> T	firstObj(T... values)
static double	floor(byte value)
static double	floor(double value)
static double	floor(float value)
static double	floor(int value)
static double	floor(long value)
static double	floor(short value)
static byte	floorDiv(byte x, byte y)
static int	floorDiv(int x, int y)
static long	floorDiv(long x, long y)
static short	floorDiv(short x, short y)
static byte	floorMod(byte x, byte y)
static int	floorMod(int x, int y)
static long	floorMod(long x, long y)
static short	floorMod(short x, short y)
static byte[]	forwardFill(byte... values)
static char[]	forwardFill(char... values)
static double[]	forwardFill(double... values)
static float[]	forwardFill(float... values)
static int[]	forwardFill(int... values)
static long[]	forwardFill(long... values)
static short[]	forwardFill(short... values)
static byte[]	forwardFill(ByteVector values)
static char[]	forwardFill(CharVector values)
static double[]	forwardFill(DoubleVector values)
static float[]	forwardFill(FloatVector values)
static int[]	forwardFill(IntVector values)
static long[]	forwardFill(LongVector values)
static short[]	forwardFill(ShortVector values)
static <T> T[]	forwardFillObj(ObjectVector<T> values)
static <T> T[]	forwardFillObj(T... values)
static int	getExponent(double x)
static int	getExponent(float x)
static double	hypot(byte x, byte y)
static double	hypot(double x, double y)
static double	hypot(float x, float y)
static double	hypot(int x, int y)
static double	hypot(long x, long y)
static double	hypot(short x, short y)
static double	IEEEremainder(double x, double y)
static float	IEEEremainder(float x, float y)
static byte[]	ifelse(ObjectVector<Boolean> condition, byte trueCase, byte falseCase)
static char[]	ifelse(ObjectVector<Boolean> condition, char trueCase, char falseCase)
static double[]	ifelse(ObjectVector<Boolean> condition, double trueCase, double falseCase)
static float[]	ifelse(ObjectVector<Boolean> condition, float trueCase, float falseCase)
static int[]	ifelse(ObjectVector<Boolean> condition, int trueCase, int falseCase)
static long[]	ifelse(ObjectVector<Boolean> condition, long trueCase, long falseCase)
static short[]	ifelse(ObjectVector<Boolean> condition, short trueCase, short falseCase)
static byte[]	ifelse(ObjectVector<Boolean> condition, ByteVector trueCase, ByteVector falseCase)
static char[]	ifelse(ObjectVector<Boolean> condition, CharVector trueCase, CharVector falseCase)
static double[]	ifelse(ObjectVector<Boolean> condition, DoubleVector trueCase, DoubleVector falseCase)
static float[]	ifelse(ObjectVector<Boolean> condition, FloatVector trueCase, FloatVector falseCase)
static int[]	ifelse(ObjectVector<Boolean> condition, IntVector trueCase, IntVector falseCase)
static long[]	ifelse(ObjectVector<Boolean> condition, LongVector trueCase, LongVector falseCase)
static short[]	ifelse(ObjectVector<Boolean> condition, ShortVector trueCase, ShortVector falseCase)
static byte[]	ifelse(Boolean[] condition, byte[] trueCase, byte[] falseCase)
static byte[]	ifelse(Boolean[] condition, byte trueCase, byte falseCase)
static char[]	ifelse(Boolean[] condition, char[] trueCase, char[] falseCase)
static char[]	ifelse(Boolean[] condition, char trueCase, char falseCase)
static double[]	ifelse(Boolean[] condition, double[] trueCase, double[] falseCase)
static double[]	ifelse(Boolean[] condition, double trueCase, double falseCase)
static float[]	ifelse(Boolean[] condition, float[] trueCase, float[] falseCase)
static float[]	ifelse(Boolean[] condition, float trueCase, float falseCase)
static int[]	ifelse(Boolean[] condition, int[] trueCase, int[] falseCase)
static int[]	ifelse(Boolean[] condition, int trueCase, int falseCase)
static long[]	ifelse(Boolean[] condition, long[] trueCase, long[] falseCase)
static long[]	ifelse(Boolean[] condition, long trueCase, long falseCase)
static short[]	ifelse(Boolean[] condition, short[] trueCase, short[] falseCase)
static short[]	ifelse(Boolean[] condition, short trueCase, short falseCase)
static byte	ifelse(Boolean condition, byte trueCase, byte falseCase)
static char	ifelse(Boolean condition, char trueCase, char falseCase)
static double	ifelse(Boolean condition, double trueCase, double falseCase)
static float	ifelse(Boolean condition, float trueCase, float falseCase)
static int	ifelse(Boolean condition, int trueCase, int falseCase)
static long	ifelse(Boolean condition, long trueCase, long falseCase)
static short	ifelse(Boolean condition, short trueCase, short falseCase)
static <T> T[]	ifelseObj(ObjectVector<Boolean> condition, ObjectVector<T> trueCase, ObjectVector<T> falseCase)
static <T> T[]	ifelseObj(ObjectVector<Boolean> condition, T trueCase, T falseCase)
static <T> T[]	ifelseObj(Boolean[] condition, T[] trueCase, T[] falseCase)
static <T> T[]	ifelseObj(Boolean[] condition, T trueCase, T falseCase)
static <T> T	ifelseObj(Boolean condition, T trueCase, T falseCase)
static boolean	in(byte testedValues, byte... possibleValues)
static boolean	in(char testedValues, char... possibleValues)
static boolean	in(double testedValues, double... possibleValues)
static boolean	in(float testedValues, float... possibleValues)
static boolean	in(int testedValues, int... possibleValues)
static boolean	in(long testedValues, long... possibleValues)
static boolean	in(short testedValues, short... possibleValues)
static byte	incrementExact(byte x)
static int	incrementExact(int x)
static long	incrementExact(long x)
static short	incrementExact(short x)
static long	indexOfMax(byte... values)
static long	indexOfMax(double... values)
static long	indexOfMax(float... values)
static long	indexOfMax(int... values)
static long	indexOfMax(long... values)
static long	indexOfMax(short... values)
static long	indexOfMax(ByteVector values)
static long	indexOfMax(DoubleVector values)
static long	indexOfMax(FloatVector values)
static long	indexOfMax(IntVector values)
static long	indexOfMax(LongVector values)
static long	indexOfMax(ShortVector values)
static long	indexOfMax(Byte[] values)
static long	indexOfMax(Double[] values)
static long	indexOfMax(Float[] values)
static long	indexOfMax(Integer[] values)
static long	indexOfMax(Long[] values)
static long	indexOfMax(Short[] values)
static <T extends Comparable<T>> long	indexOfMaxObj(ObjectVector<T> values)
static <T extends Comparable<T>> long	indexOfMaxObj(T... values)
static long	indexOfMin(byte... values)
static long	indexOfMin(double... values)
static long	indexOfMin(float... values)
static long	indexOfMin(int... values)
static long	indexOfMin(long... values)
static long	indexOfMin(short... values)
static long	indexOfMin(ByteVector values)
static long	indexOfMin(DoubleVector values)
static long	indexOfMin(FloatVector values)
static long	indexOfMin(IntVector values)
static long	indexOfMin(LongVector values)
static long	indexOfMin(ShortVector values)
static long	indexOfMin(Byte[] values)
static long	indexOfMin(Double[] values)
static long	indexOfMin(Float[] values)
static long	indexOfMin(Integer[] values)
static long	indexOfMin(Long[] values)
static long	indexOfMin(Short[] values)
static <T extends Comparable<T>> long	indexOfMinObj(ObjectVector<T> values)
static <T extends Comparable<T>> long	indexOfMinObj(T... values)
static <T> boolean	inObj(T testedValue, ObjectVector<T> possibleValues)
static <T> boolean	inObj(T testedValue, T... possibleValues)
static boolean	inRange(byte testedValue, byte lowInclusiveValue, byte highInclusiveValue)
static boolean	inRange(char testedValue, char lowInclusiveValue, char highInclusiveValue)
static boolean	inRange(double testedValue, double lowInclusiveValue, double highInclusiveValue)
static boolean	inRange(float testedValue, float lowInclusiveValue, float highInclusiveValue)
static boolean	inRange(int testedValue, int lowInclusiveValue, int highInclusiveValue)
static boolean	inRange(long testedValue, long lowInclusiveValue, long highInclusiveValue)
static boolean	inRange(short testedValue, short lowInclusiveValue, short highInclusiveValue)
static <T extends Comparable<? super T>> boolean	inRange(T testedValue, T lowInclusiveValue, T highInclusiveValue)
static boolean	isFinite(byte value)
static boolean	isFinite(double value)
static boolean	isFinite(float value)
static boolean	isFinite(int value)
static boolean	isFinite(long value)
static boolean	isFinite(short value)
static boolean	isFinite(Byte value)
static boolean	isFinite(Double value)
static boolean	isFinite(Float value)
static boolean	isFinite(Integer value)
static boolean	isFinite(Long value)
static boolean	isFinite(Short value)
static boolean	isInf(byte value)
static boolean	isInf(double value)
static boolean	isInf(float value)
static boolean	isInf(int value)
static boolean	isInf(long value)
static boolean	isInf(short value)
static boolean	isInf(Byte value)
static boolean	isInf(Double value)
static boolean	isInf(Float value)
static boolean	isInf(Integer value)
static boolean	isInf(Long value)
static boolean	isInf(Short value)
static boolean	isNaN(byte value)
static boolean	isNaN(double value)
static boolean	isNaN(float value)
static boolean	isNaN(int value)
static boolean	isNaN(long value)
static boolean	isNaN(short value)
static boolean	isNaN(Byte value)
static boolean	isNaN(Double value)
static boolean	isNaN(Float value)
static boolean	isNaN(Integer value)
static boolean	isNaN(Long value)
static boolean	isNaN(Short value)
static boolean	isNull(byte value)
static boolean	isNull(char value)
static boolean	isNull(double value)
static boolean	isNull(float value)
static boolean	isNull(int value)
static boolean	isNull(long value)
static boolean	isNull(short value)
static <T> boolean	isNull(T value)
static byte	last(byte... values)
static char	last(char... values)
static double	last(double... values)
static float	last(float... values)
static int	last(int... values)
static long	last(long... values)
static short	last(short... values)
static byte	last(ByteVector values)
static char	last(CharVector values)
static double	last(DoubleVector values)
static float	last(FloatVector values)
static int	last(IntVector values)
static long	last(LongVector values)
static short	last(ShortVector values)
static <T> T	lastObj(ObjectVector<T> values)
static <T> T	lastObj(T... values)
static long	len(byte[] values)
static long	len(char[] values)
static long	len(double[] values)
static long	len(float[] values)
static long	len(int[] values)
static long	len(long[] values)
static long	len(short[] values)
static long	len(LongSizedDataStructure values)
static <T> long	len(T[] values)
static double	log(byte value)
static double	log(double value)
static double	log(float value)
static double	log(int value)
static double	log(long value)
static double	log(short value)
static double	log10(byte x)
static double	log10(double x)
static double	log10(float x)
static double	log10(int x)
static double	log10(long x)
static double	log10(short x)
static double	log1p(byte x)
static double	log1p(double x)
static double	log1p(float x)
static double	log1p(int x)
static double	log1p(long x)
static double	log1p(short x)
static byte	lowerBin(byte value, byte interval)
static byte	lowerBin(byte value, byte interval, byte offset)
static double	lowerBin(double value, double interval)
static double	lowerBin(double value, double interval, double offset)
static float	lowerBin(float value, float interval)
static float	lowerBin(float value, float interval, float offset)
static int	lowerBin(int value, int interval)
static int	lowerBin(int value, int interval, int offset)
static long	lowerBin(long value, long interval)
static long	lowerBin(long value, long interval, long offset)
static short	lowerBin(short value, short interval)
static short	lowerBin(short value, short interval, short offset)
static byte	max(byte... values)
static double	max(double... values)
static float	max(float... values)
static int	max(int... values)
static long	max(long... values)
static short	max(short... values)
static byte	max(ByteVector values)
static double	max(DoubleVector values)
static float	max(FloatVector values)
static int	max(IntVector values)
static long	max(LongVector values)
static short	max(ShortVector values)
static byte	max(Byte[] values)
static double	max(Double[] values)
static float	max(Float[] values)
static int	max(Integer[] values)
static long	max(Long[] values)
static short	max(Short[] values)
static <T extends Comparable<T>> T	maxObj(ObjectVector<T> values)
static <T extends Comparable<T>> T	maxObj(T... values)
static double	median(byte... values)
static double	median(double... values)
static double	median(float... values)
static double	median(int... values)
static double	median(long... values)
static double	median(short... values)
static double	median(ByteVector values)
static double	median(DoubleVector values)
static double	median(FloatVector values)
static double	median(IntVector values)
static double	median(LongVector values)
static double	median(ShortVector values)
static double	median(Byte[] values)
static double	median(Double[] values)
static double	median(Float[] values)
static double	median(Integer[] values)
static double	median(Long[] values)
static double	median(Short[] values)
static byte	min(byte... values)
static double	min(double... values)
static float	min(float... values)
static int	min(int... values)
static long	min(long... values)
static short	min(short... values)
static byte	min(ByteVector values)
static double	min(DoubleVector values)
static float	min(FloatVector values)
static int	min(IntVector values)
static long	min(LongVector values)
static short	min(ShortVector values)
static byte	min(Byte[] values)
static double	min(Double[] values)
static float	min(Float[] values)
static int	min(Integer[] values)
static long	min(Long[] values)
static short	min(Short[] values)
static <T extends Comparable<T>> T	minObj(ObjectVector<T> values)
static <T extends Comparable<T>> T	minObj(T... values)
static byte	multiplyExact(byte x, byte y)
static int	multiplyExact(int x, int y)
static long	multiplyExact(long x, long y)
static short	multiplyExact(short x, short y)
static byte	negateExact(byte x)
static int	negateExact(int x)
static long	negateExact(long x)
static short	negateExact(short x)
static double	nextAfter(double start, double direction)
static float	nextAfter(float start, float direction)
static double	nextDown(double x)
static float	nextDown(float x)
static double	nextUp(double x)
static float	nextUp(float x)
static Boolean[]	not(boolean... values)
static Boolean[]	not(Boolean... values)
static byte	nth(long index, byte... values)
static char	nth(long index, char... values)
static double	nth(long index, double... values)
static float	nth(long index, float... values)
static int	nth(long index, int... values)
static long	nth(long index, long... values)
static short	nth(long index, short... values)
static byte	nth(long index, ByteVector values)
static char	nth(long index, CharVector values)
static double	nth(long index, DoubleVector values)
static float	nth(long index, FloatVector values)
static int	nth(long index, IntVector values)
static long	nth(long index, LongVector values)
static short	nth(long index, ShortVector values)
static <T> T	nthObj(long index, ObjectVector<T> values)
static <T> T	nthObj(long index, T... values)
static <T> T	nullValueFor(Class<T> clazz)
static Boolean	or(boolean... values)
static Boolean	or(Boolean... values)
static Boolean	or(Boolean[] values, Boolean nullValue)
static Boolean	parseBoolean(String s)
static byte	parseByte(String s)
static byte	parseByte(String s, int radix)
static double	parseDouble(String s)
static float	parseFloat(String s)
static int	parseInt(String s)
static int	parseInt(String s, int radix)
static long	parseLong(String s)
static long	parseLong(String s, int radix)
static short	parseShort(String s)
static short	parseShort(String s, int radix)
static int	parseUnsignedInt(String s)
static int	parseUnsignedInt(String s, int radix)
static long	parseUnsignedLong(String s)
static long	parseUnsignedLong(String s, int radix)
static byte	percentile(double percentile, byte... values)
static double	percentile(double percentile, double... values)
static float	percentile(double percentile, float... values)
static int	percentile(double percentile, int... values)
static long	percentile(double percentile, long... values)
static short	percentile(double percentile, short... values)
static byte	percentile(double percentile, ByteVector values)
static double	percentile(double percentile, DoubleVector values)
static float	percentile(double percentile, FloatVector values)
static int	percentile(double percentile, IntVector values)
static long	percentile(double percentile, LongVector values)
static short	percentile(double percentile, ShortVector values)
static double	pow(byte a, byte b)
static double	pow(byte a, double b)
static double	pow(byte a, float b)
static double	pow(byte a, int b)
static double	pow(byte a, long b)
static double	pow(byte a, short b)
static double	pow(double a, byte b)
static double	pow(double a, double b)
static double	pow(double a, float b)
static double	pow(double a, int b)
static double	pow(double a, long b)
static double	pow(double a, short b)
static double	pow(float a, byte b)
static double	pow(float a, double b)
static double	pow(float a, float b)
static double	pow(float a, int b)
static double	pow(float a, long b)
static double	pow(float a, short b)
static double	pow(int a, byte b)
static double	pow(int a, double b)
static double	pow(int a, float b)
static double	pow(int a, int b)
static double	pow(int a, long b)
static double	pow(int a, short b)
static double	pow(long a, byte b)
static double	pow(long a, double b)
static double	pow(long a, float b)
static double	pow(long a, int b)
static double	pow(long a, long b)
static double	pow(long a, short b)
static double	pow(short a, byte b)
static double	pow(short a, double b)
static double	pow(short a, float b)
static double	pow(short a, int b)
static double	pow(short a, long b)
static double	pow(short a, short b)
static long	product(byte... values)
static double	product(double... values)
static double	product(float... values)
static long	product(int... values)
static long	product(long... values)
static long	product(short... values)
static long	product(ByteVector values)
static double	product(DoubleVector values)
static double	product(FloatVector values)
static long	product(IntVector values)
static long	product(LongVector values)
static long	product(ShortVector values)
static double	random()
static boolean	randomBool()
static boolean[]	randomBool(int size)
static double	randomDouble(double min, double max)
static double[]	randomDouble(double min, double max, int size)
static float	randomFloat(float min, float max)
static float[]	randomFloat(float min, float max, int size)
static double	randomGaussian(double mean, double std)
static double[]	randomGaussian(double mean, double std, int size)
static int	randomInt(int min, int max)
static int[]	randomInt(int min, int max, int size)
static long	randomLong(long min, long max)
static long[]	randomLong(long min, long max, int size)
static int[]	rank(byte... values)
static int[]	rank(double... values)
static int[]	rank(float... values)
static int[]	rank(int... values)
static int[]	rank(long... values)
static int[]	rank(short... values)
static int[]	rank(ByteVector values)
static int[]	rank(DoubleVector values)
static int[]	rank(FloatVector values)
static int[]	rank(IntVector values)
static int[]	rank(LongVector values)
static int[]	rank(ShortVector values)
static int[]	rank(Byte[] values)
static int[]	rank(Double[] values)
static int[]	rank(Float[] values)
static int[]	rank(Integer[] values)
static int[]	rank(Long[] values)
static int[]	rank(Short[] values)
static int[]	rankDescending(byte... values)
static int[]	rankDescending(double... values)
static int[]	rankDescending(float... values)
static int[]	rankDescending(int... values)
static int[]	rankDescending(long... values)
static int[]	rankDescending(short... values)
static int[]	rankDescending(ByteVector values)
static int[]	rankDescending(DoubleVector values)
static int[]	rankDescending(FloatVector values)
static int[]	rankDescending(IntVector values)
static int[]	rankDescending(LongVector values)
static int[]	rankDescending(ShortVector values)
static int[]	rankDescending(Byte[] values)
static int[]	rankDescending(Double[] values)
static int[]	rankDescending(Float[] values)
static int[]	rankDescending(Integer[] values)
static int[]	rankDescending(Long[] values)
static int[]	rankDescending(Short[] values)
static <T extends Comparable<? super T>> int[]	rankDescendingObj(ObjectVector<T> values)
static <T extends Comparable<? super T>> int[]	rankDescendingObj(ObjectVector<T> values, Comparator<T> comparator)
static <T extends Comparable<? super T>> int[]	rankDescendingObj(T... values)
static <T extends Comparable<? super T>> int[]	rankDescendingObj(T[] values, Comparator<T> comparator)
static <T extends Comparable<? super T>> int[]	rankObj(ObjectVector<T> values)
static <T extends Comparable<? super T>> int[]	rankObj(ObjectVector<T> values, Comparator<T> comparator)
static <T extends Comparable<? super T>> int[]	rankObj(T... values)
static <T extends Comparable<? super T>> int[]	rankObj(T[] values, Comparator<T> comparator)
static int	rawBinSearchIndex(byte[] values, byte key, BinSearchAlgo choiceWhenEquals)
static int	rawBinSearchIndex(char[] values, char key, BinSearchAlgo choiceWhenEquals)
static int	rawBinSearchIndex(double[] values, double key, BinSearchAlgo choiceWhenEquals)
static int	rawBinSearchIndex(float[] values, float key, BinSearchAlgo choiceWhenEquals)
static int	rawBinSearchIndex(int[] values, int key, BinSearchAlgo choiceWhenEquals)
static int	rawBinSearchIndex(long[] values, long key, BinSearchAlgo choiceWhenEquals)
static int	rawBinSearchIndex(short[] values, short key, BinSearchAlgo choiceWhenEquals)
static int	rawBinSearchIndex(ByteVector values, byte key, BinSearchAlgo choiceWhenEquals)
static int	rawBinSearchIndex(CharVector values, char key, BinSearchAlgo choiceWhenEquals)
static int	rawBinSearchIndex(DoubleVector values, double key, BinSearchAlgo choiceWhenEquals)
static int	rawBinSearchIndex(FloatVector values, float key, BinSearchAlgo choiceWhenEquals)
static int	rawBinSearchIndex(IntVector values, int key, BinSearchAlgo choiceWhenEquals)
static int	rawBinSearchIndex(LongVector values, long key, BinSearchAlgo choiceWhenEquals)
static <T extends Comparable<? super T>> int	rawBinSearchIndex(ObjectVector<T> values, T key, BinSearchAlgo choiceWhenEquals)
static int	rawBinSearchIndex(ShortVector values, short key, BinSearchAlgo choiceWhenEquals)
static <T extends Comparable<? super T>> int	rawBinSearchIndex(T[] values, T key, BinSearchAlgo choiceWhenEquals)
static byte[]	repeat(byte value, int size)
static char[]	repeat(char value, int size)
static double[]	repeat(double value, int size)
static float[]	repeat(float value, int size)
static int[]	repeat(int value, int size)
static long[]	repeat(long value, int size)
static short[]	repeat(short value, int size)
static <T> T[]	repeat(T value, int size)
static double[]	replaceIfNaN(double[] values, double replacement)
static double	replaceIfNaN(double value, double replacement)
static float[]	replaceIfNaN(float[] values, float replacement)
static float	replaceIfNaN(float value, float replacement)
static double[]	replaceIfNaN(DoubleVector values, double replacement)
static float[]	replaceIfNaN(FloatVector values, float replacement)
static double[]	replaceIfNonFinite(double[] values, double replacement)
static double	replaceIfNonFinite(double value, double replacement)
static float[]	replaceIfNonFinite(float[] values, float replacement)
static float	replaceIfNonFinite(float value, float replacement)
static double[]	replaceIfNonFinite(DoubleVector values, double replacement)
static float[]	replaceIfNonFinite(FloatVector values, float replacement)
static byte[]	replaceIfNull(byte[] values, byte replacement)
static byte	replaceIfNull(byte value, byte replacement)
static char[]	replaceIfNull(char[] values, char replacement)
static char	replaceIfNull(char value, char replacement)
static double[]	replaceIfNull(double[] values, double replacement)
static double	replaceIfNull(double value, double replacement)
static float[]	replaceIfNull(float[] values, float replacement)
static float	replaceIfNull(float value, float replacement)
static int[]	replaceIfNull(int[] values, int replacement)
static int	replaceIfNull(int value, int replacement)
static long[]	replaceIfNull(long[] values, long replacement)
static long	replaceIfNull(long value, long replacement)
static short[]	replaceIfNull(short[] values, short replacement)
static short	replaceIfNull(short value, short replacement)
static byte[]	replaceIfNull(ByteVector values, byte replacement)
static char[]	replaceIfNull(CharVector values, char replacement)
static double[]	replaceIfNull(DoubleVector values, double replacement)
static float[]	replaceIfNull(FloatVector values, float replacement)
static int[]	replaceIfNull(IntVector values, int replacement)
static long[]	replaceIfNull(LongVector values, long replacement)
static <T> T[]	replaceIfNull(ObjectVector<T> values, T replacement)
static short[]	replaceIfNull(ShortVector values, short replacement)
static <T> T[]	replaceIfNull(T[] values, T replacement)
static <T> T	replaceIfNull(T value, T replacement)
static double[]	replaceIfNullNaN(double[] values, double replacement)
static double	replaceIfNullNaN(double value, double replacement)
static float[]	replaceIfNullNaN(float[] values, float replacement)
static float	replaceIfNullNaN(float value, float replacement)
static double[]	replaceIfNullNaN(DoubleVector values, double replacement)
static float[]	replaceIfNullNaN(FloatVector values, float replacement)
static byte[]	reverse(byte... values)
static char[]	reverse(char... values)
static double[]	reverse(double... values)
static float[]	reverse(float... values)
static int[]	reverse(int... values)
static long[]	reverse(long... values)
static short[]	reverse(short... values)
static byte[]	reverse(ByteVector values)
static char[]	reverse(CharVector values)
static double[]	reverse(DoubleVector values)
static float[]	reverse(FloatVector values)
static int[]	reverse(IntVector values)
static long[]	reverse(LongVector values)
static short[]	reverse(ShortVector values)
static <T> T[]	reverseObj(ObjectVector<T> values)
static <T> T[]	reverseObj(T... values)
static double	rint(byte value)
static double	rint(double value)
static double	rint(float value)
static double	rint(int value)
static double	rint(long value)
static double	rint(short value)
static long	round(byte value)
static long	round(double value)
static long	round(float value)
static long	round(int value)
static long	round(long value)
static long	round(short value)
static double	scalb(double x, int scaleFactor)
static float	scalb(float x, int scaleFactor)
static byte[]	sequence(byte start, byte end, byte step)
static double[]	sequence(double start, double end, double step)
static float[]	sequence(float start, float end, float step)
static int[]	sequence(int start, int end, int step)
static long[]	sequence(long start, long end, long step)
static short[]	sequence(short start, short end, short step)
static int	signum(byte value)
static int	signum(double value)
static int	signum(float value)
static int	signum(int value)
static int	signum(long value)
static int	signum(short value)
static double	sin(byte value)
static double	sin(double value)
static double	sin(float value)
static double	sin(int value)
static double	sin(long value)
static double	sin(short value)
static double	sinh(byte x)
static double	sinh(double x)
static double	sinh(float x)
static double	sinh(int x)
static double	sinh(long x)
static double	sinh(short x)
static byte[]	sort(byte... values)
static double[]	sort(double... values)
static float[]	sort(float... values)
static int[]	sort(int... values)
static long[]	sort(long... values)
static short[]	sort(short... values)
static byte[]	sort(ByteVector values)
static double[]	sort(DoubleVector values)
static float[]	sort(FloatVector values)
static int[]	sort(IntVector values)
static long[]	sort(LongVector values)
static short[]	sort(ShortVector values)
static byte[]	sort(Byte[] values)
static double[]	sort(Double[] values)
static float[]	sort(Float[] values)
static int[]	sort(Integer[] values)
static long[]	sort(Long[] values)
static short[]	sort(Short[] values)
static byte[]	sortDescending(byte... values)
static double[]	sortDescending(double... values)
static float[]	sortDescending(float... values)
static int[]	sortDescending(int... values)
static long[]	sortDescending(long... values)
static short[]	sortDescending(short... values)
static byte[]	sortDescending(ByteVector values)
static double[]	sortDescending(DoubleVector values)
static float[]	sortDescending(FloatVector values)
static int[]	sortDescending(IntVector values)
static long[]	sortDescending(LongVector values)
static short[]	sortDescending(ShortVector values)
static byte[]	sortDescending(Byte[] values)
static double[]	sortDescending(Double[] values)
static float[]	sortDescending(Float[] values)
static int[]	sortDescending(Integer[] values)
static long[]	sortDescending(Long[] values)
static short[]	sortDescending(Short[] values)
static <T extends Comparable<? super T>> T[]	sortDescendingObj(ObjectVector<T> values)
static <T extends Comparable<? super T>> T[]	sortDescendingObj(ObjectVector<T> values, Comparator<T> comparator)
static <T extends Comparable<? super T>> T[]	sortDescendingObj(T... values)
static <T extends Comparable<? super T>> T[]	sortDescendingObj(T[] values, Comparator<T> comparator)
static <T extends Comparable<? super T>> T[]	sortObj(ObjectVector<T> values)
static <T extends Comparable<? super T>> T[]	sortObj(ObjectVector<T> values, Comparator<T> comparator)
static <T extends Comparable<? super T>> T[]	sortObj(T... values)
static <T extends Comparable<? super T>> T[]	sortObj(T[] values, Comparator<T> comparator)
static double	sqrt(byte value)
static double	sqrt(double value)
static double	sqrt(float value)
static double	sqrt(int value)
static double	sqrt(long value)
static double	sqrt(short value)
static double	std(byte... values)
static double	std(double... values)
static double	std(float... values)
static double	std(int... values)
static double	std(long... values)
static double	std(short... values)
static double	std(ByteVector values)
static double	std(DoubleVector values)
static double	std(FloatVector values)
static double	std(IntVector values)
static double	std(LongVector values)
static double	std(ShortVector values)
static double	std(Byte[] values)
static double	std(Double[] values)
static double	std(Float[] values)
static double	std(Integer[] values)
static double	std(Long[] values)
static double	std(Short[] values)
static double	ste(byte... values)
static double	ste(double... values)
static double	ste(float... values)
static double	ste(int... values)
static double	ste(long... values)
static double	ste(short... values)
static double	ste(ByteVector values)
static double	ste(DoubleVector values)
static double	ste(FloatVector values)
static double	ste(IntVector values)
static double	ste(LongVector values)
static double	ste(ShortVector values)
static double	ste(Byte[] values)
static double	ste(Double[] values)
static double	ste(Float[] values)
static double	ste(Integer[] values)
static double	ste(Long[] values)
static double	ste(Short[] values)
static byte	subtractExact(byte x, byte y)
static int	subtractExact(int x, int y)
static long	subtractExact(long x, long y)
static short	subtractExact(short x, short y)
static long	sum(byte... values)
static double	sum(double... values)
static double	sum(float... values)
static long	sum(int... values)
static long	sum(long... values)
static long	sum(short... values)
static long	sum(ByteVector values)
static double	sum(DoubleVector values)
static double	sum(FloatVector values)
static long	sum(IntVector values)
static long	sum(LongVector values)
static long	sum(ShortVector values)
static double	tan(byte value)
static double	tan(double value)
static double	tan(float value)
static double	tan(int value)
static double	tan(long value)
static double	tan(short value)
static double	tanh(byte x)
static double	tanh(double x)
static double	tanh(float x)
static double	tanh(int x)
static double	tanh(long x)
static double	tanh(short x)
static short	toByteExact(byte x)
static short	toByteExact(int x)
static short	toByteExact(long x)
static short	toByteExact(short x)
static double	toDegrees(byte x)
static double	toDegrees(double x)
static double	toDegrees(float x)
static double	toDegrees(int x)
static double	toDegrees(long x)
static double	toDegrees(short x)
static int	toIntExact(byte x)
static int	toIntExact(int x)
static int	toIntExact(long x)
static int	toIntExact(short x)
static double	toRadians(byte x)
static double	toRadians(double x)
static double	toRadians(float x)
static double	toRadians(int x)
static double	toRadians(long x)
static double	toRadians(short x)
static short	toShortExact(byte x)
static short	toShortExact(int x)
static short	toShortExact(long x)
static short	toShortExact(short x)
static double	tstat(byte... values)
static double	tstat(double... values)
static double	tstat(float... values)
static double	tstat(int... values)
static double	tstat(long... values)
static double	tstat(short... values)
static double	tstat(ByteVector values)
static double	tstat(DoubleVector values)
static double	tstat(FloatVector values)
static double	tstat(IntVector values)
static double	tstat(LongVector values)
static double	tstat(ShortVector values)
static double	tstat(Byte[] values)
static double	tstat(Double[] values)
static double	tstat(Float[] values)
static double	tstat(Integer[] values)
static double	tstat(Long[] values)
static double	tstat(Short[] values)
static double	ulp(double x)
static float	ulp(float x)
static byte[]	unbox(Byte... values)
static char[]	unbox(Character... values)
static double[]	unbox(Double... values)
static float[]	unbox(Float... values)
static int[]	unbox(Integer... values)
static long[]	unbox(Long... values)
static short[]	unbox(Short... values)
static byte	upperBin(byte value, byte interval)
static byte	upperBin(byte value, byte interval, byte offset)
static double	upperBin(double value, double interval)
static double	upperBin(double value, double interval, double offset)
static float	upperBin(float value, float interval)
static float	upperBin(float value, float interval, float offset)
static int	upperBin(int value, int interval)
static int	upperBin(int value, int interval, int offset)
static long	upperBin(long value, long interval)
static long	upperBin(long value, long interval, long offset)
static short	upperBin(short value, short interval)
static short	upperBin(short value, short interval, short offset)
static double	var(byte... values)
static double	var(double... values)
static double	var(float... values)
static double	var(int... values)
static double	var(long... values)
static double	var(short... values)
static double	var(ByteVector values)
static double	var(DoubleVector values)
static double	var(FloatVector values)
static double	var(IntVector values)
static double	var(LongVector values)
static double	var(ShortVector values)
static double	var(Byte[] values)
static double	var(Double[] values)
static double	var(Float[] values)
static double	var(Integer[] values)
static double	var(Long[] values)
static double	var(Short[] values)
static ByteVector	vec(byte... values)
static CharVector	vec(char... values)
static DoubleVector	vec(double... values)
static FloatVector	vec(float... values)
static IntVector	vec(int... values)
static LongVector	vec(long... values)
static ShortVector	vec(short... values)
static <T> ObjectVector<T>	vecObj(T... values)
static double	wavg(byte[] values, byte[] weights)
static double	wavg(byte[] values, double[] weights)
static double	wavg(byte[] values, float[] weights)
static double	wavg(byte[] values, int[] weights)
static double	wavg(byte[] values, long[] weights)
static double	wavg(byte[] values, short[] weights)
static double	wavg(byte[] values, ByteVector weights)
static double	wavg(byte[] values, DoubleVector weights)
static double	wavg(byte[] values, FloatVector weights)
static double	wavg(byte[] values, IntVector weights)
static double	wavg(byte[] values, LongVector weights)
static double	wavg(byte[] values, ShortVector weights)
static double	wavg(double[] values, byte[] weights)
static double	wavg(double[] values, double[] weights)
static double	wavg(double[] values, float[] weights)
static double	wavg(double[] values, int[] weights)
static double	wavg(double[] values, long[] weights)
static double	wavg(double[] values, short[] weights)
static double	wavg(double[] values, ByteVector weights)
static double	wavg(double[] values, DoubleVector weights)
static double	wavg(double[] values, FloatVector weights)
static double	wavg(double[] values, IntVector weights)
static double	wavg(double[] values, LongVector weights)
static double	wavg(double[] values, ShortVector weights)
static double	wavg(float[] values, byte[] weights)
static double	wavg(float[] values, double[] weights)
static double	wavg(float[] values, float[] weights)
static double	wavg(float[] values, int[] weights)
static double	wavg(float[] values, long[] weights)
static double	wavg(float[] values, short[] weights)
static double	wavg(float[] values, ByteVector weights)
static double	wavg(float[] values, DoubleVector weights)
static double	wavg(float[] values, FloatVector weights)
static double	wavg(float[] values, IntVector weights)
static double	wavg(float[] values, LongVector weights)
static double	wavg(float[] values, ShortVector weights)
static double	wavg(int[] values, byte[] weights)
static double	wavg(int[] values, double[] weights)
static double	wavg(int[] values, float[] weights)
static double	wavg(int[] values, int[] weights)
static double	wavg(int[] values, long[] weights)
static double	wavg(int[] values, short[] weights)
static double	wavg(int[] values, ByteVector weights)
static double	wavg(int[] values, DoubleVector weights)
static double	wavg(int[] values, FloatVector weights)
static double	wavg(int[] values, IntVector weights)
static double	wavg(int[] values, LongVector weights)
static double	wavg(int[] values, ShortVector weights)
static double	wavg(long[] values, byte[] weights)
static double	wavg(long[] values, double[] weights)
static double	wavg(long[] values, float[] weights)
static double	wavg(long[] values, int[] weights)
static double	wavg(long[] values, long[] weights)
static double	wavg(long[] values, short[] weights)
static double	wavg(long[] values, ByteVector weights)
static double	wavg(long[] values, DoubleVector weights)
static double	wavg(long[] values, FloatVector weights)
static double	wavg(long[] values, IntVector weights)
static double	wavg(long[] values, LongVector weights)
static double	wavg(long[] values, ShortVector weights)
static double	wavg(short[] values, byte[] weights)
static double	wavg(short[] values, double[] weights)
static double	wavg(short[] values, float[] weights)
static double	wavg(short[] values, int[] weights)
static double	wavg(short[] values, long[] weights)
static double	wavg(short[] values, short[] weights)
static double	wavg(short[] values, ByteVector weights)
static double	wavg(short[] values, DoubleVector weights)
static double	wavg(short[] values, FloatVector weights)
static double	wavg(short[] values, IntVector weights)
static double	wavg(short[] values, LongVector weights)
static double	wavg(short[] values, ShortVector weights)
static double	wavg(ByteVector values, byte[] weights)
static double	wavg(ByteVector values, double[] weights)
static double	wavg(ByteVector values, float[] weights)
static double	wavg(ByteVector values, int[] weights)
static double	wavg(ByteVector values, long[] weights)
static double	wavg(ByteVector values, short[] weights)
static double	wavg(ByteVector values, ByteVector weights)
static double	wavg(ByteVector values, DoubleVector weights)
static double	wavg(ByteVector values, FloatVector weights)
static double	wavg(ByteVector values, IntVector weights)
static double	wavg(ByteVector values, LongVector weights)
static double	wavg(ByteVector values, ShortVector weights)
static double	wavg(DoubleVector values, byte[] weights)
static double	wavg(DoubleVector values, double[] weights)
static double	wavg(DoubleVector values, float[] weights)
static double	wavg(DoubleVector values, int[] weights)
static double	wavg(DoubleVector values, long[] weights)
static double	wavg(DoubleVector values, short[] weights)
static double	wavg(DoubleVector values, ByteVector weights)
static double	wavg(DoubleVector values, DoubleVector weights)
static double	wavg(DoubleVector values, FloatVector weights)
static double	wavg(DoubleVector values, IntVector weights)
static double	wavg(DoubleVector values, LongVector weights)
static double	wavg(DoubleVector values, ShortVector weights)
static double	wavg(FloatVector values, byte[] weights)
static double	wavg(FloatVector values, double[] weights)
static double	wavg(FloatVector values, float[] weights)
static double	wavg(FloatVector values, int[] weights)
static double	wavg(FloatVector values, long[] weights)
static double	wavg(FloatVector values, short[] weights)
static double	wavg(FloatVector values, ByteVector weights)
static double	wavg(FloatVector values, DoubleVector weights)
static double	wavg(FloatVector values, FloatVector weights)
static double	wavg(FloatVector values, IntVector weights)
static double	wavg(FloatVector values, LongVector weights)
static double	wavg(FloatVector values, ShortVector weights)
static double	wavg(IntVector values, byte[] weights)
static double	wavg(IntVector values, double[] weights)
static double	wavg(IntVector values, float[] weights)
static double	wavg(IntVector values, int[] weights)
static double	wavg(IntVector values, long[] weights)
static double	wavg(IntVector values, short[] weights)
static double	wavg(IntVector values, ByteVector weights)
static double	wavg(IntVector values, DoubleVector weights)
static double	wavg(IntVector values, FloatVector weights)
static double	wavg(IntVector values, IntVector weights)
static double	wavg(IntVector values, LongVector weights)
static double	wavg(IntVector values, ShortVector weights)
static double	wavg(LongVector values, byte[] weights)
static double	wavg(LongVector values, double[] weights)
static double	wavg(LongVector values, float[] weights)
static double	wavg(LongVector values, int[] weights)
static double	wavg(LongVector values, long[] weights)
static double	wavg(LongVector values, short[] weights)
static double	wavg(LongVector values, ByteVector weights)
static double	wavg(LongVector values, DoubleVector weights)
static double	wavg(LongVector values, FloatVector weights)
static double	wavg(LongVector values, IntVector weights)
static double	wavg(LongVector values, LongVector weights)
static double	wavg(LongVector values, ShortVector weights)
static double	wavg(ShortVector values, byte[] weights)
static double	wavg(ShortVector values, double[] weights)
static double	wavg(ShortVector values, float[] weights)
static double	wavg(ShortVector values, int[] weights)
static double	wavg(ShortVector values, long[] weights)
static double	wavg(ShortVector values, short[] weights)
static double	wavg(ShortVector values, ByteVector weights)
static double	wavg(ShortVector values, DoubleVector weights)
static double	wavg(ShortVector values, FloatVector weights)
static double	wavg(ShortVector values, IntVector weights)
static double	wavg(ShortVector values, LongVector weights)
static double	wavg(ShortVector values, ShortVector weights)
static double	wstd(byte[] values, byte[] weights)
static double	wstd(byte[] values, double[] weights)
static double	wstd(byte[] values, float[] weights)
static double	wstd(byte[] values, int[] weights)
static double	wstd(byte[] values, long[] weights)
static double	wstd(byte[] values, short[] weights)
static double	wstd(byte[] values, ByteVector weights)
static double	wstd(byte[] values, DoubleVector weights)
static double	wstd(byte[] values, FloatVector weights)
static double	wstd(byte[] values, IntVector weights)
static double	wstd(byte[] values, LongVector weights)
static double	wstd(byte[] values, ShortVector weights)
static double	wstd(double[] values, byte[] weights)
static double	wstd(double[] values, double[] weights)
static double	wstd(double[] values, float[] weights)
static double	wstd(double[] values, int[] weights)
static double	wstd(double[] values, long[] weights)
static double	wstd(double[] values, short[] weights)
static double	wstd(double[] values, ByteVector weights)
static double	wstd(double[] values, DoubleVector weights)
static double	wstd(double[] values, FloatVector weights)
static double	wstd(double[] values, IntVector weights)
static double	wstd(double[] values, LongVector weights)
static double	wstd(double[] values, ShortVector weights)
static double	wstd(float[] values, byte[] weights)
static double	wstd(float[] values, double[] weights)
static double	wstd(float[] values, float[] weights)
static double	wstd(float[] values, int[] weights)
static double	wstd(float[] values, long[] weights)
static double	wstd(float[] values, short[] weights)
static double	wstd(float[] values, ByteVector weights)
static double	wstd(float[] values, DoubleVector weights)
static double	wstd(float[] values, FloatVector weights)
static double	wstd(float[] values, IntVector weights)
static double	wstd(float[] values, LongVector weights)
static double	wstd(float[] values, ShortVector weights)
static double	wstd(int[] values, byte[] weights)
static double	wstd(int[] values, double[] weights)
static double	wstd(int[] values, float[] weights)
static double	wstd(int[] values, int[] weights)
static double	wstd(int[] values, long[] weights)
static double	wstd(int[] values, short[] weights)
static double	wstd(int[] values, ByteVector weights)
static double	wstd(int[] values, DoubleVector weights)
static double	wstd(int[] values, FloatVector weights)
static double	wstd(int[] values, IntVector weights)
static double	wstd(int[] values, LongVector weights)
static double	wstd(int[] values, ShortVector weights)
static double	wstd(long[] values, byte[] weights)
static double	wstd(long[] values, double[] weights)
static double	wstd(long[] values, float[] weights)
static double	wstd(long[] values, int[] weights)
static double	wstd(long[] values, long[] weights)
static double	wstd(long[] values, short[] weights)
static double	wstd(long[] values, ByteVector weights)
static double	wstd(long[] values, DoubleVector weights)
static double	wstd(long[] values, FloatVector weights)
static double	wstd(long[] values, IntVector weights)
static double	wstd(long[] values, LongVector weights)
static double	wstd(long[] values, ShortVector weights)
static double	wstd(short[] values, byte[] weights)
static double	wstd(short[] values, double[] weights)
static double	wstd(short[] values, float[] weights)
static double	wstd(short[] values, int[] weights)
static double	wstd(short[] values, long[] weights)
static double	wstd(short[] values, short[] weights)
static double	wstd(short[] values, ByteVector weights)
static double	wstd(short[] values, DoubleVector weights)
static double	wstd(short[] values, FloatVector weights)
static double	wstd(short[] values, IntVector weights)
static double	wstd(short[] values, LongVector weights)
static double	wstd(short[] values, ShortVector weights)
static double	wstd(ByteVector values, byte[] weights)
static double	wstd(ByteVector values, double[] weights)
static double	wstd(ByteVector values, float[] weights)
static double	wstd(ByteVector values, int[] weights)
static double	wstd(ByteVector values, long[] weights)
static double	wstd(ByteVector values, short[] weights)
static double	wstd(ByteVector values, ByteVector weights)
static double	wstd(ByteVector values, DoubleVector weights)
static double	wstd(ByteVector values, FloatVector weights)
static double	wstd(ByteVector values, IntVector weights)
static double	wstd(ByteVector values, LongVector weights)
static double	wstd(ByteVector values, ShortVector weights)
static double	wstd(DoubleVector values, byte[] weights)
static double	wstd(DoubleVector values, double[] weights)
static double	wstd(DoubleVector values, float[] weights)
static double	wstd(DoubleVector values, int[] weights)
static double	wstd(DoubleVector values, long[] weights)
static double	wstd(DoubleVector values, short[] weights)
static double	wstd(DoubleVector values, ByteVector weights)
static double	wstd(DoubleVector values, DoubleVector weights)
static double	wstd(DoubleVector values, FloatVector weights)
static double	wstd(DoubleVector values, IntVector weights)
static double	wstd(DoubleVector values, LongVector weights)
static double	wstd(DoubleVector values, ShortVector weights)
static double	wstd(FloatVector values, byte[] weights)
static double	wstd(FloatVector values, double[] weights)
static double	wstd(FloatVector values, float[] weights)
static double	wstd(FloatVector values, int[] weights)
static double	wstd(FloatVector values, long[] weights)
static double	wstd(FloatVector values, short[] weights)
static double	wstd(FloatVector values, ByteVector weights)
static double	wstd(FloatVector values, DoubleVector weights)
static double	wstd(FloatVector values, FloatVector weights)
static double	wstd(FloatVector values, IntVector weights)
static double	wstd(FloatVector values, LongVector weights)
static double	wstd(FloatVector values, ShortVector weights)
static double	wstd(IntVector values, byte[] weights)
static double	wstd(IntVector values, double[] weights)
static double	wstd(IntVector values, float[] weights)
static double	wstd(IntVector values, int[] weights)
static double	wstd(IntVector values, long[] weights)
static double	wstd(IntVector values, short[] weights)
static double	wstd(IntVector values, ByteVector weights)
static double	wstd(IntVector values, DoubleVector weights)
static double	wstd(IntVector values, FloatVector weights)
static double	wstd(IntVector values, IntVector weights)
static double	wstd(IntVector values, LongVector weights)
static double	wstd(IntVector values, ShortVector weights)
static double	wstd(LongVector values, byte[] weights)
static double	wstd(LongVector values, double[] weights)
static double	wstd(LongVector values, float[] weights)
static double	wstd(LongVector values, int[] weights)
static double	wstd(LongVector values, long[] weights)
static double	wstd(LongVector values, short[] weights)
static double	wstd(LongVector values, ByteVector weights)
static double	wstd(LongVector values, DoubleVector weights)
static double	wstd(LongVector values, FloatVector weights)
static double	wstd(LongVector values, IntVector weights)
static double	wstd(LongVector values, LongVector weights)
static double	wstd(LongVector values, ShortVector weights)
static double	wstd(ShortVector values, byte[] weights)
static double	wstd(ShortVector values, double[] weights)
static double	wstd(ShortVector values, float[] weights)
static double	wstd(ShortVector values, int[] weights)
static double	wstd(ShortVector values, long[] weights)
static double	wstd(ShortVector values, short[] weights)
static double	wstd(ShortVector values, ByteVector weights)
static double	wstd(ShortVector values, DoubleVector weights)
static double	wstd(ShortVector values, FloatVector weights)
static double	wstd(ShortVector values, IntVector weights)
static double	wstd(ShortVector values, LongVector weights)
static double	wstd(ShortVector values, ShortVector weights)
static double	wste(byte[] values, byte[] weights)
static double	wste(byte[] values, double[] weights)
static double	wste(byte[] values, float[] weights)
static double	wste(byte[] values, int[] weights)
static double	wste(byte[] values, long[] weights)
static double	wste(byte[] values, short[] weights)
static double	wste(byte[] values, ByteVector weights)
static double	wste(byte[] values, DoubleVector weights)
static double	wste(byte[] values, FloatVector weights)
static double	wste(byte[] values, IntVector weights)
static double	wste(byte[] values, LongVector weights)
static double	wste(byte[] values, ShortVector weights)
static double	wste(double[] values, byte[] weights)
static double	wste(double[] values, double[] weights)
static double	wste(double[] values, float[] weights)
static double	wste(double[] values, int[] weights)
static double	wste(double[] values, long[] weights)
static double	wste(double[] values, short[] weights)
static double	wste(double[] values, ByteVector weights)
static double	wste(double[] values, DoubleVector weights)
static double	wste(double[] values, FloatVector weights)
static double	wste(double[] values, IntVector weights)
static double	wste(double[] values, LongVector weights)
static double	wste(double[] values, ShortVector weights)
static double	wste(float[] values, byte[] weights)
static double	wste(float[] values, double[] weights)
static double	wste(float[] values, float[] weights)
static double	wste(float[] values, int[] weights)
static double	wste(float[] values, long[] weights)
static double	wste(float[] values, short[] weights)
static double	wste(float[] values, ByteVector weights)
static double	wste(float[] values, DoubleVector weights)
static double	wste(float[] values, FloatVector weights)
static double	wste(float[] values, IntVector weights)
static double	wste(float[] values, LongVector weights)
static double	wste(float[] values, ShortVector weights)
static double	wste(int[] values, byte[] weights)
static double	wste(int[] values, double[] weights)
static double	wste(int[] values, float[] weights)
static double	wste(int[] values, int[] weights)
static double	wste(int[] values, long[] weights)
static double	wste(int[] values, short[] weights)
static double	wste(int[] values, ByteVector weights)
static double	wste(int[] values, DoubleVector weights)
static double	wste(int[] values, FloatVector weights)
static double	wste(int[] values, IntVector weights)
static double	wste(int[] values, LongVector weights)
static double	wste(int[] values, ShortVector weights)
static double	wste(long[] values, byte[] weights)
static double	wste(long[] values, double[] weights)
static double	wste(long[] values, float[] weights)
static double	wste(long[] values, int[] weights)
static double	wste(long[] values, long[] weights)
static double	wste(long[] values, short[] weights)
static double	wste(long[] values, ByteVector weights)
static double	wste(long[] values, DoubleVector weights)
static double	wste(long[] values, FloatVector weights)
static double	wste(long[] values, IntVector weights)
static double	wste(long[] values, LongVector weights)
static double	wste(long[] values, ShortVector weights)
static double	wste(short[] values, byte[] weights)
static double	wste(short[] values, double[] weights)
static double	wste(short[] values, float[] weights)
static double	wste(short[] values, int[] weights)
static double	wste(short[] values, long[] weights)
static double	wste(short[] values, short[] weights)
static double	wste(short[] values, ByteVector weights)
static double	wste(short[] values, DoubleVector weights)
static double	wste(short[] values, FloatVector weights)
static double	wste(short[] values, IntVector weights)
static double	wste(short[] values, LongVector weights)
static double	wste(short[] values, ShortVector weights)
static double	wste(ByteVector values, byte[] weights)
static double	wste(ByteVector values, double[] weights)
static double	wste(ByteVector values, float[] weights)
static double	wste(ByteVector values, int[] weights)
static double	wste(ByteVector values, long[] weights)
static double	wste(ByteVector values, short[] weights)
static double	wste(ByteVector values, ByteVector weights)
static double	wste(ByteVector values, DoubleVector weights)
static double	wste(ByteVector values, FloatVector weights)
static double	wste(ByteVector values, IntVector weights)
static double	wste(ByteVector values, LongVector weights)
static double	wste(ByteVector values, ShortVector weights)
static double	wste(DoubleVector values, byte[] weights)
static double	wste(DoubleVector values, double[] weights)
static double	wste(DoubleVector values, float[] weights)
static double	wste(DoubleVector values, int[] weights)
static double	wste(DoubleVector values, long[] weights)
static double	wste(DoubleVector values, short[] weights)
static double	wste(DoubleVector values, ByteVector weights)
static double	wste(DoubleVector values, DoubleVector weights)
static double	wste(DoubleVector values, FloatVector weights)
static double	wste(DoubleVector values, IntVector weights)
static double	wste(DoubleVector values, LongVector weights)
static double	wste(DoubleVector values, ShortVector weights)
static double	wste(FloatVector values, byte[] weights)
static double	wste(FloatVector values, double[] weights)
static double	wste(FloatVector values, float[] weights)
static double	wste(FloatVector values, int[] weights)
static double	wste(FloatVector values, long[] weights)
static double	wste(FloatVector values, short[] weights)
static double	wste(FloatVector values, ByteVector weights)
static double	wste(FloatVector values, DoubleVector weights)
static double	wste(FloatVector values, FloatVector weights)
static double	wste(FloatVector values, IntVector weights)
static double	wste(FloatVector values, LongVector weights)
static double	wste(FloatVector values, ShortVector weights)
static double	wste(IntVector values, byte[] weights)
static double	wste(IntVector values, double[] weights)
static double	wste(IntVector values, float[] weights)
static double	wste(IntVector values, int[] weights)
static double	wste(IntVector values, long[] weights)
static double	wste(IntVector values, short[] weights)
static double	wste(IntVector values, ByteVector weights)
static double	wste(IntVector values, DoubleVector weights)
static double	wste(IntVector values, FloatVector weights)
static double	wste(IntVector values, IntVector weights)
static double	wste(IntVector values, LongVector weights)
static double	wste(IntVector values, ShortVector weights)
static double	wste(LongVector values, byte[] weights)
static double	wste(LongVector values, double[] weights)
static double	wste(LongVector values, float[] weights)
static double	wste(LongVector values, int[] weights)
static double	wste(LongVector values, long[] weights)
static double	wste(LongVector values, short[] weights)
static double	wste(LongVector values, ByteVector weights)
static double	wste(LongVector values, DoubleVector weights)
static double	wste(LongVector values, FloatVector weights)
static double	wste(LongVector values, IntVector weights)
static double	wste(LongVector values, LongVector weights)
static double	wste(LongVector values, ShortVector weights)
static double	wste(ShortVector values, byte[] weights)
static double	wste(ShortVector values, double[] weights)
static double	wste(ShortVector values, float[] weights)
static double	wste(ShortVector values, int[] weights)
static double	wste(ShortVector values, long[] weights)
static double	wste(ShortVector values, short[] weights)
static double	wste(ShortVector values, ByteVector weights)
static double	wste(ShortVector values, DoubleVector weights)
static double	wste(ShortVector values, FloatVector weights)
static double	wste(ShortVector values, IntVector weights)
static double	wste(ShortVector values, LongVector weights)
static double	wste(ShortVector values, ShortVector weights)
static long	wsum(byte[] values, byte[] weights)
static double	wsum(byte[] values, double[] weights)
static double	wsum(byte[] values, float[] weights)
static long	wsum(byte[] values, int[] weights)
static long	wsum(byte[] values, long[] weights)
static long	wsum(byte[] values, short[] weights)
static long	wsum(byte[] values, ByteVector weights)
static double	wsum(byte[] values, DoubleVector weights)
static double	wsum(byte[] values, FloatVector weights)
static long	wsum(byte[] values, IntVector weights)
static long	wsum(byte[] values, LongVector weights)
static long	wsum(byte[] values, ShortVector weights)
static double	wsum(double[] values, byte[] weights)
static double	wsum(double[] values, double[] weights)
static double	wsum(double[] values, float[] weights)
static double	wsum(double[] values, int[] weights)
static double	wsum(double[] values, long[] weights)
static double	wsum(double[] values, short[] weights)
static double	wsum(double[] values, ByteVector weights)
static double	wsum(double[] values, DoubleVector weights)
static double	wsum(double[] values, FloatVector weights)
static double	wsum(double[] values, IntVector weights)
static double	wsum(double[] values, LongVector weights)
static double	wsum(double[] values, ShortVector weights)
static double	wsum(float[] values, byte[] weights)
static double	wsum(float[] values, double[] weights)
static double	wsum(float[] values, float[] weights)
static double	wsum(float[] values, int[] weights)
static double	wsum(float[] values, long[] weights)
static double	wsum(float[] values, short[] weights)
static double	wsum(float[] values, ByteVector weights)
static double	wsum(float[] values, DoubleVector weights)
static double	wsum(float[] values, FloatVector weights)
static double	wsum(float[] values, IntVector weights)
static double	wsum(float[] values, LongVector weights)
static double	wsum(float[] values, ShortVector weights)
static long	wsum(int[] values, byte[] weights)
static double	wsum(int[] values, double[] weights)
static double	wsum(int[] values, float[] weights)
static long	wsum(int[] values, int[] weights)
static long	wsum(int[] values, long[] weights)
static long	wsum(int[] values, short[] weights)
static long	wsum(int[] values, ByteVector weights)
static double	wsum(int[] values, DoubleVector weights)
static double	wsum(int[] values, FloatVector weights)
static long	wsum(int[] values, IntVector weights)
static long	wsum(int[] values, LongVector weights)
static long	wsum(int[] values, ShortVector weights)
static long	wsum(long[] values, byte[] weights)
static double	wsum(long[] values, double[] weights)
static double	wsum(long[] values, float[] weights)
static long	wsum(long[] values, int[] weights)
static long	wsum(long[] values, long[] weights)
static long	wsum(long[] values, short[] weights)
static long	wsum(long[] values, ByteVector weights)
static double	wsum(long[] values, DoubleVector weights)
static double	wsum(long[] values, FloatVector weights)
static long	wsum(long[] values, IntVector weights)
static long	wsum(long[] values, LongVector weights)
static long	wsum(long[] values, ShortVector weights)
static long	wsum(short[] values, byte[] weights)
static double	wsum(short[] values, double[] weights)
static double	wsum(short[] values, float[] weights)
static long	wsum(short[] values, int[] weights)
static long	wsum(short[] values, long[] weights)
static long	wsum(short[] values, short[] weights)
static long	wsum(short[] values, ByteVector weights)
static double	wsum(short[] values, DoubleVector weights)
static double	wsum(short[] values, FloatVector weights)
static long	wsum(short[] values, IntVector weights)
static long	wsum(short[] values, LongVector weights)
static long	wsum(short[] values, ShortVector weights)
static long	wsum(ByteVector values, byte[] weights)
static double	wsum(ByteVector values, double[] weights)
static double	wsum(ByteVector values, float[] weights)
static long	wsum(ByteVector values, int[] weights)
static long	wsum(ByteVector values, long[] weights)
static long	wsum(ByteVector values, short[] weights)
static long	wsum(ByteVector values, ByteVector weights)
static double	wsum(ByteVector values, DoubleVector weights)
static double	wsum(ByteVector values, FloatVector weights)
static long	wsum(ByteVector values, IntVector weights)
static long	wsum(ByteVector values, LongVector weights)
static long	wsum(ByteVector values, ShortVector weights)
static double	wsum(DoubleVector values, byte[] weights)
static double	wsum(DoubleVector values, double[] weights)
static double	wsum(DoubleVector values, float[] weights)
static double	wsum(DoubleVector values, int[] weights)
static double	wsum(DoubleVector values, long[] weights)
static double	wsum(DoubleVector values, short[] weights)
static double	wsum(DoubleVector values, ByteVector weights)
static double	wsum(DoubleVector values, DoubleVector weights)
static double	wsum(DoubleVector values, FloatVector weights)
static double	wsum(DoubleVector values, IntVector weights)
static double	wsum(DoubleVector values, LongVector weights)
static double	wsum(DoubleVector values, ShortVector weights)
static double	wsum(FloatVector values, byte[] weights)
static double	wsum(FloatVector values, double[] weights)
static double	wsum(FloatVector values, float[] weights)
static double	wsum(FloatVector values, int[] weights)
static double	wsum(FloatVector values, long[] weights)
static double	wsum(FloatVector values, short[] weights)
static double	wsum(FloatVector values, ByteVector weights)
static double	wsum(FloatVector values, DoubleVector weights)
static double	wsum(FloatVector values, FloatVector weights)
static double	wsum(FloatVector values, IntVector weights)
static double	wsum(FloatVector values, LongVector weights)
static double	wsum(FloatVector values, ShortVector weights)
static long	wsum(IntVector values, byte[] weights)
static double	wsum(IntVector values, double[] weights)
static double	wsum(IntVector values, float[] weights)
static long	wsum(IntVector values, int[] weights)
static long	wsum(IntVector values, long[] weights)
static long	wsum(IntVector values, short[] weights)
static long	wsum(IntVector values, ByteVector weights)
static double	wsum(IntVector values, DoubleVector weights)
static double	wsum(IntVector values, FloatVector weights)
static long	wsum(IntVector values, IntVector weights)
static long	wsum(IntVector values, LongVector weights)
static long	wsum(IntVector values, ShortVector weights)
static long	wsum(LongVector values, byte[] weights)
static double	wsum(LongVector values, double[] weights)
static double	wsum(LongVector values, float[] weights)
static long	wsum(LongVector values, int[] weights)
static long	wsum(LongVector values, long[] weights)
static long	wsum(LongVector values, short[] weights)
static long	wsum(LongVector values, ByteVector weights)
static double	wsum(LongVector values, DoubleVector weights)
static double	wsum(LongVector values, FloatVector weights)
static long	wsum(LongVector values, IntVector weights)
static long	wsum(LongVector values, LongVector weights)
static long	wsum(LongVector values, ShortVector weights)
static long	wsum(ShortVector values, byte[] weights)
static double	wsum(ShortVector values, double[] weights)
static double	wsum(ShortVector values, float[] weights)
static long	wsum(ShortVector values, int[] weights)
static long	wsum(ShortVector values, long[] weights)
static long	wsum(ShortVector values, short[] weights)
static long	wsum(ShortVector values, ByteVector weights)
static double	wsum(ShortVector values, DoubleVector weights)
static double	wsum(ShortVector values, FloatVector weights)
static long	wsum(ShortVector values, IntVector weights)
static long	wsum(ShortVector values, LongVector weights)
static long	wsum(ShortVector values, ShortVector weights)
static double	wtstat(byte[] values, byte[] weights)
static double	wtstat(byte[] values, double[] weights)
static double	wtstat(byte[] values, float[] weights)
static double	wtstat(byte[] values, int[] weights)
static double	wtstat(byte[] values, long[] weights)
static double	wtstat(byte[] values, short[] weights)
static double	wtstat(byte[] values, ByteVector weights)
static double	wtstat(byte[] values, DoubleVector weights)
static double	wtstat(byte[] values, FloatVector weights)
static double	wtstat(byte[] values, IntVector weights)
static double	wtstat(byte[] values, LongVector weights)
static double	wtstat(byte[] values, ShortVector weights)
static double	wtstat(double[] values, byte[] weights)
static double	wtstat(double[] values, double[] weights)
static double	wtstat(double[] values, float[] weights)
static double	wtstat(double[] values, int[] weights)
static double	wtstat(double[] values, long[] weights)
static double	wtstat(double[] values, short[] weights)
static double	wtstat(double[] values, ByteVector weights)
static double	wtstat(double[] values, DoubleVector weights)
static double	wtstat(double[] values, FloatVector weights)
static double	wtstat(double[] values, IntVector weights)
static double	wtstat(double[] values, LongVector weights)
static double	wtstat(double[] values, ShortVector weights)
static double	wtstat(float[] values, byte[] weights)
static double	wtstat(float[] values, double[] weights)
static double	wtstat(float[] values, float[] weights)
static double	wtstat(float[] values, int[] weights)
static double	wtstat(float[] values, long[] weights)
static double	wtstat(float[] values, short[] weights)
static double	wtstat(float[] values, ByteVector weights)
static double	wtstat(float[] values, DoubleVector weights)
static double	wtstat(float[] values, FloatVector weights)
static double	wtstat(float[] values, IntVector weights)
static double	wtstat(float[] values, LongVector weights)
static double	wtstat(float[] values, ShortVector weights)
static double	wtstat(int[] values, byte[] weights)
static double	wtstat(int[] values, double[] weights)
static double	wtstat(int[] values, float[] weights)
static double	wtstat(int[] values, int[] weights)
static double	wtstat(int[] values, long[] weights)
static double	wtstat(int[] values, short[] weights)
static double	wtstat(int[] values, ByteVector weights)
static double	wtstat(int[] values, DoubleVector weights)
static double	wtstat(int[] values, FloatVector weights)
static double	wtstat(int[] values, IntVector weights)
static double	wtstat(int[] values, LongVector weights)
static double	wtstat(int[] values, ShortVector weights)
static double	wtstat(long[] values, byte[] weights)
static double	wtstat(long[] values, double[] weights)
static double	wtstat(long[] values, float[] weights)
static double	wtstat(long[] values, int[] weights)
static double	wtstat(long[] values, long[] weights)
static double	wtstat(long[] values, short[] weights)
static double	wtstat(long[] values, ByteVector weights)
static double	wtstat(long[] values, DoubleVector weights)
static double	wtstat(long[] values, FloatVector weights)
static double	wtstat(long[] values, IntVector weights)
static double	wtstat(long[] values, LongVector weights)
static double	wtstat(long[] values, ShortVector weights)
static double	wtstat(short[] values, byte[] weights)
static double	wtstat(short[] values, double[] weights)
static double	wtstat(short[] values, float[] weights)
static double	wtstat(short[] values, int[] weights)
static double	wtstat(short[] values, long[] weights)
static double	wtstat(short[] values, short[] weights)
static double	wtstat(short[] values, ByteVector weights)
static double	wtstat(short[] values, DoubleVector weights)
static double	wtstat(short[] values, FloatVector weights)
static double	wtstat(short[] values, IntVector weights)
static double	wtstat(short[] values, LongVector weights)
static double	wtstat(short[] values, ShortVector weights)
static double	wtstat(ByteVector values, byte[] weights)
static double	wtstat(ByteVector values, double[] weights)
static double	wtstat(ByteVector values, float[] weights)
static double	wtstat(ByteVector values, int[] weights)
static double	wtstat(ByteVector values, long[] weights)
static double	wtstat(ByteVector values, short[] weights)
static double	wtstat(ByteVector values, ByteVector weights)
static double	wtstat(ByteVector values, DoubleVector weights)
static double	wtstat(ByteVector values, FloatVector weights)
static double	wtstat(ByteVector values, IntVector weights)
static double	wtstat(ByteVector values, LongVector weights)
static double	wtstat(ByteVector values, ShortVector weights)
static double	wtstat(DoubleVector values, byte[] weights)
static double	wtstat(DoubleVector values, double[] weights)
static double	wtstat(DoubleVector values, float[] weights)
static double	wtstat(DoubleVector values, int[] weights)
static double	wtstat(DoubleVector values, long[] weights)
static double	wtstat(DoubleVector values, short[] weights)
static double	wtstat(DoubleVector values, ByteVector weights)
static double	wtstat(DoubleVector values, DoubleVector weights)
static double	wtstat(DoubleVector values, FloatVector weights)
static double	wtstat(DoubleVector values, IntVector weights)
static double	wtstat(DoubleVector values, LongVector weights)
static double	wtstat(DoubleVector values, ShortVector weights)
static double	wtstat(FloatVector values, byte[] weights)
static double	wtstat(FloatVector values, double[] weights)
static double	wtstat(FloatVector values, float[] weights)
static double	wtstat(FloatVector values, int[] weights)
static double	wtstat(FloatVector values, long[] weights)
static double	wtstat(FloatVector values, short[] weights)
static double	wtstat(FloatVector values, ByteVector weights)
static double	wtstat(FloatVector values, DoubleVector weights)
static double	wtstat(FloatVector values, FloatVector weights)
static double	wtstat(FloatVector values, IntVector weights)
static double	wtstat(FloatVector values, LongVector weights)
static double	wtstat(FloatVector values, ShortVector weights)
static double	wtstat(IntVector values, byte[] weights)
static double	wtstat(IntVector values, double[] weights)
static double	wtstat(IntVector values, float[] weights)
static double	wtstat(IntVector values, int[] weights)
static double	wtstat(IntVector values, long[] weights)
static double	wtstat(IntVector values, short[] weights)
static double	wtstat(IntVector values, ByteVector weights)
static double	wtstat(IntVector values, DoubleVector weights)
static double	wtstat(IntVector values, FloatVector weights)
static double	wtstat(IntVector values, IntVector weights)
static double	wtstat(IntVector values, LongVector weights)
static double	wtstat(IntVector values, ShortVector weights)
static double	wtstat(LongVector values, byte[] weights)
static double	wtstat(LongVector values, double[] weights)
static double	wtstat(LongVector values, float[] weights)
static double	wtstat(LongVector values, int[] weights)
static double	wtstat(LongVector values, long[] weights)
static double	wtstat(LongVector values, short[] weights)
static double	wtstat(LongVector values, ByteVector weights)
static double	wtstat(LongVector values, DoubleVector weights)
static double	wtstat(LongVector values, FloatVector weights)
static double	wtstat(LongVector values, IntVector weights)
static double	wtstat(LongVector values, LongVector weights)
static double	wtstat(LongVector values, ShortVector weights)
static double	wtstat(ShortVector values, byte[] weights)
static double	wtstat(ShortVector values, double[] weights)
static double	wtstat(ShortVector values, float[] weights)
static double	wtstat(ShortVector values, int[] weights)
static double	wtstat(ShortVector values, long[] weights)
static double	wtstat(ShortVector values, short[] weights)
static double	wtstat(ShortVector values, ByteVector weights)
static double	wtstat(ShortVector values, DoubleVector weights)
static double	wtstat(ShortVector values, FloatVector weights)
static double	wtstat(ShortVector values, IntVector weights)
static double	wtstat(ShortVector values, LongVector weights)
static double	wtstat(ShortVector values, ShortVector weights)
static double	wvar(byte[] values, byte[] weights)
static double	wvar(byte[] values, double[] weights)
static double	wvar(byte[] values, float[] weights)
static double	wvar(byte[] values, int[] weights)
static double	wvar(byte[] values, long[] weights)
static double	wvar(byte[] values, short[] weights)
static double	wvar(byte[] values, ByteVector weights)
static double	wvar(byte[] values, DoubleVector weights)
static double	wvar(byte[] values, FloatVector weights)
static double	wvar(byte[] values, IntVector weights)
static double	wvar(byte[] values, LongVector weights)
static double	wvar(byte[] values, ShortVector weights)
static double	wvar(double[] values, byte[] weights)
static double	wvar(double[] values, double[] weights)
static double	wvar(double[] values, float[] weights)
static double	wvar(double[] values, int[] weights)
static double	wvar(double[] values, long[] weights)
static double	wvar(double[] values, short[] weights)
static double	wvar(double[] values, ByteVector weights)
static double	wvar(double[] values, DoubleVector weights)
static double	wvar(double[] values, FloatVector weights)
static double	wvar(double[] values, IntVector weights)
static double	wvar(double[] values, LongVector weights)
static double	wvar(double[] values, ShortVector weights)
static double	wvar(float[] values, byte[] weights)
static double	wvar(float[] values, double[] weights)
static double	wvar(float[] values, float[] weights)
static double	wvar(float[] values, int[] weights)
static double	wvar(float[] values, long[] weights)
static double	wvar(float[] values, short[] weights)
static double	wvar(float[] values, ByteVector weights)
static double	wvar(float[] values, DoubleVector weights)
static double	wvar(float[] values, FloatVector weights)
static double	wvar(float[] values, IntVector weights)
static double	wvar(float[] values, LongVector weights)
static double	wvar(float[] values, ShortVector weights)
static double	wvar(int[] values, byte[] weights)
static double	wvar(int[] values, double[] weights)
static double	wvar(int[] values, float[] weights)
static double	wvar(int[] values, int[] weights)
static double	wvar(int[] values, long[] weights)
static double	wvar(int[] values, short[] weights)
static double	wvar(int[] values, ByteVector weights)
static double	wvar(int[] values, DoubleVector weights)
static double	wvar(int[] values, FloatVector weights)
static double	wvar(int[] values, IntVector weights)
static double	wvar(int[] values, LongVector weights)
static double	wvar(int[] values, ShortVector weights)
static double	wvar(long[] values, byte[] weights)
static double	wvar(long[] values, double[] weights)
static double	wvar(long[] values, float[] weights)
static double	wvar(long[] values, int[] weights)
static double	wvar(long[] values, long[] weights)
static double	wvar(long[] values, short[] weights)
static double	wvar(long[] values, ByteVector weights)
static double	wvar(long[] values, DoubleVector weights)
static double	wvar(long[] values, FloatVector weights)
static double	wvar(long[] values, IntVector weights)
static double	wvar(long[] values, LongVector weights)
static double	wvar(long[] values, ShortVector weights)
static double	wvar(short[] values, byte[] weights)
static double	wvar(short[] values, double[] weights)
static double	wvar(short[] values, float[] weights)
static double	wvar(short[] values, int[] weights)
static double	wvar(short[] values, long[] weights)
static double	wvar(short[] values, short[] weights)
static double	wvar(short[] values, ByteVector weights)
static double	wvar(short[] values, DoubleVector weights)
static double	wvar(short[] values, FloatVector weights)
static double	wvar(short[] values, IntVector weights)
static double	wvar(short[] values, LongVector weights)
static double	wvar(short[] values, ShortVector weights)
static double	wvar(ByteVector values, byte[] weights)
static double	wvar(ByteVector values, double[] weights)
static double	wvar(ByteVector values, float[] weights)
static double	wvar(ByteVector values, int[] weights)
static double	wvar(ByteVector values, long[] weights)
static double	wvar(ByteVector values, short[] weights)
static double	wvar(ByteVector values, ByteVector weights)
static double	wvar(ByteVector values, DoubleVector weights)
static double	wvar(ByteVector values, FloatVector weights)
static double	wvar(ByteVector values, IntVector weights)
static double	wvar(ByteVector values, LongVector weights)
static double	wvar(ByteVector values, ShortVector weights)
static double	wvar(DoubleVector values, byte[] weights)
static double	wvar(DoubleVector values, double[] weights)
static double	wvar(DoubleVector values, float[] weights)
static double	wvar(DoubleVector values, int[] weights)
static double	wvar(DoubleVector values, long[] weights)
static double	wvar(DoubleVector values, short[] weights)
static double	wvar(DoubleVector values, ByteVector weights)
static double	wvar(DoubleVector values, DoubleVector weights)
static double	wvar(DoubleVector values, FloatVector weights)
static double	wvar(DoubleVector values, IntVector weights)
static double	wvar(DoubleVector values, LongVector weights)
static double	wvar(DoubleVector values, ShortVector weights)
static double	wvar(FloatVector values, byte[] weights)
static double	wvar(FloatVector values, double[] weights)
static double	wvar(FloatVector values, float[] weights)
static double	wvar(FloatVector values, int[] weights)
static double	wvar(FloatVector values, long[] weights)
static double	wvar(FloatVector values, short[] weights)
static double	wvar(FloatVector values, ByteVector weights)
static double	wvar(FloatVector values, DoubleVector weights)
static double	wvar(FloatVector values, FloatVector weights)
static double	wvar(FloatVector values, IntVector weights)
static double	wvar(FloatVector values, LongVector weights)
static double	wvar(FloatVector values, ShortVector weights)
static double	wvar(IntVector values, byte[] weights)
static double	wvar(IntVector values, double[] weights)
static double	wvar(IntVector values, float[] weights)
static double	wvar(IntVector values, int[] weights)
static double	wvar(IntVector values, long[] weights)
static double	wvar(IntVector values, short[] weights)
static double	wvar(IntVector values, ByteVector weights)
static double	wvar(IntVector values, DoubleVector weights)
static double	wvar(IntVector values, FloatVector weights)
static double	wvar(IntVector values, IntVector weights)
static double	wvar(IntVector values, LongVector weights)
static double	wvar(IntVector values, ShortVector weights)
static double	wvar(LongVector values, byte[] weights)
static double	wvar(LongVector values, double[] weights)
static double	wvar(LongVector values, float[] weights)
static double	wvar(LongVector values, int[] weights)
static double	wvar(LongVector values, long[] weights)
static double	wvar(LongVector values, short[] weights)
static double	wvar(LongVector values, ByteVector weights)
static double	wvar(LongVector values, DoubleVector weights)
static double	wvar(LongVector values, FloatVector weights)
static double	wvar(LongVector values, IntVector weights)
static double	wvar(LongVector values, LongVector weights)
static double	wvar(LongVector values, ShortVector weights)
static double	wvar(ShortVector values, byte[] weights)
static double	wvar(ShortVector values, double[] weights)
static double	wvar(ShortVector values, float[] weights)
static double	wvar(ShortVector values, int[] weights)
static double	wvar(ShortVector values, long[] weights)
static double	wvar(ShortVector values, short[] weights)
static double	wvar(ShortVector values, ByteVector weights)
static double	wvar(ShortVector values, DoubleVector weights)
static double	wvar(ShortVector values, FloatVector weights)
static double	wvar(ShortVector values, IntVector weights)
static double	wvar(ShortVector values, LongVector weights)
static double	wvar(ShortVector values, ShortVector weights)

Methods inherited from class java.lang.Object

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

Constructor Details

GroovyStaticImports

public GroovyStaticImports()

Method Details

IEEEremainder

public static double IEEEremainder(double x,
 double y)

See Also:

• Numeric.IEEEremainder(double,double)

IEEEremainder

public static float IEEEremainder(float x,
 float y)

See Also:

• Numeric.IEEEremainder(float,float)

abs

public static byte abs(byte value)

See Also:

• Numeric.abs(byte)

abs

public static double abs(double value)

See Also:

• Numeric.abs(double)

abs

public static float abs(float value)

See Also:

• Numeric.abs(float)

abs

public static int abs(int value)

See Also:

• Numeric.abs(int)

abs

public static long abs(long value)

See Also:

• Numeric.abs(long)

abs

public static short abs(short value)

See Also:

• Numeric.abs(short)

absAvg

public static double absAvg(byte... values)

See Also:

• Numeric.absAvg(byte[])

absAvg

public static double absAvg(double... values)

See Also:

• Numeric.absAvg(double[])

absAvg

public static double absAvg(float... values)

See Also:

• Numeric.absAvg(float[])

absAvg

public static double absAvg(int... values)

See Also:

• Numeric.absAvg(int[])

absAvg

public static double absAvg(long... values)

See Also:

• Numeric.absAvg(long[])

absAvg

public static double absAvg(Byte[] values)

See Also:

• Numeric.absAvg(java.lang.Byte[])

absAvg

public static double absAvg(Double[] values)

See Also:

• Numeric.absAvg(java.lang.Double[])

absAvg

public static double absAvg(Float[] values)

See Also:

• Numeric.absAvg(java.lang.Float[])

absAvg

public static double absAvg(Integer[] values)

See Also:

• Numeric.absAvg(java.lang.Integer[])

absAvg

public static double absAvg(Long[] values)

See Also:

• Numeric.absAvg(java.lang.Long[])

absAvg

public static double absAvg(Short[] values)

See Also:

• Numeric.absAvg(java.lang.Short[])

absAvg

public static double absAvg(short... values)

See Also:

• Numeric.absAvg(short[])

absAvg

public static double absAvg(ByteVector values)

See Also:

• Numeric.absAvg(io.deephaven.vector.ByteVector)

absAvg

public static double absAvg(DoubleVector values)

See Also:

• Numeric.absAvg(io.deephaven.vector.DoubleVector)

absAvg

public static double absAvg(FloatVector values)

See Also:

• Numeric.absAvg(io.deephaven.vector.FloatVector)

absAvg

public static double absAvg(IntVector values)

See Also:

• Numeric.absAvg(io.deephaven.vector.IntVector)

absAvg

public static double absAvg(LongVector values)

See Also:

• Numeric.absAvg(io.deephaven.vector.LongVector)

absAvg

public static double absAvg(ShortVector values)

See Also:

• Numeric.absAvg(io.deephaven.vector.ShortVector)

acos

public static double acos(byte value)

See Also:

• Numeric.acos(byte)

acos

public static double acos(double value)

See Also:

• Numeric.acos(double)

acos

public static double acos(float value)

See Also:

• Numeric.acos(float)

acos

public static double acos(int value)

See Also:

• Numeric.acos(int)

acos

public static double acos(long value)

See Also:

• Numeric.acos(long)

acos

public static double acos(short value)

See Also:

• Numeric.acos(short)

addExact

public static byte addExact(byte x,
 byte y)

See Also:

• Numeric.addExact(byte,byte)

addExact

public static int addExact(int x,
 int y)

See Also:

• Numeric.addExact(int,int)

addExact

public static long addExact(long x,
 long y)

See Also:

• Numeric.addExact(long,long)

addExact

public static short addExact(short x,
 short y)

See Also:

• Numeric.addExact(short,short)

and

public static Boolean and(Boolean... values)

See Also:

• Logic.and(java.lang.Boolean[])

and

public static Boolean and(boolean... values)

See Also:

• Logic.and(boolean[])

and

public static Boolean and(ObjectVector<Boolean> values)

See Also:

• Logic.and(io.deephaven.vector.ObjectVector)

and

public static Boolean and(Boolean[] values,
 Boolean nullValue)

See Also:

• Logic.and(java.lang.Boolean[],java.lang.Boolean)

and

public static Boolean and(ObjectVector<Boolean> values,
 Boolean nullValue)

See Also:

• Logic.and(io.deephaven.vector.ObjectVector,java.lang.Boolean)

array

public static byte[] array(ByteVector values)

See Also:

• Basic.array(io.deephaven.vector.ByteVector)

array

public static char[] array(CharVector values)

See Also:

• Basic.array(io.deephaven.vector.CharVector)

array

public static double[] array(DoubleVector values)

See Also:

• Basic.array(io.deephaven.vector.DoubleVector)

array

public static float[] array(FloatVector values)

See Also:

• Basic.array(io.deephaven.vector.FloatVector)

array

public static int[] array(IntVector values)

See Also:

• Basic.array(io.deephaven.vector.IntVector)

array

public static long[] array(LongVector values)

See Also:

• Basic.array(io.deephaven.vector.LongVector)

array

public static short[] array(ShortVector values)

See Also:

• Basic.array(io.deephaven.vector.ShortVector)

arrayObj

public static <T> T[] arrayObj(ObjectVector<T> values)

See Also:

• Basic.arrayObj(io.deephaven.vector.ObjectVector)

asin

public static double asin(byte value)

See Also:

• Numeric.asin(byte)

asin

public static double asin(double value)

See Also:

• Numeric.asin(double)

asin

public static double asin(float value)

See Also:

• Numeric.asin(float)

asin

public static double asin(int value)

See Also:

• Numeric.asin(int)

asin

public static double asin(long value)

See Also:

• Numeric.asin(long)

asin

public static double asin(short value)

See Also:

• Numeric.asin(short)

atan

public static double atan(byte value)

See Also:

• Numeric.atan(byte)

atan

public static double atan(double value)

See Also:

• Numeric.atan(double)

atan

public static double atan(float value)

See Also:

• Numeric.atan(float)

atan

public static double atan(int value)

See Also:

• Numeric.atan(int)

atan

public static double atan(long value)

See Also:

• Numeric.atan(long)

atan

public static double atan(short value)

See Also:

• Numeric.atan(short)

atan2

public static double atan2(byte y,
 byte x)

See Also:

• Numeric.atan2(byte,byte)

atan2

public static double atan2(double y,
 double x)

See Also:

• Numeric.atan2(double,double)

atan2

public static double atan2(float y,
 float x)

See Also:

• Numeric.atan2(float,float)

atan2

public static double atan2(int y,
 int x)

See Also:

• Numeric.atan2(int,int)

atan2

public static double atan2(long y,
 long x)

See Also:

• Numeric.atan2(long,long)

atan2

public static double atan2(short y,
 short x)

See Also:

• Numeric.atan2(short,short)

avg

public static double avg(byte... values)

See Also:

• Numeric.avg(byte[])

avg

public static double avg(double... values)

See Also:

• Numeric.avg(double[])

avg

public static double avg(float... values)

See Also:

• Numeric.avg(float[])

avg

public static double avg(int... values)

See Also:

• Numeric.avg(int[])

avg

public static double avg(long... values)

See Also:

• Numeric.avg(long[])

avg

public static double avg(Byte[] values)

See Also:

• Numeric.avg(java.lang.Byte[])

avg

public static double avg(Double[] values)

See Also:

• Numeric.avg(java.lang.Double[])

avg

public static double avg(Float[] values)

See Also:

• Numeric.avg(java.lang.Float[])

avg

public static double avg(Integer[] values)

See Also:

• Numeric.avg(java.lang.Integer[])

avg

public static double avg(Long[] values)

See Also:

• Numeric.avg(java.lang.Long[])

avg

public static double avg(Short[] values)

See Also:

• Numeric.avg(java.lang.Short[])

avg

public static double avg(short... values)

See Also:

• Numeric.avg(short[])

avg

public static double avg(ByteVector values)

See Also:

• Numeric.avg(io.deephaven.vector.ByteVector)

avg

public static double avg(DoubleVector values)

See Also:

• Numeric.avg(io.deephaven.vector.DoubleVector)

avg

public static double avg(FloatVector values)

See Also:

• Numeric.avg(io.deephaven.vector.FloatVector)

avg

public static double avg(IntVector values)

See Also:

• Numeric.avg(io.deephaven.vector.IntVector)

avg

public static double avg(LongVector values)

See Also:

• Numeric.avg(io.deephaven.vector.LongVector)

avg

public static double avg(ShortVector values)

See Also:

• Numeric.avg(io.deephaven.vector.ShortVector)

binSearchIndex

public static <T extends Comparable<? super T>> int binSearchIndex(T[] values,
 T key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.binSearchIndex(java.lang.Comparable[],java.lang.Comparable,io.deephaven.function.BinSearchAlgo)

binSearchIndex

public static int binSearchIndex(byte[] values,
 byte key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.binSearchIndex(byte[],byte,io.deephaven.function.BinSearchAlgo)

binSearchIndex

public static int binSearchIndex(char[] values,
 char key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.binSearchIndex(char[],char,io.deephaven.function.BinSearchAlgo)

binSearchIndex

public static int binSearchIndex(double[] values,
 double key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.binSearchIndex(double[],double,io.deephaven.function.BinSearchAlgo)

binSearchIndex

public static int binSearchIndex(float[] values,
 float key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.binSearchIndex(float[],float,io.deephaven.function.BinSearchAlgo)

binSearchIndex

public static int binSearchIndex(int[] values,
 int key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.binSearchIndex(int[],int,io.deephaven.function.BinSearchAlgo)

binSearchIndex

public static int binSearchIndex(long[] values,
 long key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.binSearchIndex(long[],long,io.deephaven.function.BinSearchAlgo)

binSearchIndex

public static int binSearchIndex(short[] values,
 short key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.binSearchIndex(short[],short,io.deephaven.function.BinSearchAlgo)

binSearchIndex

public static int binSearchIndex(ByteVector values,
 byte key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.binSearchIndex(io.deephaven.vector.ByteVector,byte,io.deephaven.function.BinSearchAlgo)

binSearchIndex

public static int binSearchIndex(CharVector values,
 char key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.binSearchIndex(io.deephaven.vector.CharVector,char,io.deephaven.function.BinSearchAlgo)

binSearchIndex

public static int binSearchIndex(DoubleVector values,
 double key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.binSearchIndex(io.deephaven.vector.DoubleVector,double,io.deephaven.function.BinSearchAlgo)

binSearchIndex

public static int binSearchIndex(FloatVector values,
 float key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.binSearchIndex(io.deephaven.vector.FloatVector,float,io.deephaven.function.BinSearchAlgo)

binSearchIndex

public static int binSearchIndex(IntVector values,
 int key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.binSearchIndex(io.deephaven.vector.IntVector,int,io.deephaven.function.BinSearchAlgo)

binSearchIndex

public static int binSearchIndex(LongVector values,
 long key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.binSearchIndex(io.deephaven.vector.LongVector,long,io.deephaven.function.BinSearchAlgo)

binSearchIndex

public static int binSearchIndex(ShortVector values,
 short key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.binSearchIndex(io.deephaven.vector.ShortVector,short,io.deephaven.function.BinSearchAlgo)

binSearchIndex

public static <T extends Comparable<? super T>> int binSearchIndex(ObjectVector<T> values,
 T key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.binSearchIndex(io.deephaven.vector.ObjectVector,java.lang.Comparable,io.deephaven.function.BinSearchAlgo)

castDouble

public static double castDouble(byte value)

See Also:

• Cast.castDouble(byte)

castDouble

public static double[] castDouble(byte... values)

See Also:

• Cast.castDouble(byte[])

castDouble

public static double[] castDouble(double... values)

See Also:

• Cast.castDouble(double[])

castDouble

public static double[] castDouble(float... values)

See Also:

• Cast.castDouble(float[])

castDouble

public static double[] castDouble(int... values)

See Also:

• Cast.castDouble(int[])

castDouble

public static double[] castDouble(long... values)

See Also:

• Cast.castDouble(long[])

castDouble

public static double[] castDouble(short... values)

See Also:

• Cast.castDouble(short[])

castDouble

public static double castDouble(double value)

See Also:

• Cast.castDouble(double)

castDouble

public static double castDouble(float value)

See Also:

• Cast.castDouble(float)

castDouble

public static double castDouble(int value)

See Also:

• Cast.castDouble(int)

castDouble

public static double[] castDouble(ByteVector values)

See Also:

• Cast.castDouble(io.deephaven.vector.ByteVector)

castDouble

public static double[] castDouble(DoubleVector values)

See Also:

• Cast.castDouble(io.deephaven.vector.DoubleVector)

castDouble

public static double[] castDouble(FloatVector values)

See Also:

• Cast.castDouble(io.deephaven.vector.FloatVector)

castDouble

public static double[] castDouble(IntVector values)

See Also:

• Cast.castDouble(io.deephaven.vector.IntVector)

castDouble

public static double[] castDouble(LongVector values)

See Also:

• Cast.castDouble(io.deephaven.vector.LongVector)

castDouble

public static double[] castDouble(ShortVector values)

See Also:

• Cast.castDouble(io.deephaven.vector.ShortVector)

castDouble

public static double castDouble(long value)

See Also:

• Cast.castDouble(long)

castDouble

public static double castDouble(short value)

See Also:

• Cast.castDouble(short)

castDouble

public static double castDouble(byte value,
 boolean checkFidelity)

See Also:

• Cast.castDouble(byte,boolean)

castDouble

public static double[] castDouble(byte[] values,
 boolean checkFidelity)

See Also:

• Cast.castDouble(byte[],boolean)

castDouble

public static double[] castDouble(double[] values,
 boolean checkFidelity)

See Also:

• Cast.castDouble(double[],boolean)

castDouble

public static double[] castDouble(float[] values,
 boolean checkFidelity)

See Also:

• Cast.castDouble(float[],boolean)

castDouble

public static double[] castDouble(int[] values,
 boolean checkFidelity)

See Also:

• Cast.castDouble(int[],boolean)

castDouble

public static double[] castDouble(long[] values,
 boolean checkFidelity)

See Also:

• Cast.castDouble(long[],boolean)

castDouble

public static double[] castDouble(short[] values,
 boolean checkFidelity)

See Also:

• Cast.castDouble(short[],boolean)

castDouble

public static double castDouble(double value,
 boolean checkFidelity)

See Also:

• Cast.castDouble(double,boolean)

castDouble

public static double castDouble(float value,
 boolean checkFidelity)

See Also:

• Cast.castDouble(float,boolean)

castDouble

public static double castDouble(int value,
 boolean checkFidelity)

See Also:

• Cast.castDouble(int,boolean)

castDouble

public static double[] castDouble(ByteVector values,
 boolean checkFidelity)

See Also:

• Cast.castDouble(io.deephaven.vector.ByteVector,boolean)

castDouble

public static double[] castDouble(DoubleVector values,
 boolean checkFidelity)

See Also:

• Cast.castDouble(io.deephaven.vector.DoubleVector,boolean)

castDouble

public static double[] castDouble(FloatVector values,
 boolean checkFidelity)

See Also:

• Cast.castDouble(io.deephaven.vector.FloatVector,boolean)

castDouble

public static double[] castDouble(IntVector values,
 boolean checkFidelity)

See Also:

• Cast.castDouble(io.deephaven.vector.IntVector,boolean)

castDouble

public static double[] castDouble(LongVector values,
 boolean checkFidelity)

See Also:

• Cast.castDouble(io.deephaven.vector.LongVector,boolean)

castDouble

public static double[] castDouble(ShortVector values,
 boolean checkFidelity)

See Also:

• Cast.castDouble(io.deephaven.vector.ShortVector,boolean)

castDouble

public static double castDouble(long value,
 boolean checkFidelity)

See Also:

• Cast.castDouble(long,boolean)

castDouble

public static double castDouble(short value,
 boolean checkFidelity)

See Also:

• Cast.castDouble(short,boolean)

castInt

public static int castInt(byte value)

See Also:

• Cast.castInt(byte)

castInt

public static int[] castInt(byte... values)

See Also:

• Cast.castInt(byte[])

castInt

public static int[] castInt(int... values)

See Also:

• Cast.castInt(int[])

castInt

public static int[] castInt(long... values)

See Also:

• Cast.castInt(long[])

castInt

public static int[] castInt(short... values)

See Also:

• Cast.castInt(short[])

castInt

public static int castInt(int value)

See Also:

• Cast.castInt(int)

castInt

public static int[] castInt(ByteVector values)

See Also:

• Cast.castInt(io.deephaven.vector.ByteVector)

castInt

public static int[] castInt(IntVector values)

See Also:

• Cast.castInt(io.deephaven.vector.IntVector)

castInt

public static int[] castInt(LongVector values)

See Also:

• Cast.castInt(io.deephaven.vector.LongVector)

castInt

public static int[] castInt(ShortVector values)

See Also:

• Cast.castInt(io.deephaven.vector.ShortVector)

castInt

public static int castInt(long value)

See Also:

• Cast.castInt(long)

castInt

public static int castInt(short value)

See Also:

• Cast.castInt(short)

castInt

public static int castInt(byte value,
 boolean checkFidelity)

See Also:

• Cast.castInt(byte,boolean)

castInt

public static int[] castInt(byte[] values,
 boolean checkFidelity)

See Also:

• Cast.castInt(byte[],boolean)

castInt

public static int[] castInt(int[] values,
 boolean checkFidelity)

See Also:

• Cast.castInt(int[],boolean)

castInt

public static int[] castInt(long[] values,
 boolean checkFidelity)

See Also:

• Cast.castInt(long[],boolean)

castInt

public static int[] castInt(short[] values,
 boolean checkFidelity)

See Also:

• Cast.castInt(short[],boolean)

castInt

public static int castInt(int value,
 boolean checkFidelity)

See Also:

• Cast.castInt(int,boolean)

castInt

public static int[] castInt(ByteVector values,
 boolean checkFidelity)

See Also:

• Cast.castInt(io.deephaven.vector.ByteVector,boolean)

castInt

public static int[] castInt(IntVector values,
 boolean checkFidelity)

See Also:

• Cast.castInt(io.deephaven.vector.IntVector,boolean)

castInt

public static int[] castInt(LongVector values,
 boolean checkFidelity)

See Also:

• Cast.castInt(io.deephaven.vector.LongVector,boolean)

castInt

public static int[] castInt(ShortVector values,
 boolean checkFidelity)

See Also:

• Cast.castInt(io.deephaven.vector.ShortVector,boolean)

castInt

public static int castInt(long value,
 boolean checkFidelity)

See Also:

• Cast.castInt(long,boolean)

castInt

public static int castInt(short value,
 boolean checkFidelity)

See Also:

• Cast.castInt(short,boolean)

castLong

public static long castLong(byte value)

See Also:

• Cast.castLong(byte)

castLong

public static long[] castLong(byte... values)

See Also:

• Cast.castLong(byte[])

castLong

public static long[] castLong(int... values)

See Also:

• Cast.castLong(int[])

castLong

public static long[] castLong(long... values)

See Also:

• Cast.castLong(long[])

castLong

public static long[] castLong(short... values)

See Also:

• Cast.castLong(short[])

castLong

public static long castLong(int value)

See Also:

• Cast.castLong(int)

castLong

public static long[] castLong(ByteVector values)

See Also:

• Cast.castLong(io.deephaven.vector.ByteVector)

castLong

public static long[] castLong(IntVector values)

See Also:

• Cast.castLong(io.deephaven.vector.IntVector)

castLong

public static long[] castLong(LongVector values)

See Also:

• Cast.castLong(io.deephaven.vector.LongVector)

castLong

public static long[] castLong(ShortVector values)

See Also:

• Cast.castLong(io.deephaven.vector.ShortVector)

castLong

public static long castLong(long value)

See Also:

• Cast.castLong(long)

castLong

public static long castLong(short value)

See Also:

• Cast.castLong(short)

castLong

public static long castLong(byte value,
 boolean checkFidelity)

See Also:

• Cast.castLong(byte,boolean)

castLong

public static long[] castLong(byte[] values,
 boolean checkFidelity)

See Also:

• Cast.castLong(byte[],boolean)

castLong

public static long[] castLong(int[] values,
 boolean checkFidelity)

See Also:

• Cast.castLong(int[],boolean)

castLong

public static long[] castLong(long[] values,
 boolean checkFidelity)

See Also:

• Cast.castLong(long[],boolean)

castLong

public static long[] castLong(short[] values,
 boolean checkFidelity)

See Also:

• Cast.castLong(short[],boolean)

castLong

public static long castLong(int value,
 boolean checkFidelity)

See Also:

• Cast.castLong(int,boolean)

castLong

public static long[] castLong(ByteVector values,
 boolean checkFidelity)

See Also:

• Cast.castLong(io.deephaven.vector.ByteVector,boolean)

castLong

public static long[] castLong(IntVector values,
 boolean checkFidelity)

See Also:

• Cast.castLong(io.deephaven.vector.IntVector,boolean)

castLong

public static long[] castLong(LongVector values,
 boolean checkFidelity)

See Also:

• Cast.castLong(io.deephaven.vector.LongVector,boolean)

castLong

public static long[] castLong(ShortVector values,
 boolean checkFidelity)

See Also:

• Cast.castLong(io.deephaven.vector.ShortVector,boolean)

castLong

public static long castLong(long value,
 boolean checkFidelity)

See Also:

• Cast.castLong(long,boolean)

castLong

public static long castLong(short value,
 boolean checkFidelity)

See Also:

• Cast.castLong(short,boolean)

cbrt

public static double cbrt(byte x)

See Also:

• Numeric.cbrt(byte)

cbrt

public static double cbrt(double x)

See Also:

• Numeric.cbrt(double)

cbrt

public static double cbrt(float x)

See Also:

• Numeric.cbrt(float)

cbrt

public static double cbrt(int x)

See Also:

• Numeric.cbrt(int)

cbrt

public static double cbrt(long x)

See Also:

• Numeric.cbrt(long)

cbrt

public static double cbrt(short x)

See Also:

• Numeric.cbrt(short)

ceil

public static double ceil(byte value)

See Also:

• Numeric.ceil(byte)

ceil

public static double ceil(double value)

See Also:

• Numeric.ceil(double)

ceil

public static double ceil(float value)

See Also:

• Numeric.ceil(float)

ceil

public static double ceil(int value)

See Also:

• Numeric.ceil(int)

ceil

public static double ceil(long value)

See Also:

• Numeric.ceil(long)

ceil

public static double ceil(short value)

See Also:

• Numeric.ceil(short)

clamp

public static byte clamp(byte value,
 byte min,
 byte max)

See Also:

• Numeric.clamp(byte,byte,byte)

clamp

public static double clamp(double value,
 double min,
 double max)

See Also:

• Numeric.clamp(double,double,double)

clamp

public static float clamp(float value,
 float min,
 float max)

See Also:

• Numeric.clamp(float,float,float)

clamp

public static int clamp(int value,
 int min,
 int max)

See Also:

• Numeric.clamp(int,int,int)

clamp

public static long clamp(long value,
 long min,
 long max)

See Also:

• Numeric.clamp(long,long,long)

clamp

public static short clamp(short value,
 short min,
 short max)

See Also:

• Numeric.clamp(short,short,short)

compare

public static int compare(byte v1,
 byte v2)

See Also:

• Numeric.compare(byte,byte)

compare

public static int compare(Byte v1,
 Byte v2)

See Also:

• Numeric.compare(java.lang.Byte,java.lang.Byte)

compare

public static int compare(Double v1,
 Double v2)

See Also:

• Numeric.compare(java.lang.Double,java.lang.Double)

compare

public static int compare(Float v1,
 Float v2)

See Also:

• Numeric.compare(java.lang.Float,java.lang.Float)

compare

public static int compare(Integer v1,
 Integer v2)

See Also:

• Numeric.compare(java.lang.Integer,java.lang.Integer)

compare

public static int compare(Long v1,
 Long v2)

See Also:

• Numeric.compare(java.lang.Long,java.lang.Long)

compare

public static int compare(Short v1,
 Short v2)

See Also:

• Numeric.compare(java.lang.Short,java.lang.Short)

compare

public static int compare(double v1,
 double v2)

See Also:

• Numeric.compare(double,double)

compare

public static int compare(float v1,
 float v2)

See Also:

• Numeric.compare(float,float)

compare

public static int compare(int v1,
 int v2)

See Also:

• Numeric.compare(int,int)

compare

public static int compare(long v1,
 long v2)

See Also:

• Numeric.compare(long,long)

compare

public static int compare(short v1,
 short v2)

See Also:

• Numeric.compare(short,short)

concat

public static <T> T[] concat(T[]... values)

See Also:

• Basic.concat(java.lang.Object[][])

concat

public static byte[] concat(ByteVector... values)

See Also:

• Basic.concat(io.deephaven.vector.ByteVector[])

concat

public static char[] concat(CharVector... values)

See Also:

• Basic.concat(io.deephaven.vector.CharVector[])

concat

public static double[] concat(DoubleVector... values)

See Also:

• Basic.concat(io.deephaven.vector.DoubleVector[])

concat

public static float[] concat(FloatVector... values)

See Also:

• Basic.concat(io.deephaven.vector.FloatVector[])

concat

public static int[] concat(IntVector... values)

See Also:

• Basic.concat(io.deephaven.vector.IntVector[])

concat

public static long[] concat(LongVector... values)

See Also:

• Basic.concat(io.deephaven.vector.LongVector[])

concat

public static short[] concat(ShortVector... values)

See Also:

• Basic.concat(io.deephaven.vector.ShortVector[])

concat

public static byte[] concat(byte[]... values)

See Also:

• Basic.concat(byte[][])

concat

public static char[] concat(char[]... values)

See Also:

• Basic.concat(char[][])

concat

public static double[] concat(double[]... values)

See Also:

• Basic.concat(double[][])

concat

public static float[] concat(float[]... values)

See Also:

• Basic.concat(float[][])

concat

public static int[] concat(int[]... values)

See Also:

• Basic.concat(int[][])

concat

public static long[] concat(long[]... values)

See Also:

• Basic.concat(long[][])

concat

public static short[] concat(short[]... values)

See Also:

• Basic.concat(short[][])

concat

public static <T> T[] concat(ObjectVector<T>... values)

See Also:

• Basic.concat(io.deephaven.vector.ObjectVector[])

containsNonFinite

public static boolean containsNonFinite(byte... values)

See Also:

• Numeric.containsNonFinite(byte[])

containsNonFinite

public static boolean containsNonFinite(double... values)

See Also:

• Numeric.containsNonFinite(double[])

containsNonFinite

public static boolean containsNonFinite(float... values)

See Also:

• Numeric.containsNonFinite(float[])

containsNonFinite

public static boolean containsNonFinite(int... values)

See Also:

• Numeric.containsNonFinite(int[])

containsNonFinite

public static boolean containsNonFinite(long... values)

See Also:

• Numeric.containsNonFinite(long[])

containsNonFinite

public static boolean containsNonFinite(Byte[] values)

See Also:

• Numeric.containsNonFinite(java.lang.Byte[])

containsNonFinite

public static boolean containsNonFinite(Double[] values)

See Also:

• Numeric.containsNonFinite(java.lang.Double[])

containsNonFinite

public static boolean containsNonFinite(Float[] values)

See Also:

• Numeric.containsNonFinite(java.lang.Float[])

containsNonFinite

public static boolean containsNonFinite(Integer[] values)

See Also:

• Numeric.containsNonFinite(java.lang.Integer[])

containsNonFinite

public static boolean containsNonFinite(Long[] values)

See Also:

• Numeric.containsNonFinite(java.lang.Long[])

containsNonFinite

public static boolean containsNonFinite(Short[] values)

See Also:

• Numeric.containsNonFinite(java.lang.Short[])

containsNonFinite

public static boolean containsNonFinite(short... values)

See Also:

• Numeric.containsNonFinite(short[])

copySign

public static byte copySign(byte magnitude,
 byte sign)

See Also:

• Numeric.copySign(byte,byte)

copySign

public static double copySign(double magnitude,
 double sign)

See Also:

• Numeric.copySign(double,double)

copySign

public static float copySign(float magnitude,
 float sign)

See Also:

• Numeric.copySign(float,float)

copySign

public static int copySign(int magnitude,
 int sign)

See Also:

• Numeric.copySign(int,int)

copySign

public static long copySign(long magnitude,
 long sign)

See Also:

• Numeric.copySign(long,long)

copySign

public static short copySign(short magnitude,
 short sign)

See Also:

• Numeric.copySign(short,short)

cor

public static double cor(byte[] values0,
 byte[] values1)

See Also:

• Numeric.cor(byte[],byte[])

cor

public static double cor(byte[] values0,
 double[] values1)

See Also:

• Numeric.cor(byte[],double[])

cor

public static double cor(byte[] values0,
 float[] values1)

See Also:

• Numeric.cor(byte[],float[])

cor

public static double cor(byte[] values0,
 int[] values1)

See Also:

• Numeric.cor(byte[],int[])

cor

public static double cor(byte[] values0,
 long[] values1)

See Also:

• Numeric.cor(byte[],long[])

cor

public static double cor(byte[] values0,
 short[] values1)

See Also:

• Numeric.cor(byte[],short[])

cor

public static double cor(byte[] values0,
 ByteVector values1)

See Also:

• Numeric.cor(byte[],io.deephaven.vector.ByteVector)

cor

public static double cor(byte[] values0,
 DoubleVector values1)

See Also:

• Numeric.cor(byte[],io.deephaven.vector.DoubleVector)

cor

public static double cor(byte[] values0,
 FloatVector values1)

See Also:

• Numeric.cor(byte[],io.deephaven.vector.FloatVector)

cor

public static double cor(byte[] values0,
 IntVector values1)

See Also:

• Numeric.cor(byte[],io.deephaven.vector.IntVector)

cor

public static double cor(byte[] values0,
 LongVector values1)

See Also:

• Numeric.cor(byte[],io.deephaven.vector.LongVector)

cor

public static double cor(byte[] values0,
 ShortVector values1)

See Also:

• Numeric.cor(byte[],io.deephaven.vector.ShortVector)

cor

public static double cor(double[] values0,
 byte[] values1)

See Also:

• Numeric.cor(double[],byte[])

cor

public static double cor(double[] values0,
 double[] values1)

See Also:

• Numeric.cor(double[],double[])

cor

public static double cor(double[] values0,
 float[] values1)

See Also:

• Numeric.cor(double[],float[])

cor

public static double cor(double[] values0,
 int[] values1)

See Also:

• Numeric.cor(double[],int[])

cor

public static double cor(double[] values0,
 long[] values1)

See Also:

• Numeric.cor(double[],long[])

cor

public static double cor(double[] values0,
 short[] values1)

See Also:

• Numeric.cor(double[],short[])

cor

public static double cor(double[] values0,
 ByteVector values1)

See Also:

• Numeric.cor(double[],io.deephaven.vector.ByteVector)

cor

public static double cor(double[] values0,
 DoubleVector values1)

See Also:

• Numeric.cor(double[],io.deephaven.vector.DoubleVector)

cor

public static double cor(double[] values0,
 FloatVector values1)

See Also:

• Numeric.cor(double[],io.deephaven.vector.FloatVector)

cor

public static double cor(double[] values0,
 IntVector values1)

See Also:

• Numeric.cor(double[],io.deephaven.vector.IntVector)

cor

public static double cor(double[] values0,
 LongVector values1)

See Also:

• Numeric.cor(double[],io.deephaven.vector.LongVector)

cor

public static double cor(double[] values0,
 ShortVector values1)

See Also:

• Numeric.cor(double[],io.deephaven.vector.ShortVector)

cor

public static double cor(float[] values0,
 byte[] values1)

See Also:

• Numeric.cor(float[],byte[])

cor

public static double cor(float[] values0,
 double[] values1)

See Also:

• Numeric.cor(float[],double[])

cor

public static double cor(float[] values0,
 float[] values1)

See Also:

• Numeric.cor(float[],float[])

cor

public static double cor(float[] values0,
 int[] values1)

See Also:

• Numeric.cor(float[],int[])

cor

public static double cor(float[] values0,
 long[] values1)

See Also:

• Numeric.cor(float[],long[])

cor

public static double cor(float[] values0,
 short[] values1)

See Also:

• Numeric.cor(float[],short[])

cor

public static double cor(float[] values0,
 ByteVector values1)

See Also:

• Numeric.cor(float[],io.deephaven.vector.ByteVector)

cor

public static double cor(float[] values0,
 DoubleVector values1)

See Also:

• Numeric.cor(float[],io.deephaven.vector.DoubleVector)

cor

public static double cor(float[] values0,
 FloatVector values1)

See Also:

• Numeric.cor(float[],io.deephaven.vector.FloatVector)

cor

public static double cor(float[] values0,
 IntVector values1)

See Also:

• Numeric.cor(float[],io.deephaven.vector.IntVector)

cor

public static double cor(float[] values0,
 LongVector values1)

See Also:

• Numeric.cor(float[],io.deephaven.vector.LongVector)

cor

public static double cor(float[] values0,
 ShortVector values1)

See Also:

• Numeric.cor(float[],io.deephaven.vector.ShortVector)

cor

public static double cor(int[] values0,
 byte[] values1)

See Also:

• Numeric.cor(int[],byte[])

cor

public static double cor(int[] values0,
 double[] values1)

See Also:

• Numeric.cor(int[],double[])

cor

public static double cor(int[] values0,
 float[] values1)

See Also:

• Numeric.cor(int[],float[])

cor

public static double cor(int[] values0,
 int[] values1)

See Also:

• Numeric.cor(int[],int[])

cor

public static double cor(int[] values0,
 long[] values1)

See Also:

• Numeric.cor(int[],long[])

cor

public static double cor(int[] values0,
 short[] values1)

See Also:

• Numeric.cor(int[],short[])

cor

public static double cor(int[] values0,
 ByteVector values1)

See Also:

• Numeric.cor(int[],io.deephaven.vector.ByteVector)

cor

public static double cor(int[] values0,
 DoubleVector values1)

See Also:

• Numeric.cor(int[],io.deephaven.vector.DoubleVector)

cor

public static double cor(int[] values0,
 FloatVector values1)

See Also:

• Numeric.cor(int[],io.deephaven.vector.FloatVector)

cor

public static double cor(int[] values0,
 IntVector values1)

See Also:

• Numeric.cor(int[],io.deephaven.vector.IntVector)

cor

public static double cor(int[] values0,
 LongVector values1)

See Also:

• Numeric.cor(int[],io.deephaven.vector.LongVector)

cor

public static double cor(int[] values0,
 ShortVector values1)

See Also:

• Numeric.cor(int[],io.deephaven.vector.ShortVector)

cor

public static double cor(long[] values0,
 byte[] values1)

See Also:

• Numeric.cor(long[],byte[])

cor

public static double cor(long[] values0,
 double[] values1)

See Also:

• Numeric.cor(long[],double[])

cor

public static double cor(long[] values0,
 float[] values1)

See Also:

• Numeric.cor(long[],float[])

cor

public static double cor(long[] values0,
 int[] values1)

See Also:

• Numeric.cor(long[],int[])

cor

public static double cor(long[] values0,
 long[] values1)

See Also:

• Numeric.cor(long[],long[])

cor

public static double cor(long[] values0,
 short[] values1)

See Also:

• Numeric.cor(long[],short[])

cor

public static double cor(long[] values0,
 ByteVector values1)

See Also:

• Numeric.cor(long[],io.deephaven.vector.ByteVector)

cor

public static double cor(long[] values0,
 DoubleVector values1)

See Also:

• Numeric.cor(long[],io.deephaven.vector.DoubleVector)

cor

public static double cor(long[] values0,
 FloatVector values1)

See Also:

• Numeric.cor(long[],io.deephaven.vector.FloatVector)

cor

public static double cor(long[] values0,
 IntVector values1)

See Also:

• Numeric.cor(long[],io.deephaven.vector.IntVector)

cor

public static double cor(long[] values0,
 LongVector values1)

See Also:

• Numeric.cor(long[],io.deephaven.vector.LongVector)

cor

public static double cor(long[] values0,
 ShortVector values1)

See Also:

• Numeric.cor(long[],io.deephaven.vector.ShortVector)

cor

public static double cor(short[] values0,
 byte[] values1)

See Also:

• Numeric.cor(short[],byte[])

cor

public static double cor(short[] values0,
 double[] values1)

See Also:

• Numeric.cor(short[],double[])

cor

public static double cor(short[] values0,
 float[] values1)

See Also:

• Numeric.cor(short[],float[])

cor

public static double cor(short[] values0,
 int[] values1)

See Also:

• Numeric.cor(short[],int[])

cor

public static double cor(short[] values0,
 long[] values1)

See Also:

• Numeric.cor(short[],long[])

cor

public static double cor(short[] values0,
 short[] values1)

See Also:

• Numeric.cor(short[],short[])

cor

public static double cor(short[] values0,
 ByteVector values1)

See Also:

• Numeric.cor(short[],io.deephaven.vector.ByteVector)

cor

public static double cor(short[] values0,
 DoubleVector values1)

See Also:

• Numeric.cor(short[],io.deephaven.vector.DoubleVector)

cor

public static double cor(short[] values0,
 FloatVector values1)

See Also:

• Numeric.cor(short[],io.deephaven.vector.FloatVector)

cor

public static double cor(short[] values0,
 IntVector values1)

See Also:

• Numeric.cor(short[],io.deephaven.vector.IntVector)

cor

public static double cor(short[] values0,
 LongVector values1)

See Also:

• Numeric.cor(short[],io.deephaven.vector.LongVector)

cor

public static double cor(short[] values0,
 ShortVector values1)

See Also:

• Numeric.cor(short[],io.deephaven.vector.ShortVector)

cor

public static double cor(ByteVector values0,
 byte[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.ByteVector,byte[])

cor

public static double cor(ByteVector values0,
 double[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.ByteVector,double[])

cor

public static double cor(ByteVector values0,
 float[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.ByteVector,float[])

cor

public static double cor(ByteVector values0,
 int[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.ByteVector,int[])

cor

public static double cor(ByteVector values0,
 long[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.ByteVector,long[])

cor

public static double cor(ByteVector values0,
 short[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.ByteVector,short[])

cor

public static double cor(ByteVector values0,
 ByteVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.ByteVector,io.deephaven.vector.ByteVector)

cor

public static double cor(ByteVector values0,
 DoubleVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.ByteVector,io.deephaven.vector.DoubleVector)

cor

public static double cor(ByteVector values0,
 FloatVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.ByteVector,io.deephaven.vector.FloatVector)

cor

public static double cor(ByteVector values0,
 IntVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.ByteVector,io.deephaven.vector.IntVector)

cor

public static double cor(ByteVector values0,
 LongVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.ByteVector,io.deephaven.vector.LongVector)

cor

public static double cor(ByteVector values0,
 ShortVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.ByteVector,io.deephaven.vector.ShortVector)

cor

public static double cor(DoubleVector values0,
 byte[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.DoubleVector,byte[])

cor

public static double cor(DoubleVector values0,
 double[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.DoubleVector,double[])

cor

public static double cor(DoubleVector values0,
 float[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.DoubleVector,float[])

cor

public static double cor(DoubleVector values0,
 int[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.DoubleVector,int[])

cor

public static double cor(DoubleVector values0,
 long[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.DoubleVector,long[])

cor

public static double cor(DoubleVector values0,
 short[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.DoubleVector,short[])

cor

public static double cor(DoubleVector values0,
 ByteVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.DoubleVector,io.deephaven.vector.ByteVector)

cor

public static double cor(DoubleVector values0,
 DoubleVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.DoubleVector,io.deephaven.vector.DoubleVector)

cor

public static double cor(DoubleVector values0,
 FloatVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.DoubleVector,io.deephaven.vector.FloatVector)

cor

public static double cor(DoubleVector values0,
 IntVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.DoubleVector,io.deephaven.vector.IntVector)

cor

public static double cor(DoubleVector values0,
 LongVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.DoubleVector,io.deephaven.vector.LongVector)

cor

public static double cor(DoubleVector values0,
 ShortVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.DoubleVector,io.deephaven.vector.ShortVector)

cor

public static double cor(FloatVector values0,
 byte[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.FloatVector,byte[])

cor

public static double cor(FloatVector values0,
 double[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.FloatVector,double[])

cor

public static double cor(FloatVector values0,
 float[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.FloatVector,float[])

cor

public static double cor(FloatVector values0,
 int[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.FloatVector,int[])

cor

public static double cor(FloatVector values0,
 long[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.FloatVector,long[])

cor

public static double cor(FloatVector values0,
 short[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.FloatVector,short[])

cor

public static double cor(FloatVector values0,
 ByteVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.FloatVector,io.deephaven.vector.ByteVector)

cor

public static double cor(FloatVector values0,
 DoubleVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.FloatVector,io.deephaven.vector.DoubleVector)

cor

public static double cor(FloatVector values0,
 FloatVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.FloatVector,io.deephaven.vector.FloatVector)

cor

public static double cor(FloatVector values0,
 IntVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.FloatVector,io.deephaven.vector.IntVector)

cor

public static double cor(FloatVector values0,
 LongVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.FloatVector,io.deephaven.vector.LongVector)

cor

public static double cor(FloatVector values0,
 ShortVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.FloatVector,io.deephaven.vector.ShortVector)

cor

public static double cor(IntVector values0,
 byte[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.IntVector,byte[])

cor

public static double cor(IntVector values0,
 double[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.IntVector,double[])

cor

public static double cor(IntVector values0,
 float[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.IntVector,float[])

cor

public static double cor(IntVector values0,
 int[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.IntVector,int[])

cor

public static double cor(IntVector values0,
 long[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.IntVector,long[])

cor

public static double cor(IntVector values0,
 short[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.IntVector,short[])

cor

public static double cor(IntVector values0,
 ByteVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.IntVector,io.deephaven.vector.ByteVector)

cor

public static double cor(IntVector values0,
 DoubleVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.IntVector,io.deephaven.vector.DoubleVector)

cor

public static double cor(IntVector values0,
 FloatVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.IntVector,io.deephaven.vector.FloatVector)

cor

public static double cor(IntVector values0,
 IntVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.IntVector,io.deephaven.vector.IntVector)

cor

public static double cor(IntVector values0,
 LongVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.IntVector,io.deephaven.vector.LongVector)

cor

public static double cor(IntVector values0,
 ShortVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.IntVector,io.deephaven.vector.ShortVector)

cor

public static double cor(LongVector values0,
 byte[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.LongVector,byte[])

cor

public static double cor(LongVector values0,
 double[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.LongVector,double[])

cor

public static double cor(LongVector values0,
 float[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.LongVector,float[])

cor

public static double cor(LongVector values0,
 int[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.LongVector,int[])

cor

public static double cor(LongVector values0,
 long[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.LongVector,long[])

cor

public static double cor(LongVector values0,
 short[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.LongVector,short[])

cor

public static double cor(LongVector values0,
 ByteVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.LongVector,io.deephaven.vector.ByteVector)

cor

public static double cor(LongVector values0,
 DoubleVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.LongVector,io.deephaven.vector.DoubleVector)

cor

public static double cor(LongVector values0,
 FloatVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.LongVector,io.deephaven.vector.FloatVector)

cor

public static double cor(LongVector values0,
 IntVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.LongVector,io.deephaven.vector.IntVector)

cor

public static double cor(LongVector values0,
 LongVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.LongVector,io.deephaven.vector.LongVector)

cor

public static double cor(LongVector values0,
 ShortVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.LongVector,io.deephaven.vector.ShortVector)

cor

public static double cor(ShortVector values0,
 byte[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.ShortVector,byte[])

cor

public static double cor(ShortVector values0,
 double[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.ShortVector,double[])

cor

public static double cor(ShortVector values0,
 float[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.ShortVector,float[])

cor

public static double cor(ShortVector values0,
 int[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.ShortVector,int[])

cor

public static double cor(ShortVector values0,
 long[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.ShortVector,long[])

cor

public static double cor(ShortVector values0,
 short[] values1)

See Also:

• Numeric.cor(io.deephaven.vector.ShortVector,short[])

cor

public static double cor(ShortVector values0,
 ByteVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.ShortVector,io.deephaven.vector.ByteVector)

cor

public static double cor(ShortVector values0,
 DoubleVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.ShortVector,io.deephaven.vector.DoubleVector)

cor

public static double cor(ShortVector values0,
 FloatVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.ShortVector,io.deephaven.vector.FloatVector)

cor

public static double cor(ShortVector values0,
 IntVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.ShortVector,io.deephaven.vector.IntVector)

cor

public static double cor(ShortVector values0,
 LongVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.ShortVector,io.deephaven.vector.LongVector)

cor

public static double cor(ShortVector values0,
 ShortVector values1)

See Also:

• Numeric.cor(io.deephaven.vector.ShortVector,io.deephaven.vector.ShortVector)

cos

public static double cos(byte value)

See Also:

• Numeric.cos(byte)

cos

public static double cos(double value)

See Also:

• Numeric.cos(double)

cos

public static double cos(float value)

See Also:

• Numeric.cos(float)

cos

public static double cos(int value)

See Also:

• Numeric.cos(int)

cos

public static double cos(long value)

See Also:

• Numeric.cos(long)

cos

public static double cos(short value)

See Also:

• Numeric.cos(short)

cosh

public static double cosh(byte x)

See Also:

• Numeric.cosh(byte)

cosh

public static double cosh(double x)

See Also:

• Numeric.cosh(double)

cosh

public static double cosh(float x)

See Also:

• Numeric.cosh(float)

cosh

public static double cosh(int x)

See Also:

• Numeric.cosh(int)

cosh

public static double cosh(long x)

See Also:

• Numeric.cosh(long)

cosh

public static double cosh(short x)

See Also:

• Numeric.cosh(short)

count

public static long count(byte... values)

See Also:

• Basic.count(byte[])

count

public static long count(char... values)

See Also:

• Basic.count(char[])

count

public static long count(double... values)

See Also:

• Basic.count(double[])

count

public static long count(float... values)

See Also:

• Basic.count(float[])

count

public static long count(int... values)

See Also:

• Basic.count(int[])

count

public static long count(long... values)

See Also:

• Basic.count(long[])

count

public static long count(short... values)

See Also:

• Basic.count(short[])

count

public static long count(ByteVector values)

See Also:

• Basic.count(io.deephaven.vector.ByteVector)

count

public static long count(CharVector values)

See Also:

• Basic.count(io.deephaven.vector.CharVector)

count

public static long count(DoubleVector values)

See Also:

• Basic.count(io.deephaven.vector.DoubleVector)

count

public static long count(FloatVector values)

See Also:

• Basic.count(io.deephaven.vector.FloatVector)

count

public static long count(IntVector values)

See Also:

• Basic.count(io.deephaven.vector.IntVector)

count

public static long count(LongVector values)

See Also:

• Basic.count(io.deephaven.vector.LongVector)

count

public static long count(ShortVector values)

See Also:

• Basic.count(io.deephaven.vector.ShortVector)

countDistinct

public static long countDistinct(byte... values)

See Also:

• Basic.countDistinct(byte[])

countDistinct

public static long countDistinct(char... values)

See Also:

• Basic.countDistinct(char[])

countDistinct

public static long countDistinct(double... values)

See Also:

• Basic.countDistinct(double[])

countDistinct

public static long countDistinct(float... values)

See Also:

• Basic.countDistinct(float[])

countDistinct

public static long countDistinct(int... values)

See Also:

• Basic.countDistinct(int[])

countDistinct

public static long countDistinct(long... values)

See Also:

• Basic.countDistinct(long[])

countDistinct

public static long countDistinct(short... values)

See Also:

• Basic.countDistinct(short[])

countDistinct

public static long countDistinct(ByteVector values)

See Also:

• Basic.countDistinct(io.deephaven.vector.ByteVector)

countDistinct

public static long countDistinct(CharVector values)

See Also:

• Basic.countDistinct(io.deephaven.vector.CharVector)

countDistinct

public static long countDistinct(DoubleVector values)

See Also:

• Basic.countDistinct(io.deephaven.vector.DoubleVector)

countDistinct

public static long countDistinct(FloatVector values)

See Also:

• Basic.countDistinct(io.deephaven.vector.FloatVector)

countDistinct

public static long countDistinct(IntVector values)

See Also:

• Basic.countDistinct(io.deephaven.vector.IntVector)

countDistinct

public static long countDistinct(LongVector values)

See Also:

• Basic.countDistinct(io.deephaven.vector.LongVector)

countDistinct

public static long countDistinct(ShortVector values)

See Also:

• Basic.countDistinct(io.deephaven.vector.ShortVector)

countDistinct

public static long countDistinct(byte[] values,
 boolean countNull)

See Also:

• Basic.countDistinct(byte[],boolean)

countDistinct

public static long countDistinct(char[] values,
 boolean countNull)

See Also:

• Basic.countDistinct(char[],boolean)

countDistinct

public static long countDistinct(double[] values,
 boolean countNull)

See Also:

• Basic.countDistinct(double[],boolean)

countDistinct

public static long countDistinct(float[] values,
 boolean countNull)

See Also:

• Basic.countDistinct(float[],boolean)

countDistinct

public static long countDistinct(int[] values,
 boolean countNull)

See Also:

• Basic.countDistinct(int[],boolean)

countDistinct

public static long countDistinct(long[] values,
 boolean countNull)

See Also:

• Basic.countDistinct(long[],boolean)

countDistinct

public static long countDistinct(short[] values,
 boolean countNull)

See Also:

• Basic.countDistinct(short[],boolean)

countDistinct

public static long countDistinct(ByteVector values,
 boolean countNull)

See Also:

• Basic.countDistinct(io.deephaven.vector.ByteVector,boolean)

countDistinct

public static long countDistinct(CharVector values,
 boolean countNull)

See Also:

• Basic.countDistinct(io.deephaven.vector.CharVector,boolean)

countDistinct

public static long countDistinct(DoubleVector values,
 boolean countNull)

See Also:

• Basic.countDistinct(io.deephaven.vector.DoubleVector,boolean)

countDistinct

public static long countDistinct(FloatVector values,
 boolean countNull)

See Also:

• Basic.countDistinct(io.deephaven.vector.FloatVector,boolean)

countDistinct

public static long countDistinct(IntVector values,
 boolean countNull)

See Also:

• Basic.countDistinct(io.deephaven.vector.IntVector,boolean)

countDistinct

public static long countDistinct(LongVector values,
 boolean countNull)

See Also:

• Basic.countDistinct(io.deephaven.vector.LongVector,boolean)

countDistinct

public static long countDistinct(ShortVector values,
 boolean countNull)

See Also:

• Basic.countDistinct(io.deephaven.vector.ShortVector,boolean)

countDistinctObj

public static <T extends Comparable<? super T>>
long countDistinctObj(T... values)

See Also:

• Basic.countDistinctObj(java.lang.Comparable[])

countDistinctObj

public static <T extends Comparable<? super T>>
long countDistinctObj(ObjectVector<T> values)

See Also:

• Basic.countDistinctObj(io.deephaven.vector.ObjectVector)

countDistinctObj

public static <T extends Comparable<? super T>>
long countDistinctObj(T[] values,
 boolean countNull)

See Also:

• Basic.countDistinctObj(java.lang.Comparable[],boolean)

countDistinctObj

public static <T extends Comparable<? super T>>
long countDistinctObj(ObjectVector<T> values,
 boolean countNull)

See Also:

• Basic.countDistinctObj(io.deephaven.vector.ObjectVector,boolean)

countNeg

public static long countNeg(byte... values)

See Also:

• Numeric.countNeg(byte[])

countNeg

public static long countNeg(double... values)

See Also:

• Numeric.countNeg(double[])

countNeg

public static long countNeg(float... values)

See Also:

• Numeric.countNeg(float[])

countNeg

public static long countNeg(int... values)

See Also:

• Numeric.countNeg(int[])

countNeg

public static long countNeg(long... values)

See Also:

• Numeric.countNeg(long[])

countNeg

public static long countNeg(Byte[] values)

See Also:

• Numeric.countNeg(java.lang.Byte[])

countNeg

public static long countNeg(Double[] values)

See Also:

• Numeric.countNeg(java.lang.Double[])

countNeg

public static long countNeg(Float[] values)

See Also:

• Numeric.countNeg(java.lang.Float[])

countNeg

public static long countNeg(Integer[] values)

See Also:

• Numeric.countNeg(java.lang.Integer[])

countNeg

public static long countNeg(Long[] values)

See Also:

• Numeric.countNeg(java.lang.Long[])

countNeg

public static long countNeg(Short[] values)

See Also:

• Numeric.countNeg(java.lang.Short[])

countNeg

public static long countNeg(short... values)

See Also:

• Numeric.countNeg(short[])

countNeg

public static long countNeg(ByteVector values)

See Also:

• Numeric.countNeg(io.deephaven.vector.ByteVector)

countNeg

public static long countNeg(DoubleVector values)

See Also:

• Numeric.countNeg(io.deephaven.vector.DoubleVector)

countNeg

public static long countNeg(FloatVector values)

See Also:

• Numeric.countNeg(io.deephaven.vector.FloatVector)

countNeg

public static long countNeg(IntVector values)

See Also:

• Numeric.countNeg(io.deephaven.vector.IntVector)

countNeg

public static long countNeg(LongVector values)

See Also:

• Numeric.countNeg(io.deephaven.vector.LongVector)

countNeg

public static long countNeg(ShortVector values)

See Also:

• Numeric.countNeg(io.deephaven.vector.ShortVector)

countObj

public static <T> long countObj(T... values)

See Also:

• Basic.countObj(java.lang.Object[])

countObj

public static <T> long countObj(ObjectVector<T> values)

See Also:

• Basic.countObj(io.deephaven.vector.ObjectVector)

countPos

public static long countPos(byte... values)

See Also:

• Numeric.countPos(byte[])

countPos

public static long countPos(double... values)

See Also:

• Numeric.countPos(double[])

countPos

public static long countPos(float... values)

See Also:

• Numeric.countPos(float[])

countPos

public static long countPos(int... values)

See Also:

• Numeric.countPos(int[])

countPos

public static long countPos(long... values)

See Also:

• Numeric.countPos(long[])

countPos

public static long countPos(Byte[] values)

See Also:

• Numeric.countPos(java.lang.Byte[])

countPos

public static long countPos(Double[] values)

See Also:

• Numeric.countPos(java.lang.Double[])

countPos

public static long countPos(Float[] values)

See Also:

• Numeric.countPos(java.lang.Float[])

countPos

public static long countPos(Integer[] values)

See Also:

• Numeric.countPos(java.lang.Integer[])

countPos

public static long countPos(Long[] values)

See Also:

• Numeric.countPos(java.lang.Long[])

countPos

public static long countPos(Short[] values)

See Also:

• Numeric.countPos(java.lang.Short[])

countPos

public static long countPos(short... values)

See Also:

• Numeric.countPos(short[])

countPos

public static long countPos(ByteVector values)

See Also:

• Numeric.countPos(io.deephaven.vector.ByteVector)

countPos

public static long countPos(DoubleVector values)

See Also:

• Numeric.countPos(io.deephaven.vector.DoubleVector)

countPos

public static long countPos(FloatVector values)

See Also:

• Numeric.countPos(io.deephaven.vector.FloatVector)

countPos

public static long countPos(IntVector values)

See Also:

• Numeric.countPos(io.deephaven.vector.IntVector)

countPos

public static long countPos(LongVector values)

See Also:

• Numeric.countPos(io.deephaven.vector.LongVector)

countPos

public static long countPos(ShortVector values)

See Also:

• Numeric.countPos(io.deephaven.vector.ShortVector)

countZero

public static long countZero(byte... values)

See Also:

• Numeric.countZero(byte[])

countZero

public static long countZero(double... values)

See Also:

• Numeric.countZero(double[])

countZero

public static long countZero(float... values)

See Also:

• Numeric.countZero(float[])

countZero

public static long countZero(int... values)

See Also:

• Numeric.countZero(int[])

countZero

public static long countZero(long... values)

See Also:

• Numeric.countZero(long[])

countZero

public static long countZero(Byte[] values)

See Also:

• Numeric.countZero(java.lang.Byte[])

countZero

public static long countZero(Double[] values)

See Also:

• Numeric.countZero(java.lang.Double[])

countZero

public static long countZero(Float[] values)

See Also:

• Numeric.countZero(java.lang.Float[])

countZero

public static long countZero(Integer[] values)

See Also:

• Numeric.countZero(java.lang.Integer[])

countZero

public static long countZero(Long[] values)

See Also:

• Numeric.countZero(java.lang.Long[])

countZero

public static long countZero(Short[] values)

See Also:

• Numeric.countZero(java.lang.Short[])

countZero

public static long countZero(short... values)

See Also:

• Numeric.countZero(short[])

countZero

public static long countZero(ByteVector values)

See Also:

• Numeric.countZero(io.deephaven.vector.ByteVector)

countZero

public static long countZero(DoubleVector values)

See Also:

• Numeric.countZero(io.deephaven.vector.DoubleVector)

countZero

public static long countZero(FloatVector values)

See Also:

• Numeric.countZero(io.deephaven.vector.FloatVector)

countZero

public static long countZero(IntVector values)

See Also:

• Numeric.countZero(io.deephaven.vector.IntVector)

countZero

public static long countZero(LongVector values)

See Also:

• Numeric.countZero(io.deephaven.vector.LongVector)

countZero

public static long countZero(ShortVector values)

See Also:

• Numeric.countZero(io.deephaven.vector.ShortVector)

cov

public static double cov(byte[] values0,
 byte[] values1)

See Also:

• Numeric.cov(byte[],byte[])

cov

public static double cov(byte[] values0,
 double[] values1)

See Also:

• Numeric.cov(byte[],double[])

cov

public static double cov(byte[] values0,
 float[] values1)

See Also:

• Numeric.cov(byte[],float[])

cov

public static double cov(byte[] values0,
 int[] values1)

See Also:

• Numeric.cov(byte[],int[])

cov

public static double cov(byte[] values0,
 long[] values1)

See Also:

• Numeric.cov(byte[],long[])

cov

public static double cov(byte[] values0,
 short[] values1)

See Also:

• Numeric.cov(byte[],short[])

cov

public static double cov(byte[] values0,
 ByteVector values1)

See Also:

• Numeric.cov(byte[],io.deephaven.vector.ByteVector)

cov

public static double cov(byte[] values0,
 DoubleVector values1)

See Also:

• Numeric.cov(byte[],io.deephaven.vector.DoubleVector)

cov

public static double cov(byte[] values0,
 FloatVector values1)

See Also:

• Numeric.cov(byte[],io.deephaven.vector.FloatVector)

cov

public static double cov(byte[] values0,
 IntVector values1)

See Also:

• Numeric.cov(byte[],io.deephaven.vector.IntVector)

cov

public static double cov(byte[] values0,
 LongVector values1)

See Also:

• Numeric.cov(byte[],io.deephaven.vector.LongVector)

cov

public static double cov(byte[] values0,
 ShortVector values1)

See Also:

• Numeric.cov(byte[],io.deephaven.vector.ShortVector)

cov

public static double cov(double[] values0,
 byte[] values1)

See Also:

• Numeric.cov(double[],byte[])

cov

public static double cov(double[] values0,
 double[] values1)

See Also:

• Numeric.cov(double[],double[])

cov

public static double cov(double[] values0,
 float[] values1)

See Also:

• Numeric.cov(double[],float[])

cov

public static double cov(double[] values0,
 int[] values1)

See Also:

• Numeric.cov(double[],int[])

cov

public static double cov(double[] values0,
 long[] values1)

See Also:

• Numeric.cov(double[],long[])

cov

public static double cov(double[] values0,
 short[] values1)

See Also:

• Numeric.cov(double[],short[])

cov

public static double cov(double[] values0,
 ByteVector values1)

See Also:

• Numeric.cov(double[],io.deephaven.vector.ByteVector)

cov

public static double cov(double[] values0,
 DoubleVector values1)

See Also:

• Numeric.cov(double[],io.deephaven.vector.DoubleVector)

cov

public static double cov(double[] values0,
 FloatVector values1)

See Also:

• Numeric.cov(double[],io.deephaven.vector.FloatVector)

cov

public static double cov(double[] values0,
 IntVector values1)

See Also:

• Numeric.cov(double[],io.deephaven.vector.IntVector)

cov

public static double cov(double[] values0,
 LongVector values1)

See Also:

• Numeric.cov(double[],io.deephaven.vector.LongVector)

cov

public static double cov(double[] values0,
 ShortVector values1)

See Also:

• Numeric.cov(double[],io.deephaven.vector.ShortVector)

cov

public static double cov(float[] values0,
 byte[] values1)

See Also:

• Numeric.cov(float[],byte[])

cov

public static double cov(float[] values0,
 double[] values1)

See Also:

• Numeric.cov(float[],double[])

cov

public static double cov(float[] values0,
 float[] values1)

See Also:

• Numeric.cov(float[],float[])

cov

public static double cov(float[] values0,
 int[] values1)

See Also:

• Numeric.cov(float[],int[])

cov

public static double cov(float[] values0,
 long[] values1)

See Also:

• Numeric.cov(float[],long[])

cov

public static double cov(float[] values0,
 short[] values1)

See Also:

• Numeric.cov(float[],short[])

cov

public static double cov(float[] values0,
 ByteVector values1)

See Also:

• Numeric.cov(float[],io.deephaven.vector.ByteVector)

cov

public static double cov(float[] values0,
 DoubleVector values1)

See Also:

• Numeric.cov(float[],io.deephaven.vector.DoubleVector)

cov

public static double cov(float[] values0,
 FloatVector values1)

See Also:

• Numeric.cov(float[],io.deephaven.vector.FloatVector)

cov

public static double cov(float[] values0,
 IntVector values1)

See Also:

• Numeric.cov(float[],io.deephaven.vector.IntVector)

cov

public static double cov(float[] values0,
 LongVector values1)

See Also:

• Numeric.cov(float[],io.deephaven.vector.LongVector)

cov

public static double cov(float[] values0,
 ShortVector values1)

See Also:

• Numeric.cov(float[],io.deephaven.vector.ShortVector)

cov

public static double cov(int[] values0,
 byte[] values1)

See Also:

• Numeric.cov(int[],byte[])

cov

public static double cov(int[] values0,
 double[] values1)

See Also:

• Numeric.cov(int[],double[])

cov

public static double cov(int[] values0,
 float[] values1)

See Also:

• Numeric.cov(int[],float[])

cov

public static double cov(int[] values0,
 int[] values1)

See Also:

• Numeric.cov(int[],int[])

cov

public static double cov(int[] values0,
 long[] values1)

See Also:

• Numeric.cov(int[],long[])

cov

public static double cov(int[] values0,
 short[] values1)

See Also:

• Numeric.cov(int[],short[])

cov

public static double cov(int[] values0,
 ByteVector values1)

See Also:

• Numeric.cov(int[],io.deephaven.vector.ByteVector)

cov

public static double cov(int[] values0,
 DoubleVector values1)

See Also:

• Numeric.cov(int[],io.deephaven.vector.DoubleVector)

cov

public static double cov(int[] values0,
 FloatVector values1)

See Also:

• Numeric.cov(int[],io.deephaven.vector.FloatVector)

cov

public static double cov(int[] values0,
 IntVector values1)

See Also:

• Numeric.cov(int[],io.deephaven.vector.IntVector)

cov

public static double cov(int[] values0,
 LongVector values1)

See Also:

• Numeric.cov(int[],io.deephaven.vector.LongVector)

cov

public static double cov(int[] values0,
 ShortVector values1)

See Also:

• Numeric.cov(int[],io.deephaven.vector.ShortVector)

cov

public static double cov(long[] values0,
 byte[] values1)

See Also:

• Numeric.cov(long[],byte[])

cov

public static double cov(long[] values0,
 double[] values1)

See Also:

• Numeric.cov(long[],double[])

cov

public static double cov(long[] values0,
 float[] values1)

See Also:

• Numeric.cov(long[],float[])

cov

public static double cov(long[] values0,
 int[] values1)

See Also:

• Numeric.cov(long[],int[])

cov

public static double cov(long[] values0,
 long[] values1)

See Also:

• Numeric.cov(long[],long[])

cov

public static double cov(long[] values0,
 short[] values1)

See Also:

• Numeric.cov(long[],short[])

cov

public static double cov(long[] values0,
 ByteVector values1)

See Also:

• Numeric.cov(long[],io.deephaven.vector.ByteVector)

cov

public static double cov(long[] values0,
 DoubleVector values1)

See Also:

• Numeric.cov(long[],io.deephaven.vector.DoubleVector)

cov

public static double cov(long[] values0,
 FloatVector values1)

See Also:

• Numeric.cov(long[],io.deephaven.vector.FloatVector)

cov

public static double cov(long[] values0,
 IntVector values1)

See Also:

• Numeric.cov(long[],io.deephaven.vector.IntVector)

cov

public static double cov(long[] values0,
 LongVector values1)

See Also:

• Numeric.cov(long[],io.deephaven.vector.LongVector)

cov

public static double cov(long[] values0,
 ShortVector values1)

See Also:

• Numeric.cov(long[],io.deephaven.vector.ShortVector)

cov

public static double cov(short[] values0,
 byte[] values1)

See Also:

• Numeric.cov(short[],byte[])

cov

public static double cov(short[] values0,
 double[] values1)

See Also:

• Numeric.cov(short[],double[])

cov

public static double cov(short[] values0,
 float[] values1)

See Also:

• Numeric.cov(short[],float[])

cov

public static double cov(short[] values0,
 int[] values1)

See Also:

• Numeric.cov(short[],int[])

cov

public static double cov(short[] values0,
 long[] values1)

See Also:

• Numeric.cov(short[],long[])

cov

public static double cov(short[] values0,
 short[] values1)

See Also:

• Numeric.cov(short[],short[])

cov

public static double cov(short[] values0,
 ByteVector values1)

See Also:

• Numeric.cov(short[],io.deephaven.vector.ByteVector)

cov

public static double cov(short[] values0,
 DoubleVector values1)

See Also:

• Numeric.cov(short[],io.deephaven.vector.DoubleVector)

cov

public static double cov(short[] values0,
 FloatVector values1)

See Also:

• Numeric.cov(short[],io.deephaven.vector.FloatVector)

cov

public static double cov(short[] values0,
 IntVector values1)

See Also:

• Numeric.cov(short[],io.deephaven.vector.IntVector)

cov

public static double cov(short[] values0,
 LongVector values1)

See Also:

• Numeric.cov(short[],io.deephaven.vector.LongVector)

cov

public static double cov(short[] values0,
 ShortVector values1)

See Also:

• Numeric.cov(short[],io.deephaven.vector.ShortVector)

cov

public static double cov(ByteVector values0,
 byte[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.ByteVector,byte[])

cov

public static double cov(ByteVector values0,
 double[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.ByteVector,double[])

cov

public static double cov(ByteVector values0,
 float[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.ByteVector,float[])

cov

public static double cov(ByteVector values0,
 int[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.ByteVector,int[])

cov

public static double cov(ByteVector values0,
 long[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.ByteVector,long[])

cov

public static double cov(ByteVector values0,
 short[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.ByteVector,short[])

cov

public static double cov(ByteVector values0,
 ByteVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.ByteVector,io.deephaven.vector.ByteVector)

cov

public static double cov(ByteVector values0,
 DoubleVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.ByteVector,io.deephaven.vector.DoubleVector)

cov

public static double cov(ByteVector values0,
 FloatVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.ByteVector,io.deephaven.vector.FloatVector)

cov

public static double cov(ByteVector values0,
 IntVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.ByteVector,io.deephaven.vector.IntVector)

cov

public static double cov(ByteVector values0,
 LongVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.ByteVector,io.deephaven.vector.LongVector)

cov

public static double cov(ByteVector values0,
 ShortVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.ByteVector,io.deephaven.vector.ShortVector)

cov

public static double cov(DoubleVector values0,
 byte[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.DoubleVector,byte[])

cov

public static double cov(DoubleVector values0,
 double[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.DoubleVector,double[])

cov

public static double cov(DoubleVector values0,
 float[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.DoubleVector,float[])

cov

public static double cov(DoubleVector values0,
 int[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.DoubleVector,int[])

cov

public static double cov(DoubleVector values0,
 long[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.DoubleVector,long[])

cov

public static double cov(DoubleVector values0,
 short[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.DoubleVector,short[])

cov

public static double cov(DoubleVector values0,
 ByteVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.DoubleVector,io.deephaven.vector.ByteVector)

cov

public static double cov(DoubleVector values0,
 DoubleVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.DoubleVector,io.deephaven.vector.DoubleVector)

cov

public static double cov(DoubleVector values0,
 FloatVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.DoubleVector,io.deephaven.vector.FloatVector)

cov

public static double cov(DoubleVector values0,
 IntVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.DoubleVector,io.deephaven.vector.IntVector)

cov

public static double cov(DoubleVector values0,
 LongVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.DoubleVector,io.deephaven.vector.LongVector)

cov

public static double cov(DoubleVector values0,
 ShortVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.DoubleVector,io.deephaven.vector.ShortVector)

cov

public static double cov(FloatVector values0,
 byte[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.FloatVector,byte[])

cov

public static double cov(FloatVector values0,
 double[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.FloatVector,double[])

cov

public static double cov(FloatVector values0,
 float[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.FloatVector,float[])

cov

public static double cov(FloatVector values0,
 int[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.FloatVector,int[])

cov

public static double cov(FloatVector values0,
 long[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.FloatVector,long[])

cov

public static double cov(FloatVector values0,
 short[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.FloatVector,short[])

cov

public static double cov(FloatVector values0,
 ByteVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.FloatVector,io.deephaven.vector.ByteVector)

cov

public static double cov(FloatVector values0,
 DoubleVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.FloatVector,io.deephaven.vector.DoubleVector)

cov

public static double cov(FloatVector values0,
 FloatVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.FloatVector,io.deephaven.vector.FloatVector)

cov

public static double cov(FloatVector values0,
 IntVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.FloatVector,io.deephaven.vector.IntVector)

cov

public static double cov(FloatVector values0,
 LongVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.FloatVector,io.deephaven.vector.LongVector)

cov

public static double cov(FloatVector values0,
 ShortVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.FloatVector,io.deephaven.vector.ShortVector)

cov

public static double cov(IntVector values0,
 byte[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.IntVector,byte[])

cov

public static double cov(IntVector values0,
 double[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.IntVector,double[])

cov

public static double cov(IntVector values0,
 float[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.IntVector,float[])

cov

public static double cov(IntVector values0,
 int[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.IntVector,int[])

cov

public static double cov(IntVector values0,
 long[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.IntVector,long[])

cov

public static double cov(IntVector values0,
 short[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.IntVector,short[])

cov

public static double cov(IntVector values0,
 ByteVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.IntVector,io.deephaven.vector.ByteVector)

cov

public static double cov(IntVector values0,
 DoubleVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.IntVector,io.deephaven.vector.DoubleVector)

cov

public static double cov(IntVector values0,
 FloatVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.IntVector,io.deephaven.vector.FloatVector)

cov

public static double cov(IntVector values0,
 IntVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.IntVector,io.deephaven.vector.IntVector)

cov

public static double cov(IntVector values0,
 LongVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.IntVector,io.deephaven.vector.LongVector)

cov

public static double cov(IntVector values0,
 ShortVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.IntVector,io.deephaven.vector.ShortVector)

cov

public static double cov(LongVector values0,
 byte[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.LongVector,byte[])

cov

public static double cov(LongVector values0,
 double[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.LongVector,double[])

cov

public static double cov(LongVector values0,
 float[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.LongVector,float[])

cov

public static double cov(LongVector values0,
 int[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.LongVector,int[])

cov

public static double cov(LongVector values0,
 long[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.LongVector,long[])

cov

public static double cov(LongVector values0,
 short[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.LongVector,short[])

cov

public static double cov(LongVector values0,
 ByteVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.LongVector,io.deephaven.vector.ByteVector)

cov

public static double cov(LongVector values0,
 DoubleVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.LongVector,io.deephaven.vector.DoubleVector)

cov

public static double cov(LongVector values0,
 FloatVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.LongVector,io.deephaven.vector.FloatVector)

cov

public static double cov(LongVector values0,
 IntVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.LongVector,io.deephaven.vector.IntVector)

cov

public static double cov(LongVector values0,
 LongVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.LongVector,io.deephaven.vector.LongVector)

cov

public static double cov(LongVector values0,
 ShortVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.LongVector,io.deephaven.vector.ShortVector)

cov

public static double cov(ShortVector values0,
 byte[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.ShortVector,byte[])

cov

public static double cov(ShortVector values0,
 double[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.ShortVector,double[])

cov

public static double cov(ShortVector values0,
 float[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.ShortVector,float[])

cov

public static double cov(ShortVector values0,
 int[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.ShortVector,int[])

cov

public static double cov(ShortVector values0,
 long[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.ShortVector,long[])

cov

public static double cov(ShortVector values0,
 short[] values1)

See Also:

• Numeric.cov(io.deephaven.vector.ShortVector,short[])

cov

public static double cov(ShortVector values0,
 ByteVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.ShortVector,io.deephaven.vector.ByteVector)

cov

public static double cov(ShortVector values0,
 DoubleVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.ShortVector,io.deephaven.vector.DoubleVector)

cov

public static double cov(ShortVector values0,
 FloatVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.ShortVector,io.deephaven.vector.FloatVector)

cov

public static double cov(ShortVector values0,
 IntVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.ShortVector,io.deephaven.vector.IntVector)

cov

public static double cov(ShortVector values0,
 LongVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.ShortVector,io.deephaven.vector.LongVector)

cov

public static double cov(ShortVector values0,
 ShortVector values1)

See Also:

• Numeric.cov(io.deephaven.vector.ShortVector,io.deephaven.vector.ShortVector)

cummax

public static byte[] cummax(byte... values)

See Also:

• Numeric.cummax(byte[])

cummax

public static double[] cummax(double... values)

See Also:

• Numeric.cummax(double[])

cummax

public static float[] cummax(float... values)

See Also:

• Numeric.cummax(float[])

cummax

public static int[] cummax(int... values)

See Also:

• Numeric.cummax(int[])

cummax

public static long[] cummax(long... values)

See Also:

• Numeric.cummax(long[])

cummax

public static byte[] cummax(Byte[] values)

See Also:

• Numeric.cummax(java.lang.Byte[])

cummax

public static double[] cummax(Double[] values)

See Also:

• Numeric.cummax(java.lang.Double[])

cummax

public static float[] cummax(Float[] values)

See Also:

• Numeric.cummax(java.lang.Float[])

cummax

public static int[] cummax(Integer[] values)

See Also:

• Numeric.cummax(java.lang.Integer[])

cummax

public static long[] cummax(Long[] values)

See Also:

• Numeric.cummax(java.lang.Long[])

cummax

public static short[] cummax(Short[] values)

See Also:

• Numeric.cummax(java.lang.Short[])

cummax

public static short[] cummax(short... values)

See Also:

• Numeric.cummax(short[])

cummax

public static byte[] cummax(ByteVector values)

See Also:

• Numeric.cummax(io.deephaven.vector.ByteVector)

cummax

public static double[] cummax(DoubleVector values)

See Also:

• Numeric.cummax(io.deephaven.vector.DoubleVector)

cummax

public static float[] cummax(FloatVector values)

See Also:

• Numeric.cummax(io.deephaven.vector.FloatVector)

cummax

public static int[] cummax(IntVector values)

See Also:

• Numeric.cummax(io.deephaven.vector.IntVector)

cummax

public static long[] cummax(LongVector values)

See Also:

• Numeric.cummax(io.deephaven.vector.LongVector)

cummax

public static short[] cummax(ShortVector values)

See Also:

• Numeric.cummax(io.deephaven.vector.ShortVector)

cummin

public static byte[] cummin(byte... values)

See Also:

• Numeric.cummin(byte[])

cummin

public static double[] cummin(double... values)

See Also:

• Numeric.cummin(double[])

cummin

public static float[] cummin(float... values)

See Also:

• Numeric.cummin(float[])

cummin

public static int[] cummin(int... values)

See Also:

• Numeric.cummin(int[])

cummin

public static long[] cummin(long... values)

See Also:

• Numeric.cummin(long[])

cummin

public static byte[] cummin(Byte[] values)

See Also:

• Numeric.cummin(java.lang.Byte[])

cummin

public static double[] cummin(Double[] values)

See Also:

• Numeric.cummin(java.lang.Double[])

cummin

public static float[] cummin(Float[] values)

See Also:

• Numeric.cummin(java.lang.Float[])

cummin

public static int[] cummin(Integer[] values)

See Also:

• Numeric.cummin(java.lang.Integer[])

cummin

public static long[] cummin(Long[] values)

See Also:

• Numeric.cummin(java.lang.Long[])

cummin

public static short[] cummin(Short[] values)

See Also:

• Numeric.cummin(java.lang.Short[])

cummin

public static short[] cummin(short... values)

See Also:

• Numeric.cummin(short[])

cummin

public static byte[] cummin(ByteVector values)

See Also:

• Numeric.cummin(io.deephaven.vector.ByteVector)

cummin

public static double[] cummin(DoubleVector values)

See Also:

• Numeric.cummin(io.deephaven.vector.DoubleVector)

cummin

public static float[] cummin(FloatVector values)

See Also:

• Numeric.cummin(io.deephaven.vector.FloatVector)

cummin

public static int[] cummin(IntVector values)

See Also:

• Numeric.cummin(io.deephaven.vector.IntVector)

cummin

public static long[] cummin(LongVector values)

See Also:

• Numeric.cummin(io.deephaven.vector.LongVector)

cummin

public static short[] cummin(ShortVector values)

See Also:

• Numeric.cummin(io.deephaven.vector.ShortVector)

cumprod

public static long[] cumprod(byte... values)

See Also:

• Numeric.cumprod(byte[])

cumprod

public static double[] cumprod(double... values)

See Also:

• Numeric.cumprod(double[])

cumprod

public static double[] cumprod(float... values)

See Also:

• Numeric.cumprod(float[])

cumprod

public static long[] cumprod(int... values)

See Also:

• Numeric.cumprod(int[])

cumprod

public static long[] cumprod(long... values)

See Also:

• Numeric.cumprod(long[])

cumprod

public static long[] cumprod(Byte[] values)

See Also:

• Numeric.cumprod(java.lang.Byte[])

cumprod

public static double[] cumprod(Double[] values)

See Also:

• Numeric.cumprod(java.lang.Double[])

cumprod

public static double[] cumprod(Float[] values)

See Also:

• Numeric.cumprod(java.lang.Float[])

cumprod

public static long[] cumprod(Integer[] values)

See Also:

• Numeric.cumprod(java.lang.Integer[])

cumprod

public static long[] cumprod(Long[] values)

See Also:

• Numeric.cumprod(java.lang.Long[])

cumprod

public static long[] cumprod(Short[] values)

See Also:

• Numeric.cumprod(java.lang.Short[])

cumprod

public static long[] cumprod(short... values)

See Also:

• Numeric.cumprod(short[])

cumprod

public static long[] cumprod(ByteVector values)

See Also:

• Numeric.cumprod(io.deephaven.vector.ByteVector)

cumprod

public static double[] cumprod(DoubleVector values)

See Also:

• Numeric.cumprod(io.deephaven.vector.DoubleVector)

cumprod

public static double[] cumprod(FloatVector values)

See Also:

• Numeric.cumprod(io.deephaven.vector.FloatVector)

cumprod

public static long[] cumprod(IntVector values)

See Also:

• Numeric.cumprod(io.deephaven.vector.IntVector)

cumprod

public static long[] cumprod(LongVector values)

See Also:

• Numeric.cumprod(io.deephaven.vector.LongVector)

cumprod

public static long[] cumprod(ShortVector values)

See Also:

• Numeric.cumprod(io.deephaven.vector.ShortVector)

cumsum

public static long[] cumsum(byte... values)

See Also:

• Numeric.cumsum(byte[])

cumsum

public static double[] cumsum(double... values)

See Also:

• Numeric.cumsum(double[])

cumsum

public static double[] cumsum(float... values)

See Also:

• Numeric.cumsum(float[])

cumsum

public static long[] cumsum(int... values)

See Also:

• Numeric.cumsum(int[])

cumsum

public static long[] cumsum(long... values)

See Also:

• Numeric.cumsum(long[])

cumsum

public static long[] cumsum(Byte[] values)

See Also:

• Numeric.cumsum(java.lang.Byte[])

cumsum

public static double[] cumsum(Double[] values)

See Also:

• Numeric.cumsum(java.lang.Double[])

cumsum

public static double[] cumsum(Float[] values)

See Also:

• Numeric.cumsum(java.lang.Float[])

cumsum

public static long[] cumsum(Integer[] values)

See Also:

• Numeric.cumsum(java.lang.Integer[])

cumsum

public static long[] cumsum(Long[] values)

See Also:

• Numeric.cumsum(java.lang.Long[])

cumsum

public static long[] cumsum(Short[] values)

See Also:

• Numeric.cumsum(java.lang.Short[])

cumsum

public static long[] cumsum(short... values)

See Also:

• Numeric.cumsum(short[])

cumsum

public static long[] cumsum(ByteVector values)

See Also:

• Numeric.cumsum(io.deephaven.vector.ByteVector)

cumsum

public static double[] cumsum(DoubleVector values)

See Also:

• Numeric.cumsum(io.deephaven.vector.DoubleVector)

cumsum

public static double[] cumsum(FloatVector values)

See Also:

• Numeric.cumsum(io.deephaven.vector.FloatVector)

cumsum

public static long[] cumsum(IntVector values)

See Also:

• Numeric.cumsum(io.deephaven.vector.IntVector)

cumsum

public static long[] cumsum(LongVector values)

See Also:

• Numeric.cumsum(io.deephaven.vector.LongVector)

cumsum

public static long[] cumsum(ShortVector values)

See Also:

• Numeric.cumsum(io.deephaven.vector.ShortVector)

decrementExact

public static byte decrementExact(byte x)

See Also:

• Numeric.decrementExact(byte)

decrementExact

public static int decrementExact(int x)

See Also:

• Numeric.decrementExact(int)

decrementExact

public static long decrementExact(long x)

See Also:

• Numeric.decrementExact(long)

decrementExact

public static short decrementExact(short x)

See Also:

• Numeric.decrementExact(short)

diff

public static byte[] diff(int stride,
 byte... values)

See Also:

• Numeric.diff(int,byte[])

diff

public static double[] diff(int stride,
 double... values)

See Also:

• Numeric.diff(int,double[])

diff

public static float[] diff(int stride,
 float... values)

See Also:

• Numeric.diff(int,float[])

diff

public static int[] diff(int stride,
 int... values)

See Also:

• Numeric.diff(int,int[])

diff

public static long[] diff(int stride,
 long... values)

See Also:

• Numeric.diff(int,long[])

diff

public static byte[] diff(int stride,
 Byte[] values)

See Also:

• Numeric.diff(int,java.lang.Byte[])

diff

public static double[] diff(int stride,
 Double[] values)

See Also:

• Numeric.diff(int,java.lang.Double[])

diff

public static float[] diff(int stride,
 Float[] values)

See Also:

• Numeric.diff(int,java.lang.Float[])

diff

public static int[] diff(int stride,
 Integer[] values)

See Also:

• Numeric.diff(int,java.lang.Integer[])

diff

public static long[] diff(int stride,
 Long[] values)

See Also:

• Numeric.diff(int,java.lang.Long[])

diff

public static short[] diff(int stride,
 Short[] values)

See Also:

• Numeric.diff(int,java.lang.Short[])

diff

public static short[] diff(int stride,
 short... values)

See Also:

• Numeric.diff(int,short[])

diff

public static byte[] diff(int stride,
 ByteVector values)

See Also:

• Numeric.diff(int,io.deephaven.vector.ByteVector)

diff

public static double[] diff(int stride,
 DoubleVector values)

See Also:

• Numeric.diff(int,io.deephaven.vector.DoubleVector)

diff

public static float[] diff(int stride,
 FloatVector values)

See Also:

• Numeric.diff(int,io.deephaven.vector.FloatVector)

diff

public static int[] diff(int stride,
 IntVector values)

See Also:

• Numeric.diff(int,io.deephaven.vector.IntVector)

diff

public static long[] diff(int stride,
 LongVector values)

See Also:

• Numeric.diff(int,io.deephaven.vector.LongVector)

diff

public static short[] diff(int stride,
 ShortVector values)

See Also:

• Numeric.diff(int,io.deephaven.vector.ShortVector)

distinct

public static byte[] distinct(byte... values)

See Also:

• Basic.distinct(byte[])

distinct

public static char[] distinct(char... values)

See Also:

• Basic.distinct(char[])

distinct

public static double[] distinct(double... values)

See Also:

• Basic.distinct(double[])

distinct

public static float[] distinct(float... values)

See Also:

• Basic.distinct(float[])

distinct

public static int[] distinct(int... values)

See Also:

• Basic.distinct(int[])

distinct

public static long[] distinct(long... values)

See Also:

• Basic.distinct(long[])

distinct

public static short[] distinct(short... values)

See Also:

• Basic.distinct(short[])

distinct

public static byte[] distinct(ByteVector values)

See Also:

• Basic.distinct(io.deephaven.vector.ByteVector)

distinct

public static char[] distinct(CharVector values)

See Also:

• Basic.distinct(io.deephaven.vector.CharVector)

distinct

public static double[] distinct(DoubleVector values)

See Also:

• Basic.distinct(io.deephaven.vector.DoubleVector)

distinct

public static float[] distinct(FloatVector values)

See Also:

• Basic.distinct(io.deephaven.vector.FloatVector)

distinct

public static int[] distinct(IntVector values)

See Also:

• Basic.distinct(io.deephaven.vector.IntVector)

distinct

public static long[] distinct(LongVector values)

See Also:

• Basic.distinct(io.deephaven.vector.LongVector)

distinct

public static short[] distinct(ShortVector values)

See Also:

• Basic.distinct(io.deephaven.vector.ShortVector)

distinct

public static byte[] distinct(byte[] values,
 boolean includeNull)

See Also:

• Basic.distinct(byte[],boolean)

distinct

public static char[] distinct(char[] values,
 boolean includeNull)

See Also:

• Basic.distinct(char[],boolean)

distinct

public static double[] distinct(double[] values,
 boolean includeNull)

See Also:

• Basic.distinct(double[],boolean)

distinct

public static float[] distinct(float[] values,
 boolean includeNull)

See Also:

• Basic.distinct(float[],boolean)

distinct

public static int[] distinct(int[] values,
 boolean includeNull)

See Also:

• Basic.distinct(int[],boolean)

distinct

public static long[] distinct(long[] values,
 boolean includeNull)

See Also:

• Basic.distinct(long[],boolean)

distinct

public static short[] distinct(short[] values,
 boolean includeNull)

See Also:

• Basic.distinct(short[],boolean)

distinct

public static byte[] distinct(ByteVector values,
 boolean includeNull)

See Also:

• Basic.distinct(io.deephaven.vector.ByteVector,boolean)

distinct

public static char[] distinct(CharVector values,
 boolean includeNull)

See Also:

• Basic.distinct(io.deephaven.vector.CharVector,boolean)

distinct

public static double[] distinct(DoubleVector values,
 boolean includeNull)

See Also:

• Basic.distinct(io.deephaven.vector.DoubleVector,boolean)

distinct

public static float[] distinct(FloatVector values,
 boolean includeNull)

See Also:

• Basic.distinct(io.deephaven.vector.FloatVector,boolean)

distinct

public static int[] distinct(IntVector values,
 boolean includeNull)

See Also:

• Basic.distinct(io.deephaven.vector.IntVector,boolean)

distinct

public static long[] distinct(LongVector values,
 boolean includeNull)

See Also:

• Basic.distinct(io.deephaven.vector.LongVector,boolean)

distinct

public static short[] distinct(ShortVector values,
 boolean includeNull)

See Also:

• Basic.distinct(io.deephaven.vector.ShortVector,boolean)

distinctObj

public static <T extends Comparable<? super T>> T[] distinctObj(T... values)

See Also:

• Basic.distinctObj(java.lang.Comparable[])

distinctObj

public static <T extends Comparable<? super T>> T[] distinctObj(ObjectVector<T> values)

See Also:

• Basic.distinctObj(io.deephaven.vector.ObjectVector)

distinctObj

public static <T extends Comparable<? super T>> T[] distinctObj(T[] values,
 boolean includeNull)

See Also:

• Basic.distinctObj(java.lang.Comparable[],boolean)

distinctObj

public static <T extends Comparable<? super T>> T[] distinctObj(ObjectVector<T> values,
 boolean includeNull)

See Also:

• Basic.distinctObj(io.deephaven.vector.ObjectVector,boolean)

enlist

public static byte[] enlist(byte... values)

See Also:

• Basic.enlist(byte[])

enlist

public static char[] enlist(char... values)

See Also:

• Basic.enlist(char[])

enlist

public static double[] enlist(double... values)

See Also:

• Basic.enlist(double[])

enlist

public static float[] enlist(float... values)

See Also:

• Basic.enlist(float[])

enlist

public static int[] enlist(int... values)

See Also:

• Basic.enlist(int[])

enlist

public static long[] enlist(long... values)

See Also:

• Basic.enlist(long[])

enlist

public static short[] enlist(short... values)

See Also:

• Basic.enlist(short[])

exp

public static double exp(byte value)

See Also:

• Numeric.exp(byte)

exp

public static double exp(double value)

See Also:

• Numeric.exp(double)

exp

public static double exp(float value)

See Also:

• Numeric.exp(float)

exp

public static double exp(int value)

See Also:

• Numeric.exp(int)

exp

public static double exp(long value)

See Also:

• Numeric.exp(long)

exp

public static double exp(short value)

See Also:

• Numeric.exp(short)

expm1

public static double expm1(byte x)

See Also:

• Numeric.expm1(byte)

expm1

public static double expm1(double x)

See Also:

• Numeric.expm1(double)

expm1

public static double expm1(float x)

See Also:

• Numeric.expm1(float)

expm1

public static double expm1(int x)

See Also:

• Numeric.expm1(int)

expm1

public static double expm1(long x)

See Also:

• Numeric.expm1(long)

expm1

public static double expm1(short x)

See Also:

• Numeric.expm1(short)

first

public static byte first(byte... values)

See Also:

• Basic.first(byte[])

first

public static char first(char... values)

See Also:

• Basic.first(char[])

first

public static double first(double... values)

See Also:

• Basic.first(double[])

first

public static float first(float... values)

See Also:

• Basic.first(float[])

first

public static int first(int... values)

See Also:

• Basic.first(int[])

first

public static long first(long... values)

See Also:

• Basic.first(long[])

first

public static short first(short... values)

See Also:

• Basic.first(short[])

first

public static byte first(ByteVector values)

See Also:

• Basic.first(io.deephaven.vector.ByteVector)

first

public static char first(CharVector values)

See Also:

• Basic.first(io.deephaven.vector.CharVector)

first

public static double first(DoubleVector values)

See Also:

• Basic.first(io.deephaven.vector.DoubleVector)

first

public static float first(FloatVector values)

See Also:

• Basic.first(io.deephaven.vector.FloatVector)

first

public static int first(IntVector values)

See Also:

• Basic.first(io.deephaven.vector.IntVector)

first

public static long first(LongVector values)

See Also:

• Basic.first(io.deephaven.vector.LongVector)

first

public static short first(ShortVector values)

See Also:

• Basic.first(io.deephaven.vector.ShortVector)

firstIndexOf

public static long firstIndexOf(byte val,
 byte... values)

See Also:

• Basic.firstIndexOf(byte,byte[])

firstIndexOf

public static long firstIndexOf(byte val,
 ByteVector values)

See Also:

• Basic.firstIndexOf(byte,io.deephaven.vector.ByteVector)

firstIndexOf

public static long firstIndexOf(char val,
 char... values)

See Also:

• Basic.firstIndexOf(char,char[])

firstIndexOf

public static long firstIndexOf(char val,
 CharVector values)

See Also:

• Basic.firstIndexOf(char,io.deephaven.vector.CharVector)

firstIndexOf

public static long firstIndexOf(double val,
 double... values)

See Also:

• Basic.firstIndexOf(double,double[])

firstIndexOf

public static long firstIndexOf(double val,
 DoubleVector values)

See Also:

• Basic.firstIndexOf(double,io.deephaven.vector.DoubleVector)

firstIndexOf

public static long firstIndexOf(float val,
 float... values)

See Also:

• Basic.firstIndexOf(float,float[])

firstIndexOf

public static long firstIndexOf(float val,
 FloatVector values)

See Also:

• Basic.firstIndexOf(float,io.deephaven.vector.FloatVector)

firstIndexOf

public static long firstIndexOf(int val,
 int... values)

See Also:

• Basic.firstIndexOf(int,int[])

firstIndexOf

public static long firstIndexOf(int val,
 IntVector values)

See Also:

• Basic.firstIndexOf(int,io.deephaven.vector.IntVector)

firstIndexOf

public static long firstIndexOf(long val,
 long... values)

See Also:

• Basic.firstIndexOf(long,long[])

firstIndexOf

public static long firstIndexOf(long val,
 LongVector values)

See Also:

• Basic.firstIndexOf(long,io.deephaven.vector.LongVector)

firstIndexOf

public static long firstIndexOf(short val,
 short... values)

See Also:

• Basic.firstIndexOf(short,short[])

firstIndexOf

public static long firstIndexOf(short val,
 ShortVector values)

See Also:

• Basic.firstIndexOf(short,io.deephaven.vector.ShortVector)

firstIndexOfObj

public static <T> long firstIndexOfObj(T val,
 T... values)

See Also:

• Basic.firstIndexOfObj(java.lang.Object,java.lang.Object[])

firstIndexOfObj

public static <T> long firstIndexOfObj(T val,
 ObjectVector<T> values)

See Also:

• Basic.firstIndexOfObj(java.lang.Object,io.deephaven.vector.ObjectVector)

firstObj

public static <T> T firstObj(T... values)

See Also:

• Basic.firstObj(java.lang.Object[])

firstObj

public static <T> T firstObj(ObjectVector<T> values)

See Also:

• Basic.firstObj(io.deephaven.vector.ObjectVector)

floor

public static double floor(byte value)

See Also:

• Numeric.floor(byte)

floor

public static double floor(double value)

See Also:

• Numeric.floor(double)

floor

public static double floor(float value)

See Also:

• Numeric.floor(float)

floor

public static double floor(int value)

See Also:

• Numeric.floor(int)

floor

public static double floor(long value)

See Also:

• Numeric.floor(long)

floor

public static double floor(short value)

See Also:

• Numeric.floor(short)

floorDiv

public static byte floorDiv(byte x,
 byte y)

See Also:

• Numeric.floorDiv(byte,byte)

floorDiv

public static int floorDiv(int x,
 int y)

See Also:

• Numeric.floorDiv(int,int)

floorDiv

public static long floorDiv(long x,
 long y)

See Also:

• Numeric.floorDiv(long,long)

floorDiv

public static short floorDiv(short x,
 short y)

See Also:

• Numeric.floorDiv(short,short)

floorMod

public static byte floorMod(byte x,
 byte y)

See Also:

• Numeric.floorMod(byte,byte)

floorMod

public static int floorMod(int x,
 int y)

See Also:

• Numeric.floorMod(int,int)

floorMod

public static long floorMod(long x,
 long y)

See Also:

• Numeric.floorMod(long,long)

floorMod

public static short floorMod(short x,
 short y)

See Also:

• Numeric.floorMod(short,short)

forwardFill

public static byte[] forwardFill(byte... values)

See Also:

• Basic.forwardFill(byte[])

forwardFill

public static char[] forwardFill(char... values)

See Also:

• Basic.forwardFill(char[])

forwardFill

public static double[] forwardFill(double... values)

See Also:

• Basic.forwardFill(double[])

forwardFill

public static float[] forwardFill(float... values)

See Also:

• Basic.forwardFill(float[])

forwardFill

public static int[] forwardFill(int... values)

See Also:

• Basic.forwardFill(int[])

forwardFill

public static long[] forwardFill(long... values)

See Also:

• Basic.forwardFill(long[])

forwardFill

public static short[] forwardFill(short... values)

See Also:

• Basic.forwardFill(short[])

forwardFill

public static byte[] forwardFill(ByteVector values)

See Also:

• Basic.forwardFill(io.deephaven.vector.ByteVector)

forwardFill

public static char[] forwardFill(CharVector values)

See Also:

• Basic.forwardFill(io.deephaven.vector.CharVector)

forwardFill

public static double[] forwardFill(DoubleVector values)

See Also:

• Basic.forwardFill(io.deephaven.vector.DoubleVector)

forwardFill

public static float[] forwardFill(FloatVector values)

See Also:

• Basic.forwardFill(io.deephaven.vector.FloatVector)

forwardFill

public static int[] forwardFill(IntVector values)

See Also:

• Basic.forwardFill(io.deephaven.vector.IntVector)

forwardFill

public static long[] forwardFill(LongVector values)

See Also:

• Basic.forwardFill(io.deephaven.vector.LongVector)

forwardFill

public static short[] forwardFill(ShortVector values)

See Also:

• Basic.forwardFill(io.deephaven.vector.ShortVector)

forwardFillObj

public static <T> T[] forwardFillObj(T... values)

See Also:

• Basic.forwardFillObj(java.lang.Object[])

forwardFillObj

public static <T> T[] forwardFillObj(ObjectVector<T> values)

See Also:

• Basic.forwardFillObj(io.deephaven.vector.ObjectVector)

getExponent

public static int getExponent(double x)

See Also:

• Numeric.getExponent(double)

getExponent

public static int getExponent(float x)

See Also:

• Numeric.getExponent(float)

hypot

public static double hypot(byte x,
 byte y)

See Also:

• Numeric.hypot(byte,byte)

hypot

public static double hypot(double x,
 double y)

See Also:

• Numeric.hypot(double,double)

hypot

public static double hypot(float x,
 float y)

See Also:

• Numeric.hypot(float,float)

hypot

public static double hypot(int x,
 int y)

See Also:

• Numeric.hypot(int,int)

hypot

public static double hypot(long x,
 long y)

See Also:

• Numeric.hypot(long,long)

hypot

public static double hypot(short x,
 short y)

See Also:

• Numeric.hypot(short,short)

ifelse

public static byte[] ifelse(Boolean[] condition,
 byte trueCase,
 byte falseCase)

See Also:

• Basic.ifelse(java.lang.Boolean[],byte,byte)

ifelse

public static char[] ifelse(Boolean[] condition,
 char trueCase,
 char falseCase)

See Also:

• Basic.ifelse(java.lang.Boolean[],char,char)

ifelse

public static byte[] ifelse(Boolean[] condition,
 byte[] trueCase,
 byte[] falseCase)

See Also:

• Basic.ifelse(java.lang.Boolean[],byte[],byte[])

ifelse

public static char[] ifelse(Boolean[] condition,
 char[] trueCase,
 char[] falseCase)

See Also:

• Basic.ifelse(java.lang.Boolean[],char[],char[])

ifelse

public static double[] ifelse(Boolean[] condition,
 double[] trueCase,
 double[] falseCase)

See Also:

• Basic.ifelse(java.lang.Boolean[],double[],double[])

ifelse

public static float[] ifelse(Boolean[] condition,
 float[] trueCase,
 float[] falseCase)

See Also:

• Basic.ifelse(java.lang.Boolean[],float[],float[])

ifelse

public static int[] ifelse(Boolean[] condition,
 int[] trueCase,
 int[] falseCase)

See Also:

• Basic.ifelse(java.lang.Boolean[],int[],int[])

ifelse

public static long[] ifelse(Boolean[] condition,
 long[] trueCase,
 long[] falseCase)

See Also:

• Basic.ifelse(java.lang.Boolean[],long[],long[])

ifelse

public static short[] ifelse(Boolean[] condition,
 short[] trueCase,
 short[] falseCase)

See Also:

• Basic.ifelse(java.lang.Boolean[],short[],short[])

ifelse

public static double[] ifelse(Boolean[] condition,
 double trueCase,
 double falseCase)

See Also:

• Basic.ifelse(java.lang.Boolean[],double,double)

ifelse

public static float[] ifelse(Boolean[] condition,
 float trueCase,
 float falseCase)

See Also:

• Basic.ifelse(java.lang.Boolean[],float,float)

ifelse

public static int[] ifelse(Boolean[] condition,
 int trueCase,
 int falseCase)

See Also:

• Basic.ifelse(java.lang.Boolean[],int,int)

ifelse

public static long[] ifelse(Boolean[] condition,
 long trueCase,
 long falseCase)

See Also:

• Basic.ifelse(java.lang.Boolean[],long,long)

ifelse

public static short[] ifelse(Boolean[] condition,
 short trueCase,
 short falseCase)

See Also:

• Basic.ifelse(java.lang.Boolean[],short,short)

ifelse

public static byte ifelse(Boolean condition,
 byte trueCase,
 byte falseCase)

See Also:

• Basic.ifelse(java.lang.Boolean,byte,byte)

ifelse

public static char ifelse(Boolean condition,
 char trueCase,
 char falseCase)

See Also:

• Basic.ifelse(java.lang.Boolean,char,char)

ifelse

public static double ifelse(Boolean condition,
 double trueCase,
 double falseCase)

See Also:

• Basic.ifelse(java.lang.Boolean,double,double)

ifelse

public static float ifelse(Boolean condition,
 float trueCase,
 float falseCase)

See Also:

• Basic.ifelse(java.lang.Boolean,float,float)

ifelse

public static int ifelse(Boolean condition,
 int trueCase,
 int falseCase)

See Also:

• Basic.ifelse(java.lang.Boolean,int,int)

ifelse

public static long ifelse(Boolean condition,
 long trueCase,
 long falseCase)

See Also:

• Basic.ifelse(java.lang.Boolean,long,long)

ifelse

public static short ifelse(Boolean condition,
 short trueCase,
 short falseCase)

See Also:

• Basic.ifelse(java.lang.Boolean,short,short)

ifelse

public static byte[] ifelse(ObjectVector<Boolean> condition,
 byte trueCase,
 byte falseCase)

See Also:

• Basic.ifelse(io.deephaven.vector.ObjectVector,byte,byte)

ifelse

public static char[] ifelse(ObjectVector<Boolean> condition,
 char trueCase,
 char falseCase)

See Also:

• Basic.ifelse(io.deephaven.vector.ObjectVector,char,char)

ifelse

public static double[] ifelse(ObjectVector<Boolean> condition,
 double trueCase,
 double falseCase)

See Also:

• Basic.ifelse(io.deephaven.vector.ObjectVector,double,double)

ifelse

public static float[] ifelse(ObjectVector<Boolean> condition,
 float trueCase,
 float falseCase)

See Also:

• Basic.ifelse(io.deephaven.vector.ObjectVector,float,float)

ifelse

public static int[] ifelse(ObjectVector<Boolean> condition,
 int trueCase,
 int falseCase)

See Also:

• Basic.ifelse(io.deephaven.vector.ObjectVector,int,int)

ifelse

public static byte[] ifelse(ObjectVector<Boolean> condition,
 ByteVector trueCase,
 ByteVector falseCase)

See Also:

• Basic.ifelse(io.deephaven.vector.ObjectVector,io.deephaven.vector.ByteVector,io.deephaven.vector.ByteVector)

ifelse

public static char[] ifelse(ObjectVector<Boolean> condition,
 CharVector trueCase,
 CharVector falseCase)

See Also:

• Basic.ifelse(io.deephaven.vector.ObjectVector,io.deephaven.vector.CharVector,io.deephaven.vector.CharVector)

ifelse

public static double[] ifelse(ObjectVector<Boolean> condition,
 DoubleVector trueCase,
 DoubleVector falseCase)

See Also:

• Basic.ifelse(io.deephaven.vector.ObjectVector,io.deephaven.vector.DoubleVector,io.deephaven.vector.DoubleVector)

ifelse

public static float[] ifelse(ObjectVector<Boolean> condition,
 FloatVector trueCase,
 FloatVector falseCase)

See Also:

• Basic.ifelse(io.deephaven.vector.ObjectVector,io.deephaven.vector.FloatVector,io.deephaven.vector.FloatVector)

ifelse

public static int[] ifelse(ObjectVector<Boolean> condition,
 IntVector trueCase,
 IntVector falseCase)

See Also:

• Basic.ifelse(io.deephaven.vector.ObjectVector,io.deephaven.vector.IntVector,io.deephaven.vector.IntVector)

ifelse

public static long[] ifelse(ObjectVector<Boolean> condition,
 LongVector trueCase,
 LongVector falseCase)

See Also:

• Basic.ifelse(io.deephaven.vector.ObjectVector,io.deephaven.vector.LongVector,io.deephaven.vector.LongVector)

ifelse

public static short[] ifelse(ObjectVector<Boolean> condition,
 ShortVector trueCase,
 ShortVector falseCase)

See Also:

• Basic.ifelse(io.deephaven.vector.ObjectVector,io.deephaven.vector.ShortVector,io.deephaven.vector.ShortVector)

ifelse

public static long[] ifelse(ObjectVector<Boolean> condition,
 long trueCase,
 long falseCase)

See Also:

• Basic.ifelse(io.deephaven.vector.ObjectVector,long,long)

ifelse

public static short[] ifelse(ObjectVector<Boolean> condition,
 short trueCase,
 short falseCase)

See Also:

• Basic.ifelse(io.deephaven.vector.ObjectVector,short,short)

ifelseObj

public static <T> T[] ifelseObj(Boolean[] condition,
 T trueCase,
 T falseCase)

See Also:

• Basic.ifelseObj(java.lang.Boolean[],java.lang.Object,java.lang.Object)

ifelseObj

public static <T> T[] ifelseObj(Boolean[] condition,
 T[] trueCase,
 T[] falseCase)

See Also:

• Basic.ifelseObj(java.lang.Boolean[],java.lang.Object[],java.lang.Object[])

ifelseObj

public static <T> T ifelseObj(Boolean condition,
 T trueCase,
 T falseCase)

See Also:

• Basic.ifelseObj(java.lang.Boolean,java.lang.Object,java.lang.Object)

ifelseObj

public static <T> T[] ifelseObj(ObjectVector<Boolean> condition,
 T trueCase,
 T falseCase)

See Also:

• Basic.ifelseObj(io.deephaven.vector.ObjectVector,java.lang.Object,java.lang.Object)

ifelseObj

public static <T> T[] ifelseObj(ObjectVector<Boolean> condition,
 ObjectVector<T> trueCase,
 ObjectVector<T> falseCase)

See Also:

• Basic.ifelseObj(io.deephaven.vector.ObjectVector,io.deephaven.vector.ObjectVector,io.deephaven.vector.ObjectVector)

in

public static boolean in(byte testedValues,
 byte... possibleValues)

See Also:

• Basic.in(byte,byte[])

in

public static boolean in(char testedValues,
 char... possibleValues)

See Also:

• Basic.in(char,char[])

in

public static boolean in(double testedValues,
 double... possibleValues)

See Also:

• Basic.in(double,double[])

in

public static boolean in(float testedValues,
 float... possibleValues)

See Also:

• Basic.in(float,float[])

in

public static boolean in(int testedValues,
 int... possibleValues)

See Also:

• Basic.in(int,int[])

in

public static boolean in(long testedValues,
 long... possibleValues)

See Also:

• Basic.in(long,long[])

in

public static boolean in(short testedValues,
 short... possibleValues)

See Also:

• Basic.in(short,short[])

inObj

public static <T> boolean inObj(T testedValue,
 T... possibleValues)

See Also:

• Basic.inObj(java.lang.Object,java.lang.Object[])

inObj

public static <T> boolean inObj(T testedValue,
 ObjectVector<T> possibleValues)

See Also:

• Basic.inObj(java.lang.Object,io.deephaven.vector.ObjectVector)

inRange

public static <T extends Comparable<? super T>>
boolean inRange(T testedValue,
 T lowInclusiveValue,
 T highInclusiveValue)

See Also:

• Basic.inRange(java.lang.Comparable,java.lang.Comparable,java.lang.Comparable)

inRange

public static boolean inRange(byte testedValue,
 byte lowInclusiveValue,
 byte highInclusiveValue)

See Also:

• Basic.inRange(byte,byte,byte)

inRange

public static boolean inRange(char testedValue,
 char lowInclusiveValue,
 char highInclusiveValue)

See Also:

• Basic.inRange(char,char,char)

inRange

public static boolean inRange(double testedValue,
 double lowInclusiveValue,
 double highInclusiveValue)

See Also:

• Basic.inRange(double,double,double)

inRange

public static boolean inRange(float testedValue,
 float lowInclusiveValue,
 float highInclusiveValue)

See Also:

• Basic.inRange(float,float,float)

inRange

public static boolean inRange(int testedValue,
 int lowInclusiveValue,
 int highInclusiveValue)

See Also:

• Basic.inRange(int,int,int)

inRange

public static boolean inRange(long testedValue,
 long lowInclusiveValue,
 long highInclusiveValue)

See Also:

• Basic.inRange(long,long,long)

inRange

public static boolean inRange(short testedValue,
 short lowInclusiveValue,
 short highInclusiveValue)

See Also:

• Basic.inRange(short,short,short)

incrementExact

public static byte incrementExact(byte x)

See Also:

• Numeric.incrementExact(byte)

incrementExact

public static int incrementExact(int x)

See Also:

• Numeric.incrementExact(int)

incrementExact

public static long incrementExact(long x)

See Also:

• Numeric.incrementExact(long)

incrementExact

public static short incrementExact(short x)

See Also:

• Numeric.incrementExact(short)

indexOfMax

public static long indexOfMax(byte... values)

See Also:

• Numeric.indexOfMax(byte[])

indexOfMax

public static long indexOfMax(double... values)

See Also:

• Numeric.indexOfMax(double[])

indexOfMax

public static long indexOfMax(float... values)

See Also:

• Numeric.indexOfMax(float[])

indexOfMax

public static long indexOfMax(int... values)

See Also:

• Numeric.indexOfMax(int[])

indexOfMax

public static long indexOfMax(long... values)

See Also:

• Numeric.indexOfMax(long[])

indexOfMax

public static long indexOfMax(Byte[] values)

See Also:

• Numeric.indexOfMax(java.lang.Byte[])

indexOfMax

public static long indexOfMax(Double[] values)

See Also:

• Numeric.indexOfMax(java.lang.Double[])

indexOfMax

public static long indexOfMax(Float[] values)

See Also:

• Numeric.indexOfMax(java.lang.Float[])

indexOfMax

public static long indexOfMax(Integer[] values)

See Also:

• Numeric.indexOfMax(java.lang.Integer[])

indexOfMax

public static long indexOfMax(Long[] values)

See Also:

• Numeric.indexOfMax(java.lang.Long[])

indexOfMax

public static long indexOfMax(Short[] values)

See Also:

• Numeric.indexOfMax(java.lang.Short[])

indexOfMax

public static long indexOfMax(short... values)

See Also:

• Numeric.indexOfMax(short[])

indexOfMax

public static long indexOfMax(ByteVector values)

See Also:

• Numeric.indexOfMax(io.deephaven.vector.ByteVector)

indexOfMax

public static long indexOfMax(DoubleVector values)

See Also:

• Numeric.indexOfMax(io.deephaven.vector.DoubleVector)

indexOfMax

public static long indexOfMax(FloatVector values)

See Also:

• Numeric.indexOfMax(io.deephaven.vector.FloatVector)

indexOfMax

public static long indexOfMax(IntVector values)

See Also:

• Numeric.indexOfMax(io.deephaven.vector.IntVector)

indexOfMax

public static long indexOfMax(LongVector values)

See Also:

• Numeric.indexOfMax(io.deephaven.vector.LongVector)

indexOfMax

public static long indexOfMax(ShortVector values)

See Also:

• Numeric.indexOfMax(io.deephaven.vector.ShortVector)

indexOfMaxObj

public static <T extends Comparable<T>> long indexOfMaxObj(T... values)

See Also:

• Numeric.indexOfMaxObj(java.lang.Comparable[])

indexOfMaxObj

public static <T extends Comparable<T>> long indexOfMaxObj(ObjectVector<T> values)

See Also:

• Numeric.indexOfMaxObj(io.deephaven.vector.ObjectVector)

indexOfMin

public static long indexOfMin(byte... values)

See Also:

• Numeric.indexOfMin(byte[])

indexOfMin

public static long indexOfMin(double... values)

See Also:

• Numeric.indexOfMin(double[])

indexOfMin

public static long indexOfMin(float... values)

See Also:

• Numeric.indexOfMin(float[])

indexOfMin

public static long indexOfMin(int... values)

See Also:

• Numeric.indexOfMin(int[])

indexOfMin

public static long indexOfMin(long... values)

See Also:

• Numeric.indexOfMin(long[])

indexOfMin

public static long indexOfMin(Byte[] values)

See Also:

• Numeric.indexOfMin(java.lang.Byte[])

indexOfMin

public static long indexOfMin(Double[] values)

See Also:

• Numeric.indexOfMin(java.lang.Double[])

indexOfMin

public static long indexOfMin(Float[] values)

See Also:

• Numeric.indexOfMin(java.lang.Float[])

indexOfMin

public static long indexOfMin(Integer[] values)

See Also:

• Numeric.indexOfMin(java.lang.Integer[])

indexOfMin

public static long indexOfMin(Long[] values)

See Also:

• Numeric.indexOfMin(java.lang.Long[])

indexOfMin

public static long indexOfMin(Short[] values)

See Also:

• Numeric.indexOfMin(java.lang.Short[])

indexOfMin

public static long indexOfMin(short... values)

See Also:

• Numeric.indexOfMin(short[])

indexOfMin

public static long indexOfMin(ByteVector values)

See Also:

• Numeric.indexOfMin(io.deephaven.vector.ByteVector)

indexOfMin

public static long indexOfMin(DoubleVector values)

See Also:

• Numeric.indexOfMin(io.deephaven.vector.DoubleVector)

indexOfMin

public static long indexOfMin(FloatVector values)

See Also:

• Numeric.indexOfMin(io.deephaven.vector.FloatVector)

indexOfMin

public static long indexOfMin(IntVector values)

See Also:

• Numeric.indexOfMin(io.deephaven.vector.IntVector)

indexOfMin

public static long indexOfMin(LongVector values)

See Also:

• Numeric.indexOfMin(io.deephaven.vector.LongVector)

indexOfMin

public static long indexOfMin(ShortVector values)

See Also:

• Numeric.indexOfMin(io.deephaven.vector.ShortVector)

indexOfMinObj

public static <T extends Comparable<T>> long indexOfMinObj(T... values)

See Also:

• Numeric.indexOfMinObj(java.lang.Comparable[])

indexOfMinObj

public static <T extends Comparable<T>> long indexOfMinObj(ObjectVector<T> values)

See Also:

• Numeric.indexOfMinObj(io.deephaven.vector.ObjectVector)

isFinite

public static boolean isFinite(byte value)

See Also:

• Numeric.isFinite(byte)

isFinite

public static boolean isFinite(Byte value)

See Also:

• Numeric.isFinite(java.lang.Byte)

isFinite

public static boolean isFinite(Double value)

See Also:

• Numeric.isFinite(java.lang.Double)

isFinite

public static boolean isFinite(Float value)

See Also:

• Numeric.isFinite(java.lang.Float)

isFinite

public static boolean isFinite(Integer value)

See Also:

• Numeric.isFinite(java.lang.Integer)

isFinite

public static boolean isFinite(Long value)

See Also:

• Numeric.isFinite(java.lang.Long)

isFinite

public static boolean isFinite(Short value)

See Also:

• Numeric.isFinite(java.lang.Short)

isFinite

public static boolean isFinite(double value)

See Also:

• Numeric.isFinite(double)

isFinite

public static boolean isFinite(float value)

See Also:

• Numeric.isFinite(float)

isFinite

public static boolean isFinite(int value)

See Also:

• Numeric.isFinite(int)

isFinite

public static boolean isFinite(long value)

See Also:

• Numeric.isFinite(long)

isFinite

public static boolean isFinite(short value)

See Also:

• Numeric.isFinite(short)

isInf

public static boolean isInf(byte value)

See Also:

• Numeric.isInf(byte)

isInf

public static boolean isInf(Byte value)

See Also:

• Numeric.isInf(java.lang.Byte)

isInf

public static boolean isInf(Double value)

See Also:

• Numeric.isInf(java.lang.Double)

isInf

public static boolean isInf(Float value)

See Also:

• Numeric.isInf(java.lang.Float)

isInf

public static boolean isInf(Integer value)

See Also:

• Numeric.isInf(java.lang.Integer)

isInf

public static boolean isInf(Long value)

See Also:

• Numeric.isInf(java.lang.Long)

isInf

public static boolean isInf(Short value)

See Also:

• Numeric.isInf(java.lang.Short)

isInf

public static boolean isInf(double value)

See Also:

• Numeric.isInf(double)

isInf

public static boolean isInf(float value)

See Also:

• Numeric.isInf(float)

isInf

public static boolean isInf(int value)

See Also:

• Numeric.isInf(int)

isInf

public static boolean isInf(long value)

See Also:

• Numeric.isInf(long)

isInf

public static boolean isInf(short value)

See Also:

• Numeric.isInf(short)

isNaN

public static boolean isNaN(byte value)

See Also:

• Numeric.isNaN(byte)

isNaN

public static boolean isNaN(Byte value)

See Also:

• Numeric.isNaN(java.lang.Byte)

isNaN

public static boolean isNaN(Double value)

See Also:

• Numeric.isNaN(java.lang.Double)

isNaN

public static boolean isNaN(Float value)

See Also:

• Numeric.isNaN(java.lang.Float)

isNaN

public static boolean isNaN(Integer value)

See Also:

• Numeric.isNaN(java.lang.Integer)

isNaN

public static boolean isNaN(Long value)

See Also:

• Numeric.isNaN(java.lang.Long)

isNaN

public static boolean isNaN(Short value)

See Also:

• Numeric.isNaN(java.lang.Short)

isNaN

public static boolean isNaN(double value)

See Also:

• Numeric.isNaN(double)

isNaN

public static boolean isNaN(float value)

See Also:

• Numeric.isNaN(float)

isNaN

public static boolean isNaN(int value)

See Also:

• Numeric.isNaN(int)

isNaN

public static boolean isNaN(long value)

See Also:

• Numeric.isNaN(long)

isNaN

public static boolean isNaN(short value)

See Also:

• Numeric.isNaN(short)

isNull

public static <T> boolean isNull(T value)

See Also:

• Basic.isNull(java.lang.Object)

isNull

public static boolean isNull(byte value)

See Also:

• Basic.isNull(byte)

isNull

public static boolean isNull(char value)

See Also:

• Basic.isNull(char)

isNull

public static boolean isNull(double value)

See Also:

• Basic.isNull(double)

isNull

public static boolean isNull(float value)

See Also:

• Basic.isNull(float)

isNull

public static boolean isNull(int value)

See Also:

• Basic.isNull(int)

isNull

public static boolean isNull(long value)

See Also:

• Basic.isNull(long)

isNull

public static boolean isNull(short value)

See Also:

• Basic.isNull(short)

last

public static byte last(byte... values)

See Also:

• Basic.last(byte[])

last

public static char last(char... values)

See Also:

• Basic.last(char[])

last

public static double last(double... values)

See Also:

• Basic.last(double[])

last

public static float last(float... values)

See Also:

• Basic.last(float[])

last

public static int last(int... values)

See Also:

• Basic.last(int[])

last

public static long last(long... values)

See Also:

• Basic.last(long[])

last

public static short last(short... values)

See Also:

• Basic.last(short[])

last

public static byte last(ByteVector values)

See Also:

• Basic.last(io.deephaven.vector.ByteVector)

last

public static char last(CharVector values)

See Also:

• Basic.last(io.deephaven.vector.CharVector)

last

public static double last(DoubleVector values)

See Also:

• Basic.last(io.deephaven.vector.DoubleVector)

last

public static float last(FloatVector values)

See Also:

• Basic.last(io.deephaven.vector.FloatVector)

last

public static int last(IntVector values)

See Also:

• Basic.last(io.deephaven.vector.IntVector)

last

public static long last(LongVector values)

See Also:

• Basic.last(io.deephaven.vector.LongVector)

last

public static short last(ShortVector values)

See Also:

• Basic.last(io.deephaven.vector.ShortVector)

lastObj

public static <T> T lastObj(T... values)

See Also:

• Basic.lastObj(java.lang.Object[])

lastObj

public static <T> T lastObj(ObjectVector<T> values)

See Also:

• Basic.lastObj(io.deephaven.vector.ObjectVector)

len

public static <T> long len(T[] values)

See Also:

• Basic.len(java.lang.Object[])

len

public static long len(byte[] values)

See Also:

• Basic.len(byte[])

len

public static long len(char[] values)

See Also:

• Basic.len(char[])

len

public static long len(double[] values)

See Also:

• Basic.len(double[])

len

public static long len(float[] values)

See Also:

• Basic.len(float[])

len

public static long len(int[] values)

See Also:

• Basic.len(int[])

len

public static long len(long[] values)

See Also:

• Basic.len(long[])

len

public static long len(short[] values)

See Also:

• Basic.len(short[])

len

public static long len(LongSizedDataStructure values)

See Also:

• Basic.len(io.deephaven.util.datastructures.LongSizedDataStructure)

log

public static double log(byte value)

See Also:

• Numeric.log(byte)

log

public static double log(double value)

See Also:

• Numeric.log(double)

log

public static double log(float value)

See Also:

• Numeric.log(float)

log

public static double log(int value)

See Also:

• Numeric.log(int)

log

public static double log(long value)

See Also:

• Numeric.log(long)

log

public static double log(short value)

See Also:

• Numeric.log(short)

log10

public static double log10(byte x)

See Also:

• Numeric.log10(byte)

log10

public static double log10(double x)

See Also:

• Numeric.log10(double)

log10

public static double log10(float x)

See Also:

• Numeric.log10(float)

log10

public static double log10(int x)

See Also:

• Numeric.log10(int)

log10

public static double log10(long x)

See Also:

• Numeric.log10(long)

log10

public static double log10(short x)

See Also:

• Numeric.log10(short)

log1p

public static double log1p(byte x)

See Also:

• Numeric.log1p(byte)

log1p

public static double log1p(double x)

See Also:

• Numeric.log1p(double)

log1p

public static double log1p(float x)

See Also:

• Numeric.log1p(float)

log1p

public static double log1p(int x)

See Also:

• Numeric.log1p(int)

log1p

public static double log1p(long x)

See Also:

• Numeric.log1p(long)

log1p

public static double log1p(short x)

See Also:

• Numeric.log1p(short)

lowerBin

public static byte lowerBin(byte value,
 byte interval)

See Also:

• Numeric.lowerBin(byte,byte)

lowerBin

public static double lowerBin(double value,
 double interval)

See Also:

• Numeric.lowerBin(double,double)

lowerBin

public static float lowerBin(float value,
 float interval)

See Also:

• Numeric.lowerBin(float,float)

lowerBin

public static int lowerBin(int value,
 int interval)

See Also:

• Numeric.lowerBin(int,int)

lowerBin

public static long lowerBin(long value,
 long interval)

See Also:

• Numeric.lowerBin(long,long)

lowerBin

public static short lowerBin(short value,
 short interval)

See Also:

• Numeric.lowerBin(short,short)

lowerBin

public static byte lowerBin(byte value,
 byte interval,
 byte offset)

See Also:

• Numeric.lowerBin(byte,byte,byte)

lowerBin

public static double lowerBin(double value,
 double interval,
 double offset)

See Also:

• Numeric.lowerBin(double,double,double)

lowerBin

public static float lowerBin(float value,
 float interval,
 float offset)

See Also:

• Numeric.lowerBin(float,float,float)

lowerBin

public static int lowerBin(int value,
 int interval,
 int offset)

See Also:

• Numeric.lowerBin(int,int,int)

lowerBin

public static long lowerBin(long value,
 long interval,
 long offset)

See Also:

• Numeric.lowerBin(long,long,long)

lowerBin

public static short lowerBin(short value,
 short interval,
 short offset)

See Also:

• Numeric.lowerBin(short,short,short)

max

public static byte max(byte... values)

See Also:

• Numeric.max(byte[])

max

public static double max(double... values)

See Also:

• Numeric.max(double[])

max

public static float max(float... values)

See Also:

• Numeric.max(float[])

max

public static int max(int... values)

See Also:

• Numeric.max(int[])

max

public static long max(long... values)

See Also:

• Numeric.max(long[])

max

public static byte max(Byte[] values)

See Also:

• Numeric.max(java.lang.Byte[])

max

public static double max(Double[] values)

See Also:

• Numeric.max(java.lang.Double[])

max

public static float max(Float[] values)

See Also:

• Numeric.max(java.lang.Float[])

max

public static int max(Integer[] values)

See Also:

• Numeric.max(java.lang.Integer[])

max

public static long max(Long[] values)

See Also:

• Numeric.max(java.lang.Long[])

max

public static short max(Short[] values)

See Also:

• Numeric.max(java.lang.Short[])

max

public static short max(short... values)

See Also:

• Numeric.max(short[])

max

public static byte max(ByteVector values)

See Also:

• Numeric.max(io.deephaven.vector.ByteVector)

max

public static double max(DoubleVector values)

See Also:

• Numeric.max(io.deephaven.vector.DoubleVector)

max

public static float max(FloatVector values)

See Also:

• Numeric.max(io.deephaven.vector.FloatVector)

max

public static int max(IntVector values)

See Also:

• Numeric.max(io.deephaven.vector.IntVector)

max

public static long max(LongVector values)

See Also:

• Numeric.max(io.deephaven.vector.LongVector)

max

public static short max(ShortVector values)

See Also:

• Numeric.max(io.deephaven.vector.ShortVector)

maxObj

public static <T extends Comparable<T>> T maxObj(T... values)

See Also:

• Numeric.maxObj(java.lang.Comparable[])

maxObj

public static <T extends Comparable<T>> T maxObj(ObjectVector<T> values)

See Also:

• Numeric.maxObj(io.deephaven.vector.ObjectVector)

median

public static double median(byte... values)

See Also:

• Numeric.median(byte[])

median

public static double median(double... values)

See Also:

• Numeric.median(double[])

median

public static double median(float... values)

See Also:

• Numeric.median(float[])

median

public static double median(int... values)

See Also:

• Numeric.median(int[])

median

public static double median(long... values)

See Also:

• Numeric.median(long[])

median

public static double median(Byte[] values)

See Also:

• Numeric.median(java.lang.Byte[])

median

public static double median(Double[] values)

See Also:

• Numeric.median(java.lang.Double[])

median

public static double median(Float[] values)

See Also:

• Numeric.median(java.lang.Float[])

median

public static double median(Integer[] values)

See Also:

• Numeric.median(java.lang.Integer[])

median

public static double median(Long[] values)

See Also:

• Numeric.median(java.lang.Long[])

median

public static double median(Short[] values)

See Also:

• Numeric.median(java.lang.Short[])

median

public static double median(short... values)

See Also:

• Numeric.median(short[])

median

public static double median(ByteVector values)

See Also:

• Numeric.median(io.deephaven.vector.ByteVector)

median

public static double median(DoubleVector values)

See Also:

• Numeric.median(io.deephaven.vector.DoubleVector)

median

public static double median(FloatVector values)

See Also:

• Numeric.median(io.deephaven.vector.FloatVector)

median

public static double median(IntVector values)

See Also:

• Numeric.median(io.deephaven.vector.IntVector)

median

public static double median(LongVector values)

See Also:

• Numeric.median(io.deephaven.vector.LongVector)

median

public static double median(ShortVector values)

See Also:

• Numeric.median(io.deephaven.vector.ShortVector)

min

public static byte min(byte... values)

See Also:

• Numeric.min(byte[])

min

public static double min(double... values)

See Also:

• Numeric.min(double[])

min

public static float min(float... values)

See Also:

• Numeric.min(float[])

min

public static int min(int... values)

See Also:

• Numeric.min(int[])

min

public static long min(long... values)

See Also:

• Numeric.min(long[])

min

public static byte min(Byte[] values)

See Also:

• Numeric.min(java.lang.Byte[])

min

public static double min(Double[] values)

See Also:

• Numeric.min(java.lang.Double[])

min

public static float min(Float[] values)

See Also:

• Numeric.min(java.lang.Float[])

min

public static int min(Integer[] values)

See Also:

• Numeric.min(java.lang.Integer[])

min

public static long min(Long[] values)

See Also:

• Numeric.min(java.lang.Long[])

min

public static short min(Short[] values)

See Also:

• Numeric.min(java.lang.Short[])

min

public static short min(short... values)

See Also:

• Numeric.min(short[])

min

public static byte min(ByteVector values)

See Also:

• Numeric.min(io.deephaven.vector.ByteVector)

min

public static double min(DoubleVector values)

See Also:

• Numeric.min(io.deephaven.vector.DoubleVector)

min

public static float min(FloatVector values)

See Also:

• Numeric.min(io.deephaven.vector.FloatVector)

min

public static int min(IntVector values)

See Also:

• Numeric.min(io.deephaven.vector.IntVector)

min

public static long min(LongVector values)

See Also:

• Numeric.min(io.deephaven.vector.LongVector)

min

public static short min(ShortVector values)

See Also:

• Numeric.min(io.deephaven.vector.ShortVector)

minObj

public static <T extends Comparable<T>> T minObj(T... values)

See Also:

• Numeric.minObj(java.lang.Comparable[])

minObj

public static <T extends Comparable<T>> T minObj(ObjectVector<T> values)

See Also:

• Numeric.minObj(io.deephaven.vector.ObjectVector)

multiplyExact

public static byte multiplyExact(byte x,
 byte y)

See Also:

• Numeric.multiplyExact(byte,byte)

multiplyExact

public static int multiplyExact(int x,
 int y)

See Also:

• Numeric.multiplyExact(int,int)

multiplyExact

public static long multiplyExact(long x,
 long y)

See Also:

• Numeric.multiplyExact(long,long)

multiplyExact

public static short multiplyExact(short x,
 short y)

See Also:

• Numeric.multiplyExact(short,short)

negateExact

public static byte negateExact(byte x)

See Also:

• Numeric.negateExact(byte)

negateExact

public static int negateExact(int x)

See Also:

• Numeric.negateExact(int)

negateExact

public static long negateExact(long x)

See Also:

• Numeric.negateExact(long)

negateExact

public static short negateExact(short x)

See Also:

• Numeric.negateExact(short)

nextAfter

public static double nextAfter(double start,
 double direction)

See Also:

• Numeric.nextAfter(double,double)

nextAfter

public static float nextAfter(float start,
 float direction)

See Also:

• Numeric.nextAfter(float,float)

nextDown

public static double nextDown(double x)

See Also:

• Numeric.nextDown(double)

nextDown

public static float nextDown(float x)

See Also:

• Numeric.nextDown(float)

nextUp

public static double nextUp(double x)

See Also:

• Numeric.nextUp(double)

nextUp

public static float nextUp(float x)

See Also:

• Numeric.nextUp(float)

not

public static Boolean[] not(Boolean... values)

See Also:

• Logic.not(java.lang.Boolean[])

not

public static Boolean[] not(boolean... values)

See Also:

• Logic.not(boolean[])

nth

public static byte nth(long index,
 byte... values)

See Also:

• Basic.nth(long,byte[])

nth

public static char nth(long index,
 char... values)

See Also:

• Basic.nth(long,char[])

nth

public static double nth(long index,
 double... values)

See Also:

• Basic.nth(long,double[])

nth

public static float nth(long index,
 float... values)

See Also:

• Basic.nth(long,float[])

nth

public static int nth(long index,
 int... values)

See Also:

• Basic.nth(long,int[])

nth

public static long nth(long index,
 long... values)

See Also:

• Basic.nth(long,long[])

nth

public static short nth(long index,
 short... values)

See Also:

• Basic.nth(long,short[])

nth

public static byte nth(long index,
 ByteVector values)

See Also:

• Basic.nth(long,io.deephaven.vector.ByteVector)

nth

public static char nth(long index,
 CharVector values)

See Also:

• Basic.nth(long,io.deephaven.vector.CharVector)

nth

public static double nth(long index,
 DoubleVector values)

See Also:

• Basic.nth(long,io.deephaven.vector.DoubleVector)

nth

public static float nth(long index,
 FloatVector values)

See Also:

• Basic.nth(long,io.deephaven.vector.FloatVector)

nth

public static int nth(long index,
 IntVector values)

See Also:

• Basic.nth(long,io.deephaven.vector.IntVector)

nth

public static long nth(long index,
 LongVector values)

See Also:

• Basic.nth(long,io.deephaven.vector.LongVector)

nth

public static short nth(long index,
 ShortVector values)

See Also:

• Basic.nth(long,io.deephaven.vector.ShortVector)

nthObj

public static <T> T nthObj(long index,
 T... values)

See Also:

• Basic.nthObj(long,java.lang.Object[])

nthObj

public static <T> T nthObj(long index,
 ObjectVector<T> values)

See Also:

• Basic.nthObj(long,io.deephaven.vector.ObjectVector)

nullValueFor

public static <T> T nullValueFor(Class<T> clazz)

See Also:

• Basic.nullValueFor(java.lang.Class)

or

public static Boolean or(Boolean... values)

See Also:

• Logic.or(java.lang.Boolean[])

or

public static Boolean or(boolean... values)

See Also:

• Logic.or(boolean[])

or

public static Boolean or(Boolean[] values,
 Boolean nullValue)

See Also:

• Logic.or(java.lang.Boolean[],java.lang.Boolean)

parseBoolean

public static Boolean parseBoolean(String s)

See Also:

• Parse.parseBoolean(java.lang.String)

parseByte

public static byte parseByte(String s)

See Also:

• Parse.parseByte(java.lang.String)

parseByte

public static byte parseByte(String s,
 int radix)

See Also:

• Parse.parseByte(java.lang.String,int)

parseDouble

public static double parseDouble(String s)

See Also:

• Parse.parseDouble(java.lang.String)

parseFloat

public static float parseFloat(String s)

See Also:

• Parse.parseFloat(java.lang.String)

parseInt

public static int parseInt(String s)

See Also:

• Parse.parseInt(java.lang.String)

parseInt

public static int parseInt(String s,
 int radix)

See Also:

• Parse.parseInt(java.lang.String,int)

parseLong

public static long parseLong(String s)

See Also:

• Parse.parseLong(java.lang.String)

parseLong

public static long parseLong(String s,
 int radix)

See Also:

• Parse.parseLong(java.lang.String,int)

parseShort

public static short parseShort(String s)

See Also:

• Parse.parseShort(java.lang.String)

parseShort

public static short parseShort(String s,
 int radix)

See Also:

• Parse.parseShort(java.lang.String,int)

parseUnsignedInt

public static int parseUnsignedInt(String s)

See Also:

• Parse.parseUnsignedInt(java.lang.String)

parseUnsignedInt

public static int parseUnsignedInt(String s,
 int radix)

See Also:

• Parse.parseUnsignedInt(java.lang.String,int)

parseUnsignedLong

public static long parseUnsignedLong(String s)

See Also:

• Parse.parseUnsignedLong(java.lang.String)

parseUnsignedLong

public static long parseUnsignedLong(String s,
 int radix)

See Also:

• Parse.parseUnsignedLong(java.lang.String,int)

percentile

public static byte percentile(double percentile,
 byte... values)

See Also:

• Numeric.percentile(double,byte[])

percentile

public static double percentile(double percentile,
 double... values)

See Also:

• Numeric.percentile(double,double[])

percentile

public static float percentile(double percentile,
 float... values)

See Also:

• Numeric.percentile(double,float[])

percentile

public static int percentile(double percentile,
 int... values)

See Also:

• Numeric.percentile(double,int[])

percentile

public static long percentile(double percentile,
 long... values)

See Also:

• Numeric.percentile(double,long[])

percentile

public static short percentile(double percentile,
 short... values)

See Also:

• Numeric.percentile(double,short[])

percentile

public static byte percentile(double percentile,
 ByteVector values)

See Also:

• Numeric.percentile(double,io.deephaven.vector.ByteVector)

percentile

public static double percentile(double percentile,
 DoubleVector values)

See Also:

• Numeric.percentile(double,io.deephaven.vector.DoubleVector)

percentile

public static float percentile(double percentile,
 FloatVector values)

See Also:

• Numeric.percentile(double,io.deephaven.vector.FloatVector)

percentile

public static int percentile(double percentile,
 IntVector values)

See Also:

• Numeric.percentile(double,io.deephaven.vector.IntVector)

percentile

public static long percentile(double percentile,
 LongVector values)

See Also:

• Numeric.percentile(double,io.deephaven.vector.LongVector)

percentile

public static short percentile(double percentile,
 ShortVector values)

See Also:

• Numeric.percentile(double,io.deephaven.vector.ShortVector)

pow

public static double pow(byte a,
 byte b)

See Also:

• Numeric.pow(byte,byte)

pow

public static double pow(byte a,
 double b)

See Also:

• Numeric.pow(byte,double)

pow

public static double pow(byte a,
 float b)

See Also:

• Numeric.pow(byte,float)

pow

public static double pow(byte a,
 int b)

See Also:

• Numeric.pow(byte,int)

pow

public static double pow(byte a,
 long b)

See Also:

• Numeric.pow(byte,long)

pow

public static double pow(byte a,
 short b)

See Also:

• Numeric.pow(byte,short)

pow

public static double pow(double a,
 byte b)

See Also:

• Numeric.pow(double,byte)

pow

public static double pow(double a,
 double b)

See Also:

• Numeric.pow(double,double)

pow

public static double pow(double a,
 float b)

See Also:

• Numeric.pow(double,float)

pow

public static double pow(double a,
 int b)

See Also:

• Numeric.pow(double,int)

pow

public static double pow(double a,
 long b)

See Also:

• Numeric.pow(double,long)

pow

public static double pow(double a,
 short b)

See Also:

• Numeric.pow(double,short)

pow

public static double pow(float a,
 byte b)

See Also:

• Numeric.pow(float,byte)

pow

public static double pow(float a,
 double b)

See Also:

• Numeric.pow(float,double)

pow

public static double pow(float a,
 float b)

See Also:

• Numeric.pow(float,float)

pow

public static double pow(float a,
 int b)

See Also:

• Numeric.pow(float,int)

pow

public static double pow(float a,
 long b)

See Also:

• Numeric.pow(float,long)

pow

public static double pow(float a,
 short b)

See Also:

• Numeric.pow(float,short)

pow

public static double pow(int a,
 byte b)

See Also:

• Numeric.pow(int,byte)

pow

public static double pow(int a,
 double b)

See Also:

• Numeric.pow(int,double)

pow

public static double pow(int a,
 float b)

See Also:

• Numeric.pow(int,float)

pow

public static double pow(int a,
 int b)

See Also:

• Numeric.pow(int,int)

pow

public static double pow(int a,
 long b)

See Also:

• Numeric.pow(int,long)

pow

public static double pow(int a,
 short b)

See Also:

• Numeric.pow(int,short)

pow

public static double pow(long a,
 byte b)

See Also:

• Numeric.pow(long,byte)

pow

public static double pow(long a,
 double b)

See Also:

• Numeric.pow(long,double)

pow

public static double pow(long a,
 float b)

See Also:

• Numeric.pow(long,float)

pow

public static double pow(long a,
 int b)

See Also:

• Numeric.pow(long,int)

pow

public static double pow(long a,
 long b)

See Also:

• Numeric.pow(long,long)

pow

public static double pow(long a,
 short b)

See Also:

• Numeric.pow(long,short)

pow

public static double pow(short a,
 byte b)

See Also:

• Numeric.pow(short,byte)

pow

public static double pow(short a,
 double b)

See Also:

• Numeric.pow(short,double)

pow

public static double pow(short a,
 float b)

See Also:

• Numeric.pow(short,float)

pow

public static double pow(short a,
 int b)

See Also:

• Numeric.pow(short,int)

pow

public static double pow(short a,
 long b)

See Also:

• Numeric.pow(short,long)

pow

public static double pow(short a,
 short b)

See Also:

• Numeric.pow(short,short)

product

public static long product(byte... values)

See Also:

• Numeric.product(byte[])

product

public static double product(double... values)

See Also:

• Numeric.product(double[])

product

public static double product(float... values)

See Also:

• Numeric.product(float[])

product

public static long product(int... values)

See Also:

• Numeric.product(int[])

product

public static long product(long... values)

See Also:

• Numeric.product(long[])

product

public static long product(short... values)

See Also:

• Numeric.product(short[])

product

public static long product(ByteVector values)

See Also:

• Numeric.product(io.deephaven.vector.ByteVector)

product

public static double product(DoubleVector values)

See Also:

• Numeric.product(io.deephaven.vector.DoubleVector)

product

public static double product(FloatVector values)

See Also:

• Numeric.product(io.deephaven.vector.FloatVector)

product

public static long product(IntVector values)

See Also:

• Numeric.product(io.deephaven.vector.IntVector)

product

public static long product(LongVector values)

See Also:

• Numeric.product(io.deephaven.vector.LongVector)

product

public static long product(ShortVector values)

See Also:

• Numeric.product(io.deephaven.vector.ShortVector)

random

public static double random()

See Also:

• Random.random()

randomBool

public static boolean randomBool()

See Also:

• Random.randomBool()

randomBool

public static boolean[] randomBool(int size)

See Also:

• Random.randomBool(int)

randomDouble

public static double randomDouble(double min,
 double max)

See Also:

• Random.randomDouble(double,double)

randomDouble

public static double[] randomDouble(double min,
 double max,
 int size)

See Also:

• Random.randomDouble(double,double,int)

randomFloat

public static float randomFloat(float min,
 float max)

See Also:

• Random.randomFloat(float,float)

randomFloat

public static float[] randomFloat(float min,
 float max,
 int size)

See Also:

• Random.randomFloat(float,float,int)

randomGaussian

public static double randomGaussian(double mean,
 double std)

See Also:

• Random.randomGaussian(double,double)

randomGaussian

public static double[] randomGaussian(double mean,
 double std,
 int size)

See Also:

• Random.randomGaussian(double,double,int)

randomInt

public static int randomInt(int min,
 int max)

See Also:

• Random.randomInt(int,int)

randomInt

public static int[] randomInt(int min,
 int max,
 int size)

See Also:

• Random.randomInt(int,int,int)

randomLong

public static long randomLong(long min,
 long max)

See Also:

• Random.randomLong(long,long)

randomLong

public static long[] randomLong(long min,
 long max,
 int size)

See Also:

• Random.randomLong(long,long,int)

rank

public static int[] rank(byte... values)

See Also:

• Sort.rank(byte[])

rank

public static int[] rank(double... values)

See Also:

• Sort.rank(double[])

rank

public static int[] rank(float... values)

See Also:

• Sort.rank(float[])

rank

public static int[] rank(int... values)

See Also:

• Sort.rank(int[])

rank

public static int[] rank(long... values)

See Also:

• Sort.rank(long[])

rank

public static int[] rank(Byte[] values)

See Also:

• Sort.rank(java.lang.Byte[])

rank

public static int[] rank(Double[] values)

See Also:

• Sort.rank(java.lang.Double[])

rank

public static int[] rank(Float[] values)

See Also:

• Sort.rank(java.lang.Float[])

rank

public static int[] rank(Integer[] values)

See Also:

• Sort.rank(java.lang.Integer[])

rank

public static int[] rank(Long[] values)

See Also:

• Sort.rank(java.lang.Long[])

rank

public static int[] rank(Short[] values)

See Also:

• Sort.rank(java.lang.Short[])

rank

public static int[] rank(short... values)

See Also:

• Sort.rank(short[])

rank

public static int[] rank(ByteVector values)

See Also:

• Sort.rank(io.deephaven.vector.ByteVector)

rank

public static int[] rank(DoubleVector values)

See Also:

• Sort.rank(io.deephaven.vector.DoubleVector)

rank

public static int[] rank(FloatVector values)

See Also:

• Sort.rank(io.deephaven.vector.FloatVector)

rank

public static int[] rank(IntVector values)

See Also:

• Sort.rank(io.deephaven.vector.IntVector)

rank

public static int[] rank(LongVector values)

See Also:

• Sort.rank(io.deephaven.vector.LongVector)

rank

public static int[] rank(ShortVector values)

See Also:

• Sort.rank(io.deephaven.vector.ShortVector)

rankDescending

public static int[] rankDescending(byte... values)

See Also:

• Sort.rankDescending(byte[])

rankDescending

public static int[] rankDescending(double... values)

See Also:

• Sort.rankDescending(double[])

rankDescending

public static int[] rankDescending(float... values)

See Also:

• Sort.rankDescending(float[])

rankDescending

public static int[] rankDescending(int... values)

See Also:

• Sort.rankDescending(int[])

rankDescending

public static int[] rankDescending(long... values)

See Also:

• Sort.rankDescending(long[])

rankDescending

public static int[] rankDescending(Byte[] values)

See Also:

• Sort.rankDescending(java.lang.Byte[])

rankDescending

public static int[] rankDescending(Double[] values)

See Also:

• Sort.rankDescending(java.lang.Double[])

rankDescending

public static int[] rankDescending(Float[] values)

See Also:

• Sort.rankDescending(java.lang.Float[])

rankDescending

public static int[] rankDescending(Integer[] values)

See Also:

• Sort.rankDescending(java.lang.Integer[])

rankDescending

public static int[] rankDescending(Long[] values)

See Also:

• Sort.rankDescending(java.lang.Long[])

rankDescending

public static int[] rankDescending(Short[] values)

See Also:

• Sort.rankDescending(java.lang.Short[])

rankDescending

public static int[] rankDescending(short... values)

See Also:

• Sort.rankDescending(short[])

rankDescending

public static int[] rankDescending(ByteVector values)

See Also:

• Sort.rankDescending(io.deephaven.vector.ByteVector)

rankDescending

public static int[] rankDescending(DoubleVector values)

See Also:

• Sort.rankDescending(io.deephaven.vector.DoubleVector)

rankDescending

public static int[] rankDescending(FloatVector values)

See Also:

• Sort.rankDescending(io.deephaven.vector.FloatVector)

rankDescending

public static int[] rankDescending(IntVector values)

See Also:

• Sort.rankDescending(io.deephaven.vector.IntVector)

rankDescending

public static int[] rankDescending(LongVector values)

See Also:

• Sort.rankDescending(io.deephaven.vector.LongVector)

rankDescending

public static int[] rankDescending(ShortVector values)

See Also:

• Sort.rankDescending(io.deephaven.vector.ShortVector)

rankDescendingObj

public static <T extends Comparable<? super T>>
int[] rankDescendingObj(T... values)

See Also:

• Sort.rankDescendingObj(java.lang.Comparable[])

rankDescendingObj

public static <T extends Comparable<? super T>>
int[] rankDescendingObj(ObjectVector<T> values)

See Also:

• Sort.rankDescendingObj(io.deephaven.vector.ObjectVector)

rankDescendingObj

public static <T extends Comparable<? super T>>
int[] rankDescendingObj(T[] values,
 Comparator<T> comparator)

See Also:

• Sort.rankDescendingObj(java.lang.Comparable[],java.util.Comparator)

rankDescendingObj

public static <T extends Comparable<? super T>>
int[] rankDescendingObj(ObjectVector<T> values,
 Comparator<T> comparator)

See Also:

• Sort.rankDescendingObj(io.deephaven.vector.ObjectVector,java.util.Comparator)

rankObj

public static <T extends Comparable<? super T>>
int[] rankObj(T... values)

See Also:

• Sort.rankObj(java.lang.Comparable[])

rankObj

public static <T extends Comparable<? super T>>
int[] rankObj(ObjectVector<T> values)

See Also:

• Sort.rankObj(io.deephaven.vector.ObjectVector)

rankObj

public static <T extends Comparable<? super T>>
int[] rankObj(T[] values,
 Comparator<T> comparator)

See Also:

• Sort.rankObj(java.lang.Comparable[],java.util.Comparator)

rankObj

public static <T extends Comparable<? super T>>
int[] rankObj(ObjectVector<T> values,
 Comparator<T> comparator)

See Also:

• Sort.rankObj(io.deephaven.vector.ObjectVector,java.util.Comparator)

rawBinSearchIndex

public static <T extends Comparable<? super T>> int rawBinSearchIndex(T[] values,
 T key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.rawBinSearchIndex(java.lang.Comparable[],java.lang.Comparable,io.deephaven.function.BinSearchAlgo)

rawBinSearchIndex

public static int rawBinSearchIndex(byte[] values,
 byte key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.rawBinSearchIndex(byte[],byte,io.deephaven.function.BinSearchAlgo)

rawBinSearchIndex

public static int rawBinSearchIndex(char[] values,
 char key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.rawBinSearchIndex(char[],char,io.deephaven.function.BinSearchAlgo)

rawBinSearchIndex

public static int rawBinSearchIndex(double[] values,
 double key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.rawBinSearchIndex(double[],double,io.deephaven.function.BinSearchAlgo)

rawBinSearchIndex

public static int rawBinSearchIndex(float[] values,
 float key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.rawBinSearchIndex(float[],float,io.deephaven.function.BinSearchAlgo)

rawBinSearchIndex

public static int rawBinSearchIndex(int[] values,
 int key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.rawBinSearchIndex(int[],int,io.deephaven.function.BinSearchAlgo)

rawBinSearchIndex

public static int rawBinSearchIndex(long[] values,
 long key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.rawBinSearchIndex(long[],long,io.deephaven.function.BinSearchAlgo)

rawBinSearchIndex

public static int rawBinSearchIndex(short[] values,
 short key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.rawBinSearchIndex(short[],short,io.deephaven.function.BinSearchAlgo)

rawBinSearchIndex

public static int rawBinSearchIndex(ByteVector values,
 byte key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.rawBinSearchIndex(io.deephaven.vector.ByteVector,byte,io.deephaven.function.BinSearchAlgo)

rawBinSearchIndex

public static int rawBinSearchIndex(CharVector values,
 char key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.rawBinSearchIndex(io.deephaven.vector.CharVector,char,io.deephaven.function.BinSearchAlgo)

rawBinSearchIndex

public static int rawBinSearchIndex(DoubleVector values,
 double key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.rawBinSearchIndex(io.deephaven.vector.DoubleVector,double,io.deephaven.function.BinSearchAlgo)

rawBinSearchIndex

public static int rawBinSearchIndex(FloatVector values,
 float key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.rawBinSearchIndex(io.deephaven.vector.FloatVector,float,io.deephaven.function.BinSearchAlgo)

rawBinSearchIndex

public static int rawBinSearchIndex(IntVector values,
 int key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.rawBinSearchIndex(io.deephaven.vector.IntVector,int,io.deephaven.function.BinSearchAlgo)

rawBinSearchIndex

public static int rawBinSearchIndex(LongVector values,
 long key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.rawBinSearchIndex(io.deephaven.vector.LongVector,long,io.deephaven.function.BinSearchAlgo)

rawBinSearchIndex

public static int rawBinSearchIndex(ShortVector values,
 short key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.rawBinSearchIndex(io.deephaven.vector.ShortVector,short,io.deephaven.function.BinSearchAlgo)

rawBinSearchIndex

public static <T extends Comparable<? super T>> int rawBinSearchIndex(ObjectVector<T> values,
 T key,
 BinSearchAlgo choiceWhenEquals)

See Also:

• BinSearch.rawBinSearchIndex(io.deephaven.vector.ObjectVector,java.lang.Comparable,io.deephaven.function.BinSearchAlgo)

repeat

public static <T> T[] repeat(T value,
 int size)

See Also:

• Basic.repeat(java.lang.Object,int)

repeat

public static byte[] repeat(byte value,
 int size)

See Also:

• Basic.repeat(byte,int)

repeat

public static char[] repeat(char value,
 int size)

See Also:

• Basic.repeat(char,int)

repeat

public static double[] repeat(double value,
 int size)

See Also:

• Basic.repeat(double,int)

repeat

public static float[] repeat(float value,
 int size)

See Also:

• Basic.repeat(float,int)

repeat

public static int[] repeat(int value,
 int size)

See Also:

• Basic.repeat(int,int)

repeat

public static long[] repeat(long value,
 int size)

See Also:

• Basic.repeat(long,int)

repeat

public static short[] repeat(short value,
 int size)

See Also:

• Basic.repeat(short,int)

replaceIfNaN

public static double[] replaceIfNaN(double[] values,
 double replacement)

See Also:

• Numeric.replaceIfNaN(double[],double)

replaceIfNaN

public static float[] replaceIfNaN(float[] values,
 float replacement)

See Also:

• Numeric.replaceIfNaN(float[],float)

replaceIfNaN

public static double replaceIfNaN(double value,
 double replacement)

See Also:

• Numeric.replaceIfNaN(double,double)

replaceIfNaN

public static float replaceIfNaN(float value,
 float replacement)

See Also:

• Numeric.replaceIfNaN(float,float)

replaceIfNaN

public static double[] replaceIfNaN(DoubleVector values,
 double replacement)

See Also:

• Numeric.replaceIfNaN(io.deephaven.vector.DoubleVector,double)

replaceIfNaN

public static float[] replaceIfNaN(FloatVector values,
 float replacement)

See Also:

• Numeric.replaceIfNaN(io.deephaven.vector.FloatVector,float)

replaceIfNonFinite

public static double[] replaceIfNonFinite(double[] values,
 double replacement)

See Also:

• Numeric.replaceIfNonFinite(double[],double)

replaceIfNonFinite

public static float[] replaceIfNonFinite(float[] values,
 float replacement)

See Also:

• Numeric.replaceIfNonFinite(float[],float)

replaceIfNonFinite

public static double replaceIfNonFinite(double value,
 double replacement)

See Also:

• Numeric.replaceIfNonFinite(double,double)

replaceIfNonFinite

public static float replaceIfNonFinite(float value,
 float replacement)

See Also:

• Numeric.replaceIfNonFinite(float,float)

replaceIfNonFinite

public static double[] replaceIfNonFinite(DoubleVector values,
 double replacement)

See Also:

• Numeric.replaceIfNonFinite(io.deephaven.vector.DoubleVector,double)

replaceIfNonFinite

public static float[] replaceIfNonFinite(FloatVector values,
 float replacement)

See Also:

• Numeric.replaceIfNonFinite(io.deephaven.vector.FloatVector,float)

replaceIfNull

public static <T> T replaceIfNull(T value,
 T replacement)

See Also:

• Basic.replaceIfNull(java.lang.Object,java.lang.Object)

replaceIfNull

public static <T> T[] replaceIfNull(T[] values,
 T replacement)

See Also:

• Basic.replaceIfNull(java.lang.Object[],java.lang.Object)

replaceIfNull

public static byte replaceIfNull(byte value,
 byte replacement)

See Also:

• Basic.replaceIfNull(byte,byte)

replaceIfNull

public static char replaceIfNull(char value,
 char replacement)

See Also:

• Basic.replaceIfNull(char,char)

replaceIfNull

public static byte[] replaceIfNull(byte[] values,
 byte replacement)

See Also:

• Basic.replaceIfNull(byte[],byte)

replaceIfNull

public static char[] replaceIfNull(char[] values,
 char replacement)

See Also:

• Basic.replaceIfNull(char[],char)

replaceIfNull

public static double[] replaceIfNull(double[] values,
 double replacement)

See Also:

• Basic.replaceIfNull(double[],double)

replaceIfNull

public static float[] replaceIfNull(float[] values,
 float replacement)

See Also:

• Basic.replaceIfNull(float[],float)

replaceIfNull

public static int[] replaceIfNull(int[] values,
 int replacement)

See Also:

• Basic.replaceIfNull(int[],int)

replaceIfNull

public static long[] replaceIfNull(long[] values,
 long replacement)

See Also:

• Basic.replaceIfNull(long[],long)

replaceIfNull

public static short[] replaceIfNull(short[] values,
 short replacement)

See Also:

• Basic.replaceIfNull(short[],short)

replaceIfNull

public static double replaceIfNull(double value,
 double replacement)

See Also:

• Basic.replaceIfNull(double,double)

replaceIfNull

public static float replaceIfNull(float value,
 float replacement)

See Also:

• Basic.replaceIfNull(float,float)

replaceIfNull

public static int replaceIfNull(int value,
 int replacement)

See Also:

• Basic.replaceIfNull(int,int)

replaceIfNull

public static byte[] replaceIfNull(ByteVector values,
 byte replacement)

See Also:

• Basic.replaceIfNull(io.deephaven.vector.ByteVector,byte)

replaceIfNull

public static char[] replaceIfNull(CharVector values,
 char replacement)

See Also:

• Basic.replaceIfNull(io.deephaven.vector.CharVector,char)

replaceIfNull

public static double[] replaceIfNull(DoubleVector values,
 double replacement)

See Also:

• Basic.replaceIfNull(io.deephaven.vector.DoubleVector,double)

replaceIfNull

public static float[] replaceIfNull(FloatVector values,
 float replacement)

See Also:

• Basic.replaceIfNull(io.deephaven.vector.FloatVector,float)

replaceIfNull

public static int[] replaceIfNull(IntVector values,
 int replacement)

See Also:

• Basic.replaceIfNull(io.deephaven.vector.IntVector,int)

replaceIfNull

public static long[] replaceIfNull(LongVector values,
 long replacement)

See Also:

• Basic.replaceIfNull(io.deephaven.vector.LongVector,long)

replaceIfNull

public static short[] replaceIfNull(ShortVector values,
 short replacement)

See Also:

• Basic.replaceIfNull(io.deephaven.vector.ShortVector,short)

replaceIfNull

public static <T> T[] replaceIfNull(ObjectVector<T> values,
 T replacement)

See Also:

• Basic.replaceIfNull(io.deephaven.vector.ObjectVector,java.lang.Object)

replaceIfNull

public static long replaceIfNull(long value,
 long replacement)

See Also:

• Basic.replaceIfNull(long,long)

replaceIfNull

public static short replaceIfNull(short value,
 short replacement)

See Also:

• Basic.replaceIfNull(short,short)

replaceIfNullNaN

public static double[] replaceIfNullNaN(double[] values,
 double replacement)

See Also:

• Numeric.replaceIfNullNaN(double[],double)

replaceIfNullNaN

public static float[] replaceIfNullNaN(float[] values,
 float replacement)

See Also:

• Numeric.replaceIfNullNaN(float[],float)

replaceIfNullNaN

public static double replaceIfNullNaN(double value,
 double replacement)

See Also:

• Numeric.replaceIfNullNaN(double,double)

replaceIfNullNaN

public static float replaceIfNullNaN(float value,
 float replacement)

See Also:

• Numeric.replaceIfNullNaN(float,float)

replaceIfNullNaN

public static double[] replaceIfNullNaN(DoubleVector values,
 double replacement)

See Also:

• Numeric.replaceIfNullNaN(io.deephaven.vector.DoubleVector,double)

replaceIfNullNaN

public static float[] replaceIfNullNaN(FloatVector values,
 float replacement)

See Also:

• Numeric.replaceIfNullNaN(io.deephaven.vector.FloatVector,float)

reverse

public static byte[] reverse(byte... values)

See Also:

• Basic.reverse(byte[])

reverse

public static char[] reverse(char... values)

See Also:

• Basic.reverse(char[])

reverse

public static double[] reverse(double... values)

See Also:

• Basic.reverse(double[])

reverse

public static float[] reverse(float... values)

See Also:

• Basic.reverse(float[])

reverse

public static int[] reverse(int... values)

See Also:

• Basic.reverse(int[])

reverse

public static long[] reverse(long... values)

See Also:

• Basic.reverse(long[])

reverse

public static short[] reverse(short... values)

See Also:

• Basic.reverse(short[])

reverse

public static byte[] reverse(ByteVector values)

See Also:

• Basic.reverse(io.deephaven.vector.ByteVector)

reverse

public static char[] reverse(CharVector values)

See Also:

• Basic.reverse(io.deephaven.vector.CharVector)

reverse

public static double[] reverse(DoubleVector values)

See Also:

• Basic.reverse(io.deephaven.vector.DoubleVector)

reverse

public static float[] reverse(FloatVector values)

See Also:

• Basic.reverse(io.deephaven.vector.FloatVector)

reverse

public static int[] reverse(IntVector values)

See Also:

• Basic.reverse(io.deephaven.vector.IntVector)

reverse

public static long[] reverse(LongVector values)

See Also:

• Basic.reverse(io.deephaven.vector.LongVector)

reverse

public static short[] reverse(ShortVector values)

See Also:

• Basic.reverse(io.deephaven.vector.ShortVector)

reverseObj

public static <T> T[] reverseObj(T... values)

See Also:

• Basic.reverseObj(java.lang.Object[])

reverseObj

public static <T> T[] reverseObj(ObjectVector<T> values)

See Also:

• Basic.reverseObj(io.deephaven.vector.ObjectVector)

rint

public static double rint(byte value)

See Also:

• Numeric.rint(byte)

rint

public static double rint(double value)

See Also:

• Numeric.rint(double)

rint

public static double rint(float value)

See Also:

• Numeric.rint(float)

rint

public static double rint(int value)

See Also:

• Numeric.rint(int)

rint

public static double rint(long value)

See Also:

• Numeric.rint(long)

rint

public static double rint(short value)

See Also:

• Numeric.rint(short)

round

public static long round(byte value)

See Also:

• Numeric.round(byte)

round

public static long round(double value)

See Also:

• Numeric.round(double)

round

public static long round(float value)

See Also:

• Numeric.round(float)

round

public static long round(int value)

See Also:

• Numeric.round(int)

round

public static long round(long value)

See Also:

• Numeric.round(long)

round

public static long round(short value)

See Also:

• Numeric.round(short)

scalb

public static double scalb(double x,
 int scaleFactor)

See Also:

• Numeric.scalb(double,int)

scalb

public static float scalb(float x,
 int scaleFactor)

See Also:

• Numeric.scalb(float,int)

sequence

public static byte[] sequence(byte start,
 byte end,
 byte step)

See Also:

• Numeric.sequence(byte,byte,byte)

sequence

public static double[] sequence(double start,
 double end,
 double step)

See Also:

• Numeric.sequence(double,double,double)

sequence

public static float[] sequence(float start,
 float end,
 float step)

See Also:

• Numeric.sequence(float,float,float)

sequence

public static int[] sequence(int start,
 int end,
 int step)

See Also:

• Numeric.sequence(int,int,int)

sequence

public static long[] sequence(long start,
 long end,
 long step)

See Also:

• Numeric.sequence(long,long,long)

sequence

public static short[] sequence(short start,
 short end,
 short step)

See Also:

• Numeric.sequence(short,short,short)

signum

public static int signum(byte value)

See Also:

• Numeric.signum(byte)

signum

public static int signum(double value)

See Also:

• Numeric.signum(double)

signum

public static int signum(float value)

See Also:

• Numeric.signum(float)

signum

public static int signum(int value)

See Also:

• Numeric.signum(int)

signum

public static int signum(long value)

See Also:

• Numeric.signum(long)

signum

public static int signum(short value)

See Also:

• Numeric.signum(short)

sin

public static double sin(byte value)

See Also:

• Numeric.sin(byte)

sin

public static double sin(double value)

See Also:

• Numeric.sin(double)

sin

public static double sin(float value)

See Also:

• Numeric.sin(float)

sin

public static double sin(int value)

See Also:

• Numeric.sin(int)

sin

public static double sin(long value)

See Also:

• Numeric.sin(long)

sin

public static double sin(short value)

See Also:

• Numeric.sin(short)

sinh

public static double sinh(byte x)

See Also:

• Numeric.sinh(byte)

sinh

public static double sinh(double x)

See Also:

• Numeric.sinh(double)

sinh

public static double sinh(float x)

See Also:

• Numeric.sinh(float)

sinh

public static double sinh(int x)

See Also:

• Numeric.sinh(int)

sinh

public static double sinh(long x)

See Also:

• Numeric.sinh(long)

sinh

public static double sinh(short x)

See Also:

• Numeric.sinh(short)

sort

public static byte[] sort(byte... values)

See Also:

• Sort.sort(byte[])

sort

public static double[] sort(double... values)

See Also:

• Sort.sort(double[])

sort

public static float[] sort(float... values)

See Also:

• Sort.sort(float[])

sort

public static int[] sort(int... values)

See Also:

• Sort.sort(int[])

sort

public static long[] sort(long... values)

See Also:

• Sort.sort(long[])

sort

public static byte[] sort(Byte[] values)

See Also:

• Sort.sort(java.lang.Byte[])

sort

public static double[] sort(Double[] values)

See Also:

• Sort.sort(java.lang.Double[])

sort

public static float[] sort(Float[] values)

See Also:

• Sort.sort(java.lang.Float[])

sort

public static int[] sort(Integer[] values)

See Also:

• Sort.sort(java.lang.Integer[])

sort

public static long[] sort(Long[] values)

See Also:

• Sort.sort(java.lang.Long[])

sort

public static short[] sort(Short[] values)

See Also:

• Sort.sort(java.lang.Short[])

sort

public static short[] sort(short... values)

See Also:

• Sort.sort(short[])

sort

public static byte[] sort(ByteVector values)

See Also:

• Sort.sort(io.deephaven.vector.ByteVector)

sort

public static double[] sort(DoubleVector values)

See Also:

• Sort.sort(io.deephaven.vector.DoubleVector)

sort

public static float[] sort(FloatVector values)

See Also:

• Sort.sort(io.deephaven.vector.FloatVector)

sort

public static int[] sort(IntVector values)

See Also:

• Sort.sort(io.deephaven.vector.IntVector)

sort

public static long[] sort(LongVector values)

See Also:

• Sort.sort(io.deephaven.vector.LongVector)

sort

public static short[] sort(ShortVector values)

See Also:

• Sort.sort(io.deephaven.vector.ShortVector)

sortDescending

public static byte[] sortDescending(byte... values)

See Also:

• Sort.sortDescending(byte[])

sortDescending

public static double[] sortDescending(double... values)

See Also:

• Sort.sortDescending(double[])

sortDescending

public static float[] sortDescending(float... values)

See Also:

• Sort.sortDescending(float[])

sortDescending

public static int[] sortDescending(int... values)

See Also:

• Sort.sortDescending(int[])

sortDescending

public static long[] sortDescending(long... values)

See Also:

• Sort.sortDescending(long[])

sortDescending

public static byte[] sortDescending(Byte[] values)

See Also:

• Sort.sortDescending(java.lang.Byte[])

sortDescending

public static double[] sortDescending(Double[] values)

See Also:

• Sort.sortDescending(java.lang.Double[])

sortDescending

public static float[] sortDescending(Float[] values)

See Also:

• Sort.sortDescending(java.lang.Float[])

sortDescending

public static int[] sortDescending(Integer[] values)

See Also:

• Sort.sortDescending(java.lang.Integer[])

sortDescending

public static long[] sortDescending(Long[] values)

See Also:

• Sort.sortDescending(java.lang.Long[])

sortDescending

public static short[] sortDescending(Short[] values)

See Also:

• Sort.sortDescending(java.lang.Short[])

sortDescending

public static short[] sortDescending(short... values)

See Also:

• Sort.sortDescending(short[])

sortDescending

public static byte[] sortDescending(ByteVector values)

See Also:

• Sort.sortDescending(io.deephaven.vector.ByteVector)

sortDescending

public static double[] sortDescending(DoubleVector values)

See Also:

• Sort.sortDescending(io.deephaven.vector.DoubleVector)

sortDescending

public static float[] sortDescending(FloatVector values)

See Also:

• Sort.sortDescending(io.deephaven.vector.FloatVector)

sortDescending

public static int[] sortDescending(IntVector values)

See Also:

• Sort.sortDescending(io.deephaven.vector.IntVector)

sortDescending

public static long[] sortDescending(LongVector values)

See Also:

• Sort.sortDescending(io.deephaven.vector.LongVector)

sortDescending

public static short[] sortDescending(ShortVector values)

See Also:

• Sort.sortDescending(io.deephaven.vector.ShortVector)

sortDescendingObj

public static <T extends Comparable<? super T>> T[] sortDescendingObj(T... values)

See Also:

• Sort.sortDescendingObj(java.lang.Comparable[])

sortDescendingObj

public static <T extends Comparable<? super T>> T[] sortDescendingObj(ObjectVector<T> values)

See Also:

• Sort.sortDescendingObj(io.deephaven.vector.ObjectVector)

sortDescendingObj

public static <T extends Comparable<? super T>> T[] sortDescendingObj(T[] values,
 Comparator<T> comparator)

See Also:

• Sort.sortDescendingObj(java.lang.Comparable[],java.util.Comparator)

sortDescendingObj

public static <T extends Comparable<? super T>> T[] sortDescendingObj(ObjectVector<T> values,
 Comparator<T> comparator)

See Also:

• Sort.sortDescendingObj(io.deephaven.vector.ObjectVector,java.util.Comparator)

sortObj

public static <T extends Comparable<? super T>> T[] sortObj(T... values)

See Also:

• Sort.sortObj(java.lang.Comparable[])

sortObj

public static <T extends Comparable<? super T>> T[] sortObj(ObjectVector<T> values)

See Also:

• Sort.sortObj(io.deephaven.vector.ObjectVector)

sortObj

public static <T extends Comparable<? super T>> T[] sortObj(T[] values,
 Comparator<T> comparator)

See Also:

• Sort.sortObj(java.lang.Comparable[],java.util.Comparator)

sortObj

public static <T extends Comparable<? super T>> T[] sortObj(ObjectVector<T> values,
 Comparator<T> comparator)

See Also:

• Sort.sortObj(io.deephaven.vector.ObjectVector,java.util.Comparator)

sqrt

public static double sqrt(byte value)

See Also:

• Numeric.sqrt(byte)

sqrt

public static double sqrt(double value)

See Also:

• Numeric.sqrt(double)

sqrt

public static double sqrt(float value)

See Also:

• Numeric.sqrt(float)

sqrt

public static double sqrt(int value)

See Also:

• Numeric.sqrt(int)

sqrt

public static double sqrt(long value)

See Also:

• Numeric.sqrt(long)

sqrt

public static double sqrt(short value)

See Also:

• Numeric.sqrt(short)

std

public static double std(byte... values)

See Also:

• Numeric.std(byte[])

std

public static double std(double... values)

See Also:

• Numeric.std(double[])

std

public static double std(float... values)

See Also:

• Numeric.std(float[])

std

public static double std(int... values)

See Also:

• Numeric.std(int[])

std

public static double std(long... values)

See Also:

• Numeric.std(long[])

std

public static double std(Byte[] values)

See Also:

• Numeric.std(java.lang.Byte[])

std

public static double std(Double[] values)

See Also:

• Numeric.std(java.lang.Double[])

std

public static double std(Float[] values)

See Also:

• Numeric.std(java.lang.Float[])

std

public static double std(Integer[] values)

See Also:

• Numeric.std(java.lang.Integer[])

std

public static double std(Long[] values)

See Also:

• Numeric.std(java.lang.Long[])

std

public static double std(Short[] values)

See Also:

• Numeric.std(java.lang.Short[])

std

public static double std(short... values)

See Also:

• Numeric.std(short[])

std

public static double std(ByteVector values)

See Also:

• Numeric.std(io.deephaven.vector.ByteVector)

std

public static double std(DoubleVector values)

See Also:

• Numeric.std(io.deephaven.vector.DoubleVector)

std

public static double std(FloatVector values)

See Also:

• Numeric.std(io.deephaven.vector.FloatVector)

std

public static double std(IntVector values)

See Also:

• Numeric.std(io.deephaven.vector.IntVector)

std

public static double std(LongVector values)

See Also:

• Numeric.std(io.deephaven.vector.LongVector)

std

public static double std(ShortVector values)

See Also:

• Numeric.std(io.deephaven.vector.ShortVector)

ste

public static double ste(byte... values)

See Also:

• Numeric.ste(byte[])

ste

public static double ste(double... values)

See Also:

• Numeric.ste(double[])

ste

public static double ste(float... values)

See Also:

• Numeric.ste(float[])

ste

public static double ste(int... values)

See Also:

• Numeric.ste(int[])

ste

public static double ste(long... values)

See Also:

• Numeric.ste(long[])

ste

public static double ste(Byte[] values)

See Also:

• Numeric.ste(java.lang.Byte[])

ste

public static double ste(Double[] values)

See Also:

• Numeric.ste(java.lang.Double[])

ste

public static double ste(Float[] values)

See Also:

• Numeric.ste(java.lang.Float[])

ste

public static double ste(Integer[] values)

See Also:

• Numeric.ste(java.lang.Integer[])

ste

public static double ste(Long[] values)

See Also:

• Numeric.ste(java.lang.Long[])

ste

public static double ste(Short[] values)

See Also:

• Numeric.ste(java.lang.Short[])

ste

public static double ste(short... values)

See Also:

• Numeric.ste(short[])

ste

public static double ste(ByteVector values)

See Also:

• Numeric.ste(io.deephaven.vector.ByteVector)

ste

public static double ste(DoubleVector values)

See Also:

• Numeric.ste(io.deephaven.vector.DoubleVector)

ste

public static double ste(FloatVector values)

See Also:

• Numeric.ste(io.deephaven.vector.FloatVector)

ste

public static double ste(IntVector values)

See Also:

• Numeric.ste(io.deephaven.vector.IntVector)

ste

public static double ste(LongVector values)

See Also:

• Numeric.ste(io.deephaven.vector.LongVector)

ste

public static double ste(ShortVector values)

See Also:

• Numeric.ste(io.deephaven.vector.ShortVector)

subtractExact

public static byte subtractExact(byte x,
 byte y)

See Also:

• Numeric.subtractExact(byte,byte)

subtractExact

public static int subtractExact(int x,
 int y)

See Also:

• Numeric.subtractExact(int,int)

subtractExact

public static long subtractExact(long x,
 long y)

See Also:

• Numeric.subtractExact(long,long)

subtractExact

public static short subtractExact(short x,
 short y)

See Also:

• Numeric.subtractExact(short,short)

sum

public static long sum(byte... values)

See Also:

• Numeric.sum(byte[])

sum

public static double sum(double... values)

See Also:

• Numeric.sum(double[])

sum

public static double sum(float... values)

See Also:

• Numeric.sum(float[])

sum

public static long sum(int... values)

See Also:

• Numeric.sum(int[])

sum

public static long sum(long... values)

See Also:

• Numeric.sum(long[])

sum

public static long sum(short... values)

See Also:

• Numeric.sum(short[])

sum

public static long sum(ByteVector values)

See Also:

• Numeric.sum(io.deephaven.vector.ByteVector)

sum

public static double sum(DoubleVector values)

See Also:

• Numeric.sum(io.deephaven.vector.DoubleVector)

sum

public static double sum(FloatVector values)

See Also:

• Numeric.sum(io.deephaven.vector.FloatVector)

sum

public static long sum(IntVector values)

See Also:

• Numeric.sum(io.deephaven.vector.IntVector)

sum

public static long sum(LongVector values)

See Also:

• Numeric.sum(io.deephaven.vector.LongVector)

sum

public static long sum(ShortVector values)

See Also:

• Numeric.sum(io.deephaven.vector.ShortVector)

tan

public static double tan(byte value)

See Also:

• Numeric.tan(byte)

tan

public static double tan(double value)

See Also:

• Numeric.tan(double)

tan

public static double tan(float value)

See Also:

• Numeric.tan(float)

tan

public static double tan(int value)

See Also:

• Numeric.tan(int)

tan

public static double tan(long value)

See Also:

• Numeric.tan(long)

tan

public static double tan(short value)

See Also:

• Numeric.tan(short)

tanh

public static double tanh(byte x)

See Also:

• Numeric.tanh(byte)

tanh

public static double tanh(double x)

See Also:

• Numeric.tanh(double)

tanh

public static double tanh(float x)

See Also:

• Numeric.tanh(float)

tanh

public static double tanh(int x)

See Also:

• Numeric.tanh(int)

tanh

public static double tanh(long x)

See Also:

• Numeric.tanh(long)

tanh

public static double tanh(short x)

See Also:

• Numeric.tanh(short)

toByteExact

public static short toByteExact(byte x)

See Also:

• Numeric.toByteExact(byte)

toByteExact

public static short toByteExact(int x)

See Also:

• Numeric.toByteExact(int)

toByteExact

public static short toByteExact(long x)

See Also:

• Numeric.toByteExact(long)

toByteExact

public static short toByteExact(short x)

See Also:

• Numeric.toByteExact(short)

toDegrees

public static double toDegrees(byte x)

See Also:

• Numeric.toDegrees(byte)

toDegrees

public static double toDegrees(double x)

See Also:

• Numeric.toDegrees(double)

toDegrees

public static double toDegrees(float x)

See Also:

• Numeric.toDegrees(float)

toDegrees

public static double toDegrees(int x)

See Also:

• Numeric.toDegrees(int)

toDegrees

public static double toDegrees(long x)

See Also:

• Numeric.toDegrees(long)

toDegrees

public static double toDegrees(short x)

See Also:

• Numeric.toDegrees(short)

toIntExact

public static int toIntExact(byte x)

See Also:

• Numeric.toIntExact(byte)

toIntExact

public static int toIntExact(int x)

See Also:

• Numeric.toIntExact(int)

toIntExact

public static int toIntExact(long x)

See Also:

• Numeric.toIntExact(long)

toIntExact

public static int toIntExact(short x)

See Also:

• Numeric.toIntExact(short)

toRadians

public static double toRadians(byte x)

See Also:

• Numeric.toRadians(byte)

toRadians

public static double toRadians(double x)

See Also:

• Numeric.toRadians(double)

toRadians

public static double toRadians(float x)

See Also:

• Numeric.toRadians(float)

toRadians

public static double toRadians(int x)

See Also:

• Numeric.toRadians(int)

toRadians

public static double toRadians(long x)

See Also:

• Numeric.toRadians(long)

toRadians

public static double toRadians(short x)

See Also:

• Numeric.toRadians(short)

toShortExact

public static short toShortExact(byte x)

See Also:

• Numeric.toShortExact(byte)

toShortExact

public static short toShortExact(int x)

See Also:

• Numeric.toShortExact(int)

toShortExact

public static short toShortExact(long x)

See Also:

• Numeric.toShortExact(long)

toShortExact

public static short toShortExact(short x)

See Also:

• Numeric.toShortExact(short)

tstat

public static double tstat(byte... values)

See Also:

• Numeric.tstat(byte[])

tstat

public static double tstat(double... values)

See Also:

• Numeric.tstat(double[])

tstat

public static double tstat(float... values)

See Also:

• Numeric.tstat(float[])

tstat

public static double tstat(int... values)

See Also:

• Numeric.tstat(int[])

tstat

public static double tstat(long... values)

See Also:

• Numeric.tstat(long[])

tstat

public static double tstat(Byte[] values)

See Also:

• Numeric.tstat(java.lang.Byte[])

tstat

public static double tstat(Double[] values)

See Also:

• Numeric.tstat(java.lang.Double[])

tstat

public static double tstat(Float[] values)

See Also:

• Numeric.tstat(java.lang.Float[])

tstat

public static double tstat(Integer[] values)

See Also:

• Numeric.tstat(java.lang.Integer[])

tstat

public static double tstat(Long[] values)

See Also:

• Numeric.tstat(java.lang.Long[])

tstat

public static double tstat(Short[] values)

See Also:

• Numeric.tstat(java.lang.Short[])

tstat

public static double tstat(short... values)

See Also:

• Numeric.tstat(short[])

tstat

public static double tstat(ByteVector values)

See Also:

• Numeric.tstat(io.deephaven.vector.ByteVector)

tstat

public static double tstat(DoubleVector values)

See Also:

• Numeric.tstat(io.deephaven.vector.DoubleVector)

tstat

public static double tstat(FloatVector values)

See Also:

• Numeric.tstat(io.deephaven.vector.FloatVector)

tstat

public static double tstat(IntVector values)

See Also:

• Numeric.tstat(io.deephaven.vector.IntVector)

tstat

public static double tstat(LongVector values)

See Also:

• Numeric.tstat(io.deephaven.vector.LongVector)

tstat

public static double tstat(ShortVector values)

See Also:

• Numeric.tstat(io.deephaven.vector.ShortVector)

ulp

public static double ulp(double x)

See Also:

• Numeric.ulp(double)

ulp

public static float ulp(float x)

See Also:

• Numeric.ulp(float)

unbox

public static byte[] unbox(Byte... values)

See Also:

• Basic.unbox(java.lang.Byte[])

unbox

public static char[] unbox(Character... values)

See Also:

• Basic.unbox(java.lang.Character[])

unbox

public static double[] unbox(Double... values)

See Also:

• Basic.unbox(java.lang.Double[])

unbox

public static float[] unbox(Float... values)

See Also:

• Basic.unbox(java.lang.Float[])

unbox

public static int[] unbox(Integer... values)

See Also:

• Basic.unbox(java.lang.Integer[])

unbox

public static long[] unbox(Long... values)

See Also:

• Basic.unbox(java.lang.Long[])

unbox

public static short[] unbox(Short... values)

See Also:

• Basic.unbox(java.lang.Short[])

upperBin

public static byte upperBin(byte value,
 byte interval)

See Also:

• Numeric.upperBin(byte,byte)

upperBin

public static double upperBin(double value,
 double interval)

See Also:

• Numeric.upperBin(double,double)

upperBin

public static float upperBin(float value,
 float interval)

See Also:

• Numeric.upperBin(float,float)

upperBin

public static int upperBin(int value,
 int interval)

See Also:

• Numeric.upperBin(int,int)

upperBin

public static long upperBin(long value,
 long interval)

See Also:

• Numeric.upperBin(long,long)

upperBin

public static short upperBin(short value,
 short interval)

See Also:

• Numeric.upperBin(short,short)

upperBin

public static byte upperBin(byte value,
 byte interval,
 byte offset)

See Also:

• Numeric.upperBin(byte,byte,byte)

upperBin

public static double upperBin(double value,
 double interval,
 double offset)

See Also:

• Numeric.upperBin(double,double,double)

upperBin

public static float upperBin(float value,
 float interval,
 float offset)

See Also:

• Numeric.upperBin(float,float,float)

upperBin

public static int upperBin(int value,
 int interval,
 int offset)

See Also:

• Numeric.upperBin(int,int,int)

upperBin

public static long upperBin(long value,
 long interval,
 long offset)

See Also:

• Numeric.upperBin(long,long,long)

upperBin

public static short upperBin(short value,
 short interval,
 short offset)

See Also:

• Numeric.upperBin(short,short,short)

var

public static double var(byte... values)

See Also:

• Numeric.var(byte[])

var

public static double var(double... values)

See Also:

• Numeric.var(double[])

var

public static double var(float... values)

See Also:

• Numeric.var(float[])

var

public static double var(int... values)

See Also:

• Numeric.var(int[])

var

public static double var(long... values)

See Also:

• Numeric.var(long[])

var

public static double var(Byte[] values)

See Also:

• Numeric.var(java.lang.Byte[])

var

public static double var(Double[] values)

See Also:

• Numeric.var(java.lang.Double[])

var

public static double var(Float[] values)

See Also:

• Numeric.var(java.lang.Float[])

var

public static double var(Integer[] values)

See Also:

• Numeric.var(java.lang.Integer[])

var

public static double var(Long[] values)

See Also:

• Numeric.var(java.lang.Long[])

var

public static double var(Short[] values)

See Also:

• Numeric.var(java.lang.Short[])

var

public static double var(short... values)

See Also:

• Numeric.var(short[])

var

public static double var(ByteVector values)

See Also:

• Numeric.var(io.deephaven.vector.ByteVector)

var

public static double var(DoubleVector values)

See Also:

• Numeric.var(io.deephaven.vector.DoubleVector)

var

public static double var(FloatVector values)

See Also:

• Numeric.var(io.deephaven.vector.FloatVector)

var

public static double var(IntVector values)

See Also:

• Numeric.var(io.deephaven.vector.IntVector)

var

public static double var(LongVector values)

See Also:

• Numeric.var(io.deephaven.vector.LongVector)

var

public static double var(ShortVector values)

See Also:

• Numeric.var(io.deephaven.vector.ShortVector)

vec

public static ByteVector vec(byte... values)

See Also:

• Basic.vec(byte[])

vec

public static CharVector vec(char... values)

See Also:

• Basic.vec(char[])

vec

public static DoubleVector vec(double... values)

See Also:

• Basic.vec(double[])

vec

public static FloatVector vec(float... values)

See Also:

• Basic.vec(float[])

vec

public static IntVector vec(int... values)

See Also:

• Basic.vec(int[])

vec

public static LongVector vec(long... values)

See Also:

• Basic.vec(long[])

vec

public static ShortVector vec(short... values)

See Also:

• Basic.vec(short[])

vecObj

public static <T> ObjectVector<T> vecObj(T... values)

See Also:

• Basic.vecObj(java.lang.Object[])

wavg

public static double wavg(byte[] values,
 byte[] weights)

See Also:

• Numeric.wavg(byte[],byte[])

wavg

public static double wavg(byte[] values,
 double[] weights)

See Also:

• Numeric.wavg(byte[],double[])

wavg

public static double wavg(byte[] values,
 float[] weights)

See Also:

• Numeric.wavg(byte[],float[])

wavg

public static double wavg(byte[] values,
 int[] weights)

See Also:

• Numeric.wavg(byte[],int[])

wavg

public static double wavg(byte[] values,
 long[] weights)

See Also:

• Numeric.wavg(byte[],long[])

wavg

public static double wavg(byte[] values,
 short[] weights)

See Also:

• Numeric.wavg(byte[],short[])

wavg

public static double wavg(byte[] values,
 ByteVector weights)

See Also:

• Numeric.wavg(byte[],io.deephaven.vector.ByteVector)

wavg

public static double wavg(byte[] values,
 DoubleVector weights)

See Also:

• Numeric.wavg(byte[],io.deephaven.vector.DoubleVector)

wavg

public static double wavg(byte[] values,
 FloatVector weights)

See Also:

• Numeric.wavg(byte[],io.deephaven.vector.FloatVector)

wavg

public static double wavg(byte[] values,
 IntVector weights)

See Also:

• Numeric.wavg(byte[],io.deephaven.vector.IntVector)

wavg

public static double wavg(byte[] values,
 LongVector weights)

See Also:

• Numeric.wavg(byte[],io.deephaven.vector.LongVector)

wavg

public static double wavg(byte[] values,
 ShortVector weights)

See Also:

• Numeric.wavg(byte[],io.deephaven.vector.ShortVector)

wavg

public static double wavg(double[] values,
 byte[] weights)

See Also:

• Numeric.wavg(double[],byte[])

wavg

public static double wavg(double[] values,
 double[] weights)

See Also:

• Numeric.wavg(double[],double[])

wavg

public static double wavg(double[] values,
 float[] weights)

See Also:

• Numeric.wavg(double[],float[])

wavg

public static double wavg(double[] values,
 int[] weights)

See Also:

• Numeric.wavg(double[],int[])

wavg

public static double wavg(double[] values,
 long[] weights)

See Also:

• Numeric.wavg(double[],long[])

wavg

public static double wavg(double[] values,
 short[] weights)

See Also:

• Numeric.wavg(double[],short[])

wavg

public static double wavg(double[] values,
 ByteVector weights)

See Also:

• Numeric.wavg(double[],io.deephaven.vector.ByteVector)

wavg

public static double wavg(double[] values,
 DoubleVector weights)

See Also:

• Numeric.wavg(double[],io.deephaven.vector.DoubleVector)

wavg

public static double wavg(double[] values,
 FloatVector weights)

See Also:

• Numeric.wavg(double[],io.deephaven.vector.FloatVector)

wavg

public static double wavg(double[] values,
 IntVector weights)

See Also:

• Numeric.wavg(double[],io.deephaven.vector.IntVector)

wavg

public static double wavg(double[] values,
 LongVector weights)

See Also:

• Numeric.wavg(double[],io.deephaven.vector.LongVector)

wavg

public static double wavg(double[] values,
 ShortVector weights)

See Also:

• Numeric.wavg(double[],io.deephaven.vector.ShortVector)

wavg

public static double wavg(float[] values,
 byte[] weights)

See Also:

• Numeric.wavg(float[],byte[])

wavg

public static double wavg(float[] values,
 double[] weights)

See Also:

• Numeric.wavg(float[],double[])

wavg

public static double wavg(float[] values,
 float[] weights)

See Also:

• Numeric.wavg(float[],float[])

wavg

public static double wavg(float[] values,
 int[] weights)

See Also:

• Numeric.wavg(float[],int[])

wavg

public static double wavg(float[] values,
 long[] weights)

See Also:

• Numeric.wavg(float[],long[])

wavg

public static double wavg(float[] values,
 short[] weights)

See Also:

• Numeric.wavg(float[],short[])

wavg

public static double wavg(float[] values,
 ByteVector weights)

See Also:

• Numeric.wavg(float[],io.deephaven.vector.ByteVector)

wavg

public static double wavg(float[] values,
 DoubleVector weights)

See Also:

• Numeric.wavg(float[],io.deephaven.vector.DoubleVector)

wavg

public static double wavg(float[] values,
 FloatVector weights)

See Also:

• Numeric.wavg(float[],io.deephaven.vector.FloatVector)

wavg

public static double wavg(float[] values,
 IntVector weights)

See Also:

• Numeric.wavg(float[],io.deephaven.vector.IntVector)

wavg

public static double wavg(float[] values,
 LongVector weights)

See Also:

• Numeric.wavg(float[],io.deephaven.vector.LongVector)

wavg

public static double wavg(float[] values,
 ShortVector weights)

See Also:

• Numeric.wavg(float[],io.deephaven.vector.ShortVector)

wavg

public static double wavg(int[] values,
 byte[] weights)

See Also:

• Numeric.wavg(int[],byte[])

wavg

public static double wavg(int[] values,
 double[] weights)

See Also:

• Numeric.wavg(int[],double[])

wavg

public static double wavg(int[] values,
 float[] weights)

See Also:

• Numeric.wavg(int[],float[])

wavg

public static double wavg(int[] values,
 int[] weights)

See Also:

• Numeric.wavg(int[],int[])

wavg

public static double wavg(int[] values,
 long[] weights)

See Also:

• Numeric.wavg(int[],long[])

wavg

public static double wavg(int[] values,
 short[] weights)

See Also:

• Numeric.wavg(int[],short[])

wavg

public static double wavg(int[] values,
 ByteVector weights)

See Also:

• Numeric.wavg(int[],io.deephaven.vector.ByteVector)

wavg

public static double wavg(int[] values,
 DoubleVector weights)

See Also:

• Numeric.wavg(int[],io.deephaven.vector.DoubleVector)

wavg

public static double wavg(int[] values,
 FloatVector weights)

See Also:

• Numeric.wavg(int[],io.deephaven.vector.FloatVector)

wavg

public static double wavg(int[] values,
 IntVector weights)

See Also:

• Numeric.wavg(int[],io.deephaven.vector.IntVector)

wavg

public static double wavg(int[] values,
 LongVector weights)

See Also:

• Numeric.wavg(int[],io.deephaven.vector.LongVector)

wavg

public static double wavg(int[] values,
 ShortVector weights)

See Also:

• Numeric.wavg(int[],io.deephaven.vector.ShortVector)

wavg

public static double wavg(long[] values,
 byte[] weights)

See Also:

• Numeric.wavg(long[],byte[])

wavg

public static double wavg(long[] values,
 double[] weights)

See Also:

• Numeric.wavg(long[],double[])

wavg

public static double wavg(long[] values,
 float[] weights)

See Also:

• Numeric.wavg(long[],float[])

wavg

public static double wavg(long[] values,
 int[] weights)

See Also:

• Numeric.wavg(long[],int[])

wavg

public static double wavg(long[] values,
 long[] weights)

See Also:

• Numeric.wavg(long[],long[])

wavg

public static double wavg(long[] values,
 short[] weights)

See Also:

• Numeric.wavg(long[],short[])

wavg

public static double wavg(long[] values,
 ByteVector weights)

See Also:

• Numeric.wavg(long[],io.deephaven.vector.ByteVector)

wavg

public static double wavg(long[] values,
 DoubleVector weights)

See Also:

• Numeric.wavg(long[],io.deephaven.vector.DoubleVector)

wavg

public static double wavg(long[] values,
 FloatVector weights)

See Also:

• Numeric.wavg(long[],io.deephaven.vector.FloatVector)

wavg

public static double wavg(long[] values,
 IntVector weights)

See Also:

• Numeric.wavg(long[],io.deephaven.vector.IntVector)

wavg

public static double wavg(long[] values,
 LongVector weights)

See Also:

• Numeric.wavg(long[],io.deephaven.vector.LongVector)

wavg

public static double wavg(long[] values,
 ShortVector weights)

See Also:

• Numeric.wavg(long[],io.deephaven.vector.ShortVector)

wavg

public static double wavg(short[] values,
 byte[] weights)

See Also:

• Numeric.wavg(short[],byte[])

wavg

public static double wavg(short[] values,
 double[] weights)

See Also:

• Numeric.wavg(short[],double[])

wavg

public static double wavg(short[] values,
 float[] weights)

See Also:

• Numeric.wavg(short[],float[])

wavg

public static double wavg(short[] values,
 int[] weights)

See Also:

• Numeric.wavg(short[],int[])

wavg

public static double wavg(short[] values,
 long[] weights)

See Also:

• Numeric.wavg(short[],long[])

wavg

public static double wavg(short[] values,
 short[] weights)

See Also:

• Numeric.wavg(short[],short[])

wavg

public static double wavg(short[] values,
 ByteVector weights)

See Also:

• Numeric.wavg(short[],io.deephaven.vector.ByteVector)

wavg

public static double wavg(short[] values,
 DoubleVector weights)

See Also:

• Numeric.wavg(short[],io.deephaven.vector.DoubleVector)

wavg

public static double wavg(short[] values,
 FloatVector weights)

See Also:

• Numeric.wavg(short[],io.deephaven.vector.FloatVector)

wavg

public static double wavg(short[] values,
 IntVector weights)

See Also:

• Numeric.wavg(short[],io.deephaven.vector.IntVector)

wavg

public static double wavg(short[] values,
 LongVector weights)

See Also:

• Numeric.wavg(short[],io.deephaven.vector.LongVector)

wavg

public static double wavg(short[] values,
 ShortVector weights)

See Also:

• Numeric.wavg(short[],io.deephaven.vector.ShortVector)

wavg

public static double wavg(ByteVector values,
 byte[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.ByteVector,byte[])

wavg

public static double wavg(ByteVector values,
 double[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.ByteVector,double[])

wavg

public static double wavg(ByteVector values,
 float[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.ByteVector,float[])

wavg

public static double wavg(ByteVector values,
 int[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.ByteVector,int[])

wavg

public static double wavg(ByteVector values,
 long[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.ByteVector,long[])

wavg

public static double wavg(ByteVector values,
 short[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.ByteVector,short[])

wavg

public static double wavg(ByteVector values,
 ByteVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.ByteVector,io.deephaven.vector.ByteVector)

wavg

public static double wavg(ByteVector values,
 DoubleVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.ByteVector,io.deephaven.vector.DoubleVector)

wavg

public static double wavg(ByteVector values,
 FloatVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.ByteVector,io.deephaven.vector.FloatVector)

wavg

public static double wavg(ByteVector values,
 IntVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.ByteVector,io.deephaven.vector.IntVector)

wavg

public static double wavg(ByteVector values,
 LongVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.ByteVector,io.deephaven.vector.LongVector)

wavg

public static double wavg(ByteVector values,
 ShortVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.ByteVector,io.deephaven.vector.ShortVector)

wavg

public static double wavg(DoubleVector values,
 byte[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.DoubleVector,byte[])

wavg

public static double wavg(DoubleVector values,
 double[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.DoubleVector,double[])

wavg

public static double wavg(DoubleVector values,
 float[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.DoubleVector,float[])

wavg

public static double wavg(DoubleVector values,
 int[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.DoubleVector,int[])

wavg

public static double wavg(DoubleVector values,
 long[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.DoubleVector,long[])

wavg

public static double wavg(DoubleVector values,
 short[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.DoubleVector,short[])

wavg

public static double wavg(DoubleVector values,
 ByteVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.DoubleVector,io.deephaven.vector.ByteVector)

wavg

public static double wavg(DoubleVector values,
 DoubleVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.DoubleVector,io.deephaven.vector.DoubleVector)

wavg

public static double wavg(DoubleVector values,
 FloatVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.DoubleVector,io.deephaven.vector.FloatVector)

wavg

public static double wavg(DoubleVector values,
 IntVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.DoubleVector,io.deephaven.vector.IntVector)

wavg

public static double wavg(DoubleVector values,
 LongVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.DoubleVector,io.deephaven.vector.LongVector)

wavg

public static double wavg(DoubleVector values,
 ShortVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.DoubleVector,io.deephaven.vector.ShortVector)

wavg

public static double wavg(FloatVector values,
 byte[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.FloatVector,byte[])

wavg

public static double wavg(FloatVector values,
 double[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.FloatVector,double[])

wavg

public static double wavg(FloatVector values,
 float[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.FloatVector,float[])

wavg

public static double wavg(FloatVector values,
 int[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.FloatVector,int[])

wavg

public static double wavg(FloatVector values,
 long[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.FloatVector,long[])

wavg

public static double wavg(FloatVector values,
 short[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.FloatVector,short[])

wavg

public static double wavg(FloatVector values,
 ByteVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.FloatVector,io.deephaven.vector.ByteVector)

wavg

public static double wavg(FloatVector values,
 DoubleVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.FloatVector,io.deephaven.vector.DoubleVector)

wavg

public static double wavg(FloatVector values,
 FloatVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.FloatVector,io.deephaven.vector.FloatVector)

wavg

public static double wavg(FloatVector values,
 IntVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.FloatVector,io.deephaven.vector.IntVector)

wavg

public static double wavg(FloatVector values,
 LongVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.FloatVector,io.deephaven.vector.LongVector)

wavg

public static double wavg(FloatVector values,
 ShortVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.FloatVector,io.deephaven.vector.ShortVector)

wavg

public static double wavg(IntVector values,
 byte[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.IntVector,byte[])

wavg

public static double wavg(IntVector values,
 double[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.IntVector,double[])

wavg

public static double wavg(IntVector values,
 float[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.IntVector,float[])

wavg

public static double wavg(IntVector values,
 int[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.IntVector,int[])

wavg

public static double wavg(IntVector values,
 long[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.IntVector,long[])

wavg

public static double wavg(IntVector values,
 short[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.IntVector,short[])

wavg

public static double wavg(IntVector values,
 ByteVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.IntVector,io.deephaven.vector.ByteVector)

wavg

public static double wavg(IntVector values,
 DoubleVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.IntVector,io.deephaven.vector.DoubleVector)

wavg

public static double wavg(IntVector values,
 FloatVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.IntVector,io.deephaven.vector.FloatVector)

wavg

public static double wavg(IntVector values,
 IntVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.IntVector,io.deephaven.vector.IntVector)

wavg

public static double wavg(IntVector values,
 LongVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.IntVector,io.deephaven.vector.LongVector)

wavg

public static double wavg(IntVector values,
 ShortVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.IntVector,io.deephaven.vector.ShortVector)

wavg

public static double wavg(LongVector values,
 byte[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.LongVector,byte[])

wavg

public static double wavg(LongVector values,
 double[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.LongVector,double[])

wavg

public static double wavg(LongVector values,
 float[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.LongVector,float[])

wavg

public static double wavg(LongVector values,
 int[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.LongVector,int[])

wavg

public static double wavg(LongVector values,
 long[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.LongVector,long[])

wavg

public static double wavg(LongVector values,
 short[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.LongVector,short[])

wavg

public static double wavg(LongVector values,
 ByteVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.LongVector,io.deephaven.vector.ByteVector)

wavg

public static double wavg(LongVector values,
 DoubleVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.LongVector,io.deephaven.vector.DoubleVector)

wavg

public static double wavg(LongVector values,
 FloatVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.LongVector,io.deephaven.vector.FloatVector)

wavg

public static double wavg(LongVector values,
 IntVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.LongVector,io.deephaven.vector.IntVector)

wavg

public static double wavg(LongVector values,
 LongVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.LongVector,io.deephaven.vector.LongVector)

wavg

public static double wavg(LongVector values,
 ShortVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.LongVector,io.deephaven.vector.ShortVector)

wavg

public static double wavg(ShortVector values,
 byte[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.ShortVector,byte[])

wavg

public static double wavg(ShortVector values,
 double[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.ShortVector,double[])

wavg

public static double wavg(ShortVector values,
 float[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.ShortVector,float[])

wavg

public static double wavg(ShortVector values,
 int[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.ShortVector,int[])

wavg

public static double wavg(ShortVector values,
 long[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.ShortVector,long[])

wavg

public static double wavg(ShortVector values,
 short[] weights)

See Also:

• Numeric.wavg(io.deephaven.vector.ShortVector,short[])

wavg

public static double wavg(ShortVector values,
 ByteVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.ShortVector,io.deephaven.vector.ByteVector)

wavg

public static double wavg(ShortVector values,
 DoubleVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.ShortVector,io.deephaven.vector.DoubleVector)

wavg

public static double wavg(ShortVector values,
 FloatVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.ShortVector,io.deephaven.vector.FloatVector)

wavg

public static double wavg(ShortVector values,
 IntVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.ShortVector,io.deephaven.vector.IntVector)

wavg

public static double wavg(ShortVector values,
 LongVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.ShortVector,io.deephaven.vector.LongVector)

wavg

public static double wavg(ShortVector values,
 ShortVector weights)

See Also:

• Numeric.wavg(io.deephaven.vector.ShortVector,io.deephaven.vector.ShortVector)

wstd

public static double wstd(byte[] values,
 byte[] weights)

See Also:

• Numeric.wstd(byte[],byte[])

wstd

public static double wstd(byte[] values,
 double[] weights)

See Also:

• Numeric.wstd(byte[],double[])

wstd

public static double wstd(byte[] values,
 float[] weights)

See Also:

• Numeric.wstd(byte[],float[])

wstd

public static double wstd(byte[] values,
 int[] weights)

See Also:

• Numeric.wstd(byte[],int[])

wstd

public static double wstd(byte[] values,
 long[] weights)

See Also:

• Numeric.wstd(byte[],long[])

wstd

public static double wstd(byte[] values,
 short[] weights)

See Also:

• Numeric.wstd(byte[],short[])

wstd

public static double wstd(byte[] values,
 ByteVector weights)

See Also:

• Numeric.wstd(byte[],io.deephaven.vector.ByteVector)

wstd

public static double wstd(byte[] values,
 DoubleVector weights)

See Also:

• Numeric.wstd(byte[],io.deephaven.vector.DoubleVector)

wstd

public static double wstd(byte[] values,
 FloatVector weights)

See Also:

• Numeric.wstd(byte[],io.deephaven.vector.FloatVector)

wstd

public static double wstd(byte[] values,
 IntVector weights)

See Also:

• Numeric.wstd(byte[],io.deephaven.vector.IntVector)

wstd

public static double wstd(byte[] values,
 LongVector weights)

See Also:

• Numeric.wstd(byte[],io.deephaven.vector.LongVector)

wstd

public static double wstd(byte[] values,
 ShortVector weights)

See Also:

• Numeric.wstd(byte[],io.deephaven.vector.ShortVector)

wstd

public static double wstd(double[] values,
 byte[] weights)

See Also:

• Numeric.wstd(double[],byte[])

wstd

public static double wstd(double[] values,
 double[] weights)

See Also:

• Numeric.wstd(double[],double[])

wstd

public static double wstd(double[] values,
 float[] weights)

See Also:

• Numeric.wstd(double[],float[])

wstd

public static double wstd(double[] values,
 int[] weights)

See Also:

• Numeric.wstd(double[],int[])

wstd

public static double wstd(double[] values,
 long[] weights)

See Also:

• Numeric.wstd(double[],long[])

wstd

public static double wstd(double[] values,
 short[] weights)

See Also:

• Numeric.wstd(double[],short[])

wstd

public static double wstd(double[] values,
 ByteVector weights)

See Also:

• Numeric.wstd(double[],io.deephaven.vector.ByteVector)

wstd

public static double wstd(double[] values,
 DoubleVector weights)

See Also:

• Numeric.wstd(double[],io.deephaven.vector.DoubleVector)

wstd

public static double wstd(double[] values,
 FloatVector weights)

See Also:

• Numeric.wstd(double[],io.deephaven.vector.FloatVector)

wstd

public static double wstd(double[] values,
 IntVector weights)

See Also:

• Numeric.wstd(double[],io.deephaven.vector.IntVector)

wstd

public static double wstd(double[] values,
 LongVector weights)

See Also:

• Numeric.wstd(double[],io.deephaven.vector.LongVector)

wstd

public static double wstd(double[] values,
 ShortVector weights)

See Also:

• Numeric.wstd(double[],io.deephaven.vector.ShortVector)

wstd

public static double wstd(float[] values,
 byte[] weights)

See Also:

• Numeric.wstd(float[],byte[])

wstd

public static double wstd(float[] values,
 double[] weights)

See Also:

• Numeric.wstd(float[],double[])

wstd

public static double wstd(float[] values,
 float[] weights)

See Also:

• Numeric.wstd(float[],float[])

wstd

public static double wstd(float[] values,
 int[] weights)

See Also:

• Numeric.wstd(float[],int[])

wstd

public static double wstd(float[] values,
 long[] weights)

See Also:

• Numeric.wstd(float[],long[])

wstd

public static double wstd(float[] values,
 short[] weights)

See Also:

• Numeric.wstd(float[],short[])

wstd

public static double wstd(float[] values,
 ByteVector weights)

See Also:

• Numeric.wstd(float[],io.deephaven.vector.ByteVector)

wstd

public static double wstd(float[] values,
 DoubleVector weights)

See Also:

• Numeric.wstd(float[],io.deephaven.vector.DoubleVector)

wstd

public static double wstd(float[] values,
 FloatVector weights)

See Also:

• Numeric.wstd(float[],io.deephaven.vector.FloatVector)

wstd

public static double wstd(float[] values,
 IntVector weights)

See Also:

• Numeric.wstd(float[],io.deephaven.vector.IntVector)

wstd

public static double wstd(float[] values,
 LongVector weights)

See Also:

• Numeric.wstd(float[],io.deephaven.vector.LongVector)

wstd

public static double wstd(float[] values,
 ShortVector weights)

See Also:

• Numeric.wstd(float[],io.deephaven.vector.ShortVector)

wstd

public static double wstd(int[] values,
 byte[] weights)

See Also:

• Numeric.wstd(int[],byte[])

wstd

public static double wstd(int[] values,
 double[] weights)

See Also:

• Numeric.wstd(int[],double[])

wstd

public static double wstd(int[] values,
 float[] weights)

See Also:

• Numeric.wstd(int[],float[])

wstd

public static double wstd(int[] values,
 int[] weights)

See Also:

• Numeric.wstd(int[],int[])

wstd

public static double wstd(int[] values,
 long[] weights)

See Also:

• Numeric.wstd(int[],long[])

wstd

public static double wstd(int[] values,
 short[] weights)

See Also:

• Numeric.wstd(int[],short[])

wstd

public static double wstd(int[] values,
 ByteVector weights)

See Also:

• Numeric.wstd(int[],io.deephaven.vector.ByteVector)

wstd

public static double wstd(int[] values,
 DoubleVector weights)

See Also:

• Numeric.wstd(int[],io.deephaven.vector.DoubleVector)

wstd

public static double wstd(int[] values,
 FloatVector weights)

See Also:

• Numeric.wstd(int[],io.deephaven.vector.FloatVector)

wstd

public static double wstd(int[] values,
 IntVector weights)

See Also:

• Numeric.wstd(int[],io.deephaven.vector.IntVector)

wstd

public static double wstd(int[] values,
 LongVector weights)

See Also:

• Numeric.wstd(int[],io.deephaven.vector.LongVector)

wstd

public static double wstd(int[] values,
 ShortVector weights)

See Also:

• Numeric.wstd(int[],io.deephaven.vector.ShortVector)

wstd

public static double wstd(long[] values,
 byte[] weights)

See Also:

• Numeric.wstd(long[],byte[])

wstd

public static double wstd(long[] values,
 double[] weights)

See Also:

• Numeric.wstd(long[],double[])

wstd

public static double wstd(long[] values,
 float[] weights)

See Also:

• Numeric.wstd(long[],float[])

wstd

public static double wstd(long[] values,
 int[] weights)

See Also:

• Numeric.wstd(long[],int[])

wstd

public static double wstd(long[] values,
 long[] weights)

See Also:

• Numeric.wstd(long[],long[])

wstd

public static double wstd(long[] values,
 short[] weights)

See Also:

• Numeric.wstd(long[],short[])

wstd

public static double wstd(long[] values,
 ByteVector weights)

See Also:

• Numeric.wstd(long[],io.deephaven.vector.ByteVector)

wstd

public static double wstd(long[] values,
 DoubleVector weights)

See Also:

• Numeric.wstd(long[],io.deephaven.vector.DoubleVector)

wstd

public static double wstd(long[] values,
 FloatVector weights)

See Also:

• Numeric.wstd(long[],io.deephaven.vector.FloatVector)

wstd

public static double wstd(long[] values,
 IntVector weights)

See Also:

• Numeric.wstd(long[],io.deephaven.vector.IntVector)

wstd

public static double wstd(long[] values,
 LongVector weights)

See Also:

• Numeric.wstd(long[],io.deephaven.vector.LongVector)

wstd

public static double wstd(long[] values,
 ShortVector weights)

See Also:

• Numeric.wstd(long[],io.deephaven.vector.ShortVector)

wstd

public static double wstd(short[] values,
 byte[] weights)

See Also:

• Numeric.wstd(short[],byte[])

wstd

public static double wstd(short[] values,
 double[] weights)

See Also:

• Numeric.wstd(short[],double[])

wstd

public static double wstd(short[] values,
 float[] weights)

See Also:

• Numeric.wstd(short[],float[])

wstd

public static double wstd(short[] values,
 int[] weights)

See Also:

• Numeric.wstd(short[],int[])

wstd

public static double wstd(short[] values,
 long[] weights)

See Also:

• Numeric.wstd(short[],long[])

wstd

public static double wstd(short[] values,
 short[] weights)

See Also:

• Numeric.wstd(short[],short[])

wstd

public static double wstd(short[] values,
 ByteVector weights)

See Also:

• Numeric.wstd(short[],io.deephaven.vector.ByteVector)

wstd

public static double wstd(short[] values,
 DoubleVector weights)

See Also:

• Numeric.wstd(short[],io.deephaven.vector.DoubleVector)

wstd

public static double wstd(short[] values,
 FloatVector weights)

See Also:

• Numeric.wstd(short[],io.deephaven.vector.FloatVector)

wstd

public static double wstd(short[] values,
 IntVector weights)

See Also:

• Numeric.wstd(short[],io.deephaven.vector.IntVector)

wstd

public static double wstd(short[] values,
 LongVector weights)

See Also:

• Numeric.wstd(short[],io.deephaven.vector.LongVector)

wstd

public static double wstd(short[] values,
 ShortVector weights)

See Also:

• Numeric.wstd(short[],io.deephaven.vector.ShortVector)

wstd

public static double wstd(ByteVector values,
 byte[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.ByteVector,byte[])

wstd

public static double wstd(ByteVector values,
 double[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.ByteVector,double[])

wstd

public static double wstd(ByteVector values,
 float[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.ByteVector,float[])

wstd

public static double wstd(ByteVector values,
 int[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.ByteVector,int[])

wstd

public static double wstd(ByteVector values,
 long[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.ByteVector,long[])

wstd

public static double wstd(ByteVector values,
 short[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.ByteVector,short[])

wstd

public static double wstd(ByteVector values,
 ByteVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.ByteVector,io.deephaven.vector.ByteVector)

wstd

public static double wstd(ByteVector values,
 DoubleVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.ByteVector,io.deephaven.vector.DoubleVector)

wstd

public static double wstd(ByteVector values,
 FloatVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.ByteVector,io.deephaven.vector.FloatVector)

wstd

public static double wstd(ByteVector values,
 IntVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.ByteVector,io.deephaven.vector.IntVector)

wstd

public static double wstd(ByteVector values,
 LongVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.ByteVector,io.deephaven.vector.LongVector)

wstd

public static double wstd(ByteVector values,
 ShortVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.ByteVector,io.deephaven.vector.ShortVector)

wstd

public static double wstd(DoubleVector values,
 byte[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.DoubleVector,byte[])

wstd

public static double wstd(DoubleVector values,
 double[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.DoubleVector,double[])

wstd

public static double wstd(DoubleVector values,
 float[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.DoubleVector,float[])

wstd

public static double wstd(DoubleVector values,
 int[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.DoubleVector,int[])

wstd

public static double wstd(DoubleVector values,
 long[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.DoubleVector,long[])

wstd

public static double wstd(DoubleVector values,
 short[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.DoubleVector,short[])

wstd

public static double wstd(DoubleVector values,
 ByteVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.DoubleVector,io.deephaven.vector.ByteVector)

wstd

public static double wstd(DoubleVector values,
 DoubleVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.DoubleVector,io.deephaven.vector.DoubleVector)

wstd

public static double wstd(DoubleVector values,
 FloatVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.DoubleVector,io.deephaven.vector.FloatVector)

wstd

public static double wstd(DoubleVector values,
 IntVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.DoubleVector,io.deephaven.vector.IntVector)

wstd

public static double wstd(DoubleVector values,
 LongVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.DoubleVector,io.deephaven.vector.LongVector)

wstd

public static double wstd(DoubleVector values,
 ShortVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.DoubleVector,io.deephaven.vector.ShortVector)

wstd

public static double wstd(FloatVector values,
 byte[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.FloatVector,byte[])

wstd

public static double wstd(FloatVector values,
 double[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.FloatVector,double[])

wstd

public static double wstd(FloatVector values,
 float[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.FloatVector,float[])

wstd

public static double wstd(FloatVector values,
 int[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.FloatVector,int[])

wstd

public static double wstd(FloatVector values,
 long[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.FloatVector,long[])

wstd

public static double wstd(FloatVector values,
 short[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.FloatVector,short[])

wstd

public static double wstd(FloatVector values,
 ByteVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.FloatVector,io.deephaven.vector.ByteVector)

wstd

public static double wstd(FloatVector values,
 DoubleVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.FloatVector,io.deephaven.vector.DoubleVector)

wstd

public static double wstd(FloatVector values,
 FloatVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.FloatVector,io.deephaven.vector.FloatVector)

wstd

public static double wstd(FloatVector values,
 IntVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.FloatVector,io.deephaven.vector.IntVector)

wstd

public static double wstd(FloatVector values,
 LongVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.FloatVector,io.deephaven.vector.LongVector)

wstd

public static double wstd(FloatVector values,
 ShortVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.FloatVector,io.deephaven.vector.ShortVector)

wstd

public static double wstd(IntVector values,
 byte[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.IntVector,byte[])

wstd

public static double wstd(IntVector values,
 double[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.IntVector,double[])

wstd

public static double wstd(IntVector values,
 float[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.IntVector,float[])

wstd

public static double wstd(IntVector values,
 int[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.IntVector,int[])

wstd

public static double wstd(IntVector values,
 long[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.IntVector,long[])

wstd

public static double wstd(IntVector values,
 short[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.IntVector,short[])

wstd

public static double wstd(IntVector values,
 ByteVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.IntVector,io.deephaven.vector.ByteVector)

wstd

public static double wstd(IntVector values,
 DoubleVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.IntVector,io.deephaven.vector.DoubleVector)

wstd

public static double wstd(IntVector values,
 FloatVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.IntVector,io.deephaven.vector.FloatVector)

wstd

public static double wstd(IntVector values,
 IntVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.IntVector,io.deephaven.vector.IntVector)

wstd

public static double wstd(IntVector values,
 LongVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.IntVector,io.deephaven.vector.LongVector)

wstd

public static double wstd(IntVector values,
 ShortVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.IntVector,io.deephaven.vector.ShortVector)

wstd

public static double wstd(LongVector values,
 byte[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.LongVector,byte[])

wstd

public static double wstd(LongVector values,
 double[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.LongVector,double[])

wstd

public static double wstd(LongVector values,
 float[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.LongVector,float[])

wstd

public static double wstd(LongVector values,
 int[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.LongVector,int[])

wstd

public static double wstd(LongVector values,
 long[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.LongVector,long[])

wstd

public static double wstd(LongVector values,
 short[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.LongVector,short[])

wstd

public static double wstd(LongVector values,
 ByteVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.LongVector,io.deephaven.vector.ByteVector)

wstd

public static double wstd(LongVector values,
 DoubleVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.LongVector,io.deephaven.vector.DoubleVector)

wstd

public static double wstd(LongVector values,
 FloatVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.LongVector,io.deephaven.vector.FloatVector)

wstd

public static double wstd(LongVector values,
 IntVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.LongVector,io.deephaven.vector.IntVector)

wstd

public static double wstd(LongVector values,
 LongVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.LongVector,io.deephaven.vector.LongVector)

wstd

public static double wstd(LongVector values,
 ShortVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.LongVector,io.deephaven.vector.ShortVector)

wstd

public static double wstd(ShortVector values,
 byte[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.ShortVector,byte[])

wstd

public static double wstd(ShortVector values,
 double[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.ShortVector,double[])

wstd

public static double wstd(ShortVector values,
 float[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.ShortVector,float[])

wstd

public static double wstd(ShortVector values,
 int[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.ShortVector,int[])

wstd

public static double wstd(ShortVector values,
 long[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.ShortVector,long[])

wstd

public static double wstd(ShortVector values,
 short[] weights)

See Also:

• Numeric.wstd(io.deephaven.vector.ShortVector,short[])

wstd

public static double wstd(ShortVector values,
 ByteVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.ShortVector,io.deephaven.vector.ByteVector)

wstd

public static double wstd(ShortVector values,
 DoubleVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.ShortVector,io.deephaven.vector.DoubleVector)

wstd

public static double wstd(ShortVector values,
 FloatVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.ShortVector,io.deephaven.vector.FloatVector)

wstd

public static double wstd(ShortVector values,
 IntVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.ShortVector,io.deephaven.vector.IntVector)

wstd

public static double wstd(ShortVector values,
 LongVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.ShortVector,io.deephaven.vector.LongVector)

wstd

public static double wstd(ShortVector values,
 ShortVector weights)

See Also:

• Numeric.wstd(io.deephaven.vector.ShortVector,io.deephaven.vector.ShortVector)

wste

public static double wste(byte[] values,
 byte[] weights)

See Also:

• Numeric.wste(byte[],byte[])

wste

public static double wste(byte[] values,
 double[] weights)

See Also:

• Numeric.wste(byte[],double[])

wste

public static double wste(byte[] values,
 float[] weights)

See Also:

• Numeric.wste(byte[],float[])

wste

public static double wste(byte[] values,
 int[] weights)

See Also:

• Numeric.wste(byte[],int[])

wste

public static double wste(byte[] values,
 long[] weights)

See Also:

• Numeric.wste(byte[],long[])

wste

public static double wste(byte[] values,
 short[] weights)

See Also:

• Numeric.wste(byte[],short[])

wste

public static double wste(byte[] values,
 ByteVector weights)

See Also:

• Numeric.wste(byte[],io.deephaven.vector.ByteVector)

wste

public static double wste(byte[] values,
 DoubleVector weights)

See Also:

• Numeric.wste(byte[],io.deephaven.vector.DoubleVector)

wste

public static double wste(byte[] values,
 FloatVector weights)

See Also:

• Numeric.wste(byte[],io.deephaven.vector.FloatVector)

wste

public static double wste(byte[] values,
 IntVector weights)

See Also:

• Numeric.wste(byte[],io.deephaven.vector.IntVector)

wste

public static double wste(byte[] values,
 LongVector weights)

See Also:

• Numeric.wste(byte[],io.deephaven.vector.LongVector)

wste

public static double wste(byte[] values,
 ShortVector weights)

See Also:

• Numeric.wste(byte[],io.deephaven.vector.ShortVector)

wste

public static double wste(double[] values,
 byte[] weights)

See Also:

• Numeric.wste(double[],byte[])

wste

public static double wste(double[] values,
 double[] weights)

See Also:

• Numeric.wste(double[],double[])

wste

public static double wste(double[] values,
 float[] weights)

See Also:

• Numeric.wste(double[],float[])

wste

public static double wste(double[] values,
 int[] weights)

See Also:

• Numeric.wste(double[],int[])

wste

public static double wste(double[] values,
 long[] weights)

See Also:

• Numeric.wste(double[],long[])

wste

public static double wste(double[] values,
 short[] weights)

See Also:

• Numeric.wste(double[],short[])

wste

public static double wste(double[] values,
 ByteVector weights)

See Also:

• Numeric.wste(double[],io.deephaven.vector.ByteVector)

wste

public static double wste(double[] values,
 DoubleVector weights)

See Also:

• Numeric.wste(double[],io.deephaven.vector.DoubleVector)

wste

public static double wste(double[] values,
 FloatVector weights)

See Also:

• Numeric.wste(double[],io.deephaven.vector.FloatVector)

wste

public static double wste(double[] values,
 IntVector weights)

See Also:

• Numeric.wste(double[],io.deephaven.vector.IntVector)

wste

public static double wste(double[] values,
 LongVector weights)

See Also:

• Numeric.wste(double[],io.deephaven.vector.LongVector)

wste

public static double wste(double[] values,
 ShortVector weights)

See Also:

• Numeric.wste(double[],io.deephaven.vector.ShortVector)

wste

public static double wste(float[] values,
 byte[] weights)

See Also:

• Numeric.wste(float[],byte[])

wste

public static double wste(float[] values,
 double[] weights)

See Also:

• Numeric.wste(float[],double[])

wste

public static double wste(float[] values,
 float[] weights)

See Also:

• Numeric.wste(float[],float[])

wste

public static double wste(float[] values,
 int[] weights)

See Also:

• Numeric.wste(float[],int[])

wste

public static double wste(float[] values,
 long[] weights)

See Also:

• Numeric.wste(float[],long[])

wste

public static double wste(float[] values,
 short[] weights)

See Also:

• Numeric.wste(float[],short[])

wste

public static double wste(float[] values,
 ByteVector weights)

See Also:

• Numeric.wste(float[],io.deephaven.vector.ByteVector)

wste

public static double wste(float[] values,
 DoubleVector weights)

See Also:

• Numeric.wste(float[],io.deephaven.vector.DoubleVector)

wste

public static double wste(float[] values,
 FloatVector weights)

See Also:

• Numeric.wste(float[],io.deephaven.vector.FloatVector)

wste

public static double wste(float[] values,
 IntVector weights)

See Also:

• Numeric.wste(float[],io.deephaven.vector.IntVector)

wste

public static double wste(float[] values,
 LongVector weights)

See Also:

• Numeric.wste(float[],io.deephaven.vector.LongVector)

wste

public static double wste(float[] values,
 ShortVector weights)

See Also:

• Numeric.wste(float[],io.deephaven.vector.ShortVector)

wste

public static double wste(int[] values,
 byte[] weights)

See Also:

• Numeric.wste(int[],byte[])

wste

public static double wste(int[] values,
 double[] weights)

See Also:

• Numeric.wste(int[],double[])

wste

public static double wste(int[] values,
 float[] weights)

See Also:

• Numeric.wste(int[],float[])

wste

public static double wste(int[] values,
 int[] weights)

See Also:

• Numeric.wste(int[],int[])

wste

public static double wste(int[] values,
 long[] weights)

See Also:

• Numeric.wste(int[],long[])

wste

public static double wste(int[] values,
 short[] weights)

See Also:

• Numeric.wste(int[],short[])

wste

public static double wste(int[] values,
 ByteVector weights)

See Also:

• Numeric.wste(int[],io.deephaven.vector.ByteVector)

wste

public static double wste(int[] values,
 DoubleVector weights)

See Also:

• Numeric.wste(int[],io.deephaven.vector.DoubleVector)

wste

public static double wste(int[] values,
 FloatVector weights)

See Also:

• Numeric.wste(int[],io.deephaven.vector.FloatVector)

wste

public static double wste(int[] values,
 IntVector weights)

See Also:

• Numeric.wste(int[],io.deephaven.vector.IntVector)

wste

public static double wste(int[] values,
 LongVector weights)

See Also:

• Numeric.wste(int[],io.deephaven.vector.LongVector)

wste

public static double wste(int[] values,
 ShortVector weights)

See Also:

• Numeric.wste(int[],io.deephaven.vector.ShortVector)

wste

public static double wste(long[] values,
 byte[] weights)

See Also:

• Numeric.wste(long[],byte[])

wste

public static double wste(long[] values,
 double[] weights)

See Also:

• Numeric.wste(long[],double[])

wste

public static double wste(long[] values,
 float[] weights)

See Also:

• Numeric.wste(long[],float[])

wste

public static double wste(long[] values,
 int[] weights)

See Also:

• Numeric.wste(long[],int[])

wste

public static double wste(long[] values,
 long[] weights)

See Also:

• Numeric.wste(long[],long[])

wste

public static double wste(long[] values,
 short[] weights)

See Also:

• Numeric.wste(long[],short[])

wste

public static double wste(long[] values,
 ByteVector weights)

See Also:

• Numeric.wste(long[],io.deephaven.vector.ByteVector)

wste

public static double wste(long[] values,
 DoubleVector weights)

See Also:

• Numeric.wste(long[],io.deephaven.vector.DoubleVector)

wste

public static double wste(long[] values,
 FloatVector weights)

See Also:

• Numeric.wste(long[],io.deephaven.vector.FloatVector)

wste

public static double wste(long[] values,
 IntVector weights)

See Also:

• Numeric.wste(long[],io.deephaven.vector.IntVector)

wste

public static double wste(long[] values,
 LongVector weights)

See Also:

• Numeric.wste(long[],io.deephaven.vector.LongVector)

wste

public static double wste(long[] values,
 ShortVector weights)

See Also:

• Numeric.wste(long[],io.deephaven.vector.ShortVector)

wste

public static double wste(short[] values,
 byte[] weights)

See Also:

• Numeric.wste(short[],byte[])

wste

public static double wste(short[] values,
 double[] weights)

See Also:

• Numeric.wste(short[],double[])

wste

public static double wste(short[] values,
 float[] weights)

See Also:

• Numeric.wste(short[],float[])

wste

public static double wste(short[] values,
 int[] weights)

See Also:

• Numeric.wste(short[],int[])

wste

public static double wste(short[] values,
 long[] weights)

See Also:

• Numeric.wste(short[],long[])

wste

public static double wste(short[] values,
 short[] weights)

See Also:

• Numeric.wste(short[],short[])

wste

public static double wste(short[] values,
 ByteVector weights)

See Also:

• Numeric.wste(short[],io.deephaven.vector.ByteVector)

wste

public static double wste(short[] values,
 DoubleVector weights)

See Also:

• Numeric.wste(short[],io.deephaven.vector.DoubleVector)

wste

public static double wste(short[] values,
 FloatVector weights)

See Also:

• Numeric.wste(short[],io.deephaven.vector.FloatVector)

wste

public static double wste(short[] values,
 IntVector weights)

See Also:

• Numeric.wste(short[],io.deephaven.vector.IntVector)

wste

public static double wste(short[] values,
 LongVector weights)

See Also:

• Numeric.wste(short[],io.deephaven.vector.LongVector)

wste

public static double wste(short[] values,
 ShortVector weights)

See Also:

• Numeric.wste(short[],io.deephaven.vector.ShortVector)

wste

public static double wste(ByteVector values,
 byte[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.ByteVector,byte[])

wste

public static double wste(ByteVector values,
 double[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.ByteVector,double[])

wste

public static double wste(ByteVector values,
 float[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.ByteVector,float[])

wste

public static double wste(ByteVector values,
 int[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.ByteVector,int[])

wste

public static double wste(ByteVector values,
 long[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.ByteVector,long[])

wste

public static double wste(ByteVector values,
 short[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.ByteVector,short[])

wste

public static double wste(ByteVector values,
 ByteVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.ByteVector,io.deephaven.vector.ByteVector)

wste

public static double wste(ByteVector values,
 DoubleVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.ByteVector,io.deephaven.vector.DoubleVector)

wste

public static double wste(ByteVector values,
 FloatVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.ByteVector,io.deephaven.vector.FloatVector)

wste

public static double wste(ByteVector values,
 IntVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.ByteVector,io.deephaven.vector.IntVector)

wste

public static double wste(ByteVector values,
 LongVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.ByteVector,io.deephaven.vector.LongVector)

wste

public static double wste(ByteVector values,
 ShortVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.ByteVector,io.deephaven.vector.ShortVector)

wste

public static double wste(DoubleVector values,
 byte[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.DoubleVector,byte[])

wste

public static double wste(DoubleVector values,
 double[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.DoubleVector,double[])

wste

public static double wste(DoubleVector values,
 float[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.DoubleVector,float[])

wste

public static double wste(DoubleVector values,
 int[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.DoubleVector,int[])

wste

public static double wste(DoubleVector values,
 long[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.DoubleVector,long[])

wste

public static double wste(DoubleVector values,
 short[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.DoubleVector,short[])

wste

public static double wste(DoubleVector values,
 ByteVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.DoubleVector,io.deephaven.vector.ByteVector)

wste

public static double wste(DoubleVector values,
 DoubleVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.DoubleVector,io.deephaven.vector.DoubleVector)

wste

public static double wste(DoubleVector values,
 FloatVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.DoubleVector,io.deephaven.vector.FloatVector)

wste

public static double wste(DoubleVector values,
 IntVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.DoubleVector,io.deephaven.vector.IntVector)

wste

public static double wste(DoubleVector values,
 LongVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.DoubleVector,io.deephaven.vector.LongVector)

wste

public static double wste(DoubleVector values,
 ShortVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.DoubleVector,io.deephaven.vector.ShortVector)

wste

public static double wste(FloatVector values,
 byte[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.FloatVector,byte[])

wste

public static double wste(FloatVector values,
 double[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.FloatVector,double[])

wste

public static double wste(FloatVector values,
 float[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.FloatVector,float[])

wste

public static double wste(FloatVector values,
 int[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.FloatVector,int[])

wste

public static double wste(FloatVector values,
 long[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.FloatVector,long[])

wste

public static double wste(FloatVector values,
 short[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.FloatVector,short[])

wste

public static double wste(FloatVector values,
 ByteVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.FloatVector,io.deephaven.vector.ByteVector)

wste

public static double wste(FloatVector values,
 DoubleVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.FloatVector,io.deephaven.vector.DoubleVector)

wste

public static double wste(FloatVector values,
 FloatVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.FloatVector,io.deephaven.vector.FloatVector)

wste

public static double wste(FloatVector values,
 IntVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.FloatVector,io.deephaven.vector.IntVector)

wste

public static double wste(FloatVector values,
 LongVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.FloatVector,io.deephaven.vector.LongVector)

wste

public static double wste(FloatVector values,
 ShortVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.FloatVector,io.deephaven.vector.ShortVector)

wste

public static double wste(IntVector values,
 byte[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.IntVector,byte[])

wste

public static double wste(IntVector values,
 double[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.IntVector,double[])

wste

public static double wste(IntVector values,
 float[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.IntVector,float[])

wste

public static double wste(IntVector values,
 int[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.IntVector,int[])

wste

public static double wste(IntVector values,
 long[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.IntVector,long[])

wste

public static double wste(IntVector values,
 short[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.IntVector,short[])

wste

public static double wste(IntVector values,
 ByteVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.IntVector,io.deephaven.vector.ByteVector)

wste

public static double wste(IntVector values,
 DoubleVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.IntVector,io.deephaven.vector.DoubleVector)

wste

public static double wste(IntVector values,
 FloatVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.IntVector,io.deephaven.vector.FloatVector)

wste

public static double wste(IntVector values,
 IntVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.IntVector,io.deephaven.vector.IntVector)

wste

public static double wste(IntVector values,
 LongVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.IntVector,io.deephaven.vector.LongVector)

wste

public static double wste(IntVector values,
 ShortVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.IntVector,io.deephaven.vector.ShortVector)

wste

public static double wste(LongVector values,
 byte[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.LongVector,byte[])

wste

public static double wste(LongVector values,
 double[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.LongVector,double[])

wste

public static double wste(LongVector values,
 float[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.LongVector,float[])

wste

public static double wste(LongVector values,
 int[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.LongVector,int[])

wste

public static double wste(LongVector values,
 long[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.LongVector,long[])

wste

public static double wste(LongVector values,
 short[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.LongVector,short[])

wste

public static double wste(LongVector values,
 ByteVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.LongVector,io.deephaven.vector.ByteVector)

wste

public static double wste(LongVector values,
 DoubleVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.LongVector,io.deephaven.vector.DoubleVector)

wste

public static double wste(LongVector values,
 FloatVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.LongVector,io.deephaven.vector.FloatVector)

wste

public static double wste(LongVector values,
 IntVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.LongVector,io.deephaven.vector.IntVector)

wste

public static double wste(LongVector values,
 LongVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.LongVector,io.deephaven.vector.LongVector)

wste

public static double wste(LongVector values,
 ShortVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.LongVector,io.deephaven.vector.ShortVector)

wste

public static double wste(ShortVector values,
 byte[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.ShortVector,byte[])

wste

public static double wste(ShortVector values,
 double[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.ShortVector,double[])

wste

public static double wste(ShortVector values,
 float[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.ShortVector,float[])

wste

public static double wste(ShortVector values,
 int[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.ShortVector,int[])

wste

public static double wste(ShortVector values,
 long[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.ShortVector,long[])

wste

public static double wste(ShortVector values,
 short[] weights)

See Also:

• Numeric.wste(io.deephaven.vector.ShortVector,short[])

wste

public static double wste(ShortVector values,
 ByteVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.ShortVector,io.deephaven.vector.ByteVector)

wste

public static double wste(ShortVector values,
 DoubleVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.ShortVector,io.deephaven.vector.DoubleVector)

wste

public static double wste(ShortVector values,
 FloatVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.ShortVector,io.deephaven.vector.FloatVector)

wste

public static double wste(ShortVector values,
 IntVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.ShortVector,io.deephaven.vector.IntVector)

wste

public static double wste(ShortVector values,
 LongVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.ShortVector,io.deephaven.vector.LongVector)

wste

public static double wste(ShortVector values,
 ShortVector weights)

See Also:

• Numeric.wste(io.deephaven.vector.ShortVector,io.deephaven.vector.ShortVector)

wsum

public static long wsum(byte[] values,
 byte[] weights)

See Also:

• Numeric.wsum(byte[],byte[])

wsum

public static double wsum(byte[] values,
 double[] weights)

See Also:

• Numeric.wsum(byte[],double[])

wsum

public static double wsum(byte[] values,
 float[] weights)

See Also:

• Numeric.wsum(byte[],float[])

wsum

public static long wsum(byte[] values,
 int[] weights)

See Also:

• Numeric.wsum(byte[],int[])

wsum

public static long wsum(byte[] values,
 long[] weights)

See Also:

• Numeric.wsum(byte[],long[])

wsum

public static long wsum(byte[] values,
 short[] weights)

See Also:

• Numeric.wsum(byte[],short[])

wsum

public static long wsum(byte[] values,
 ByteVector weights)

See Also:

• Numeric.wsum(byte[],io.deephaven.vector.ByteVector)

wsum

public static double wsum(byte[] values,
 DoubleVector weights)

See Also:

• Numeric.wsum(byte[],io.deephaven.vector.DoubleVector)

wsum

public static double wsum(byte[] values,
 FloatVector weights)

See Also:

• Numeric.wsum(byte[],io.deephaven.vector.FloatVector)

wsum

public static long wsum(byte[] values,
 IntVector weights)

See Also:

• Numeric.wsum(byte[],io.deephaven.vector.IntVector)

wsum

public static long wsum(byte[] values,
 LongVector weights)

See Also:

• Numeric.wsum(byte[],io.deephaven.vector.LongVector)

wsum

public static long wsum(byte[] values,
 ShortVector weights)

See Also:

• Numeric.wsum(byte[],io.deephaven.vector.ShortVector)

wsum

public static double wsum(double[] values,
 byte[] weights)

See Also:

• Numeric.wsum(double[],byte[])

wsum

public static double wsum(double[] values,
 double[] weights)

See Also:

• Numeric.wsum(double[],double[])

wsum

public static double wsum(double[] values,
 float[] weights)

See Also:

• Numeric.wsum(double[],float[])

wsum

public static double wsum(double[] values,
 int[] weights)

See Also:

• Numeric.wsum(double[],int[])

wsum

public static double wsum(double[] values,
 long[] weights)

See Also:

• Numeric.wsum(double[],long[])

wsum

public static double wsum(double[] values,
 short[] weights)

See Also:

• Numeric.wsum(double[],short[])

wsum

public static double wsum(double[] values,
 ByteVector weights)

See Also:

• Numeric.wsum(double[],io.deephaven.vector.ByteVector)

wsum

public static double wsum(double[] values,
 DoubleVector weights)

See Also:

• Numeric.wsum(double[],io.deephaven.vector.DoubleVector)

wsum

public static double wsum(double[] values,
 FloatVector weights)

See Also:

• Numeric.wsum(double[],io.deephaven.vector.FloatVector)

wsum

public static double wsum(double[] values,
 IntVector weights)

See Also:

• Numeric.wsum(double[],io.deephaven.vector.IntVector)

wsum

public static double wsum(double[] values,
 LongVector weights)

See Also:

• Numeric.wsum(double[],io.deephaven.vector.LongVector)

wsum

public static double wsum(double[] values,
 ShortVector weights)

See Also:

• Numeric.wsum(double[],io.deephaven.vector.ShortVector)

wsum

public static double wsum(float[] values,
 byte[] weights)

See Also:

• Numeric.wsum(float[],byte[])

wsum

public static double wsum(float[] values,
 double[] weights)

See Also:

• Numeric.wsum(float[],double[])

wsum

public static double wsum(float[] values,
 float[] weights)

See Also:

• Numeric.wsum(float[],float[])

wsum

public static double wsum(float[] values,
 int[] weights)

See Also:

• Numeric.wsum(float[],int[])

wsum

public static double wsum(float[] values,
 long[] weights)

See Also:

• Numeric.wsum(float[],long[])

wsum

public static double wsum(float[] values,
 short[] weights)

See Also:

• Numeric.wsum(float[],short[])

wsum

public static double wsum(float[] values,
 ByteVector weights)

See Also:

• Numeric.wsum(float[],io.deephaven.vector.ByteVector)

wsum

public static double wsum(float[] values,
 DoubleVector weights)

See Also:

• Numeric.wsum(float[],io.deephaven.vector.DoubleVector)

wsum

public static double wsum(float[] values,
 FloatVector weights)

See Also:

• Numeric.wsum(float[],io.deephaven.vector.FloatVector)

wsum

public static double wsum(float[] values,
 IntVector weights)

See Also:

• Numeric.wsum(float[],io.deephaven.vector.IntVector)

wsum

public static double wsum(float[] values,
 LongVector weights)

See Also:

• Numeric.wsum(float[],io.deephaven.vector.LongVector)

wsum

public static double wsum(float[] values,
 ShortVector weights)

See Also:

• Numeric.wsum(float[],io.deephaven.vector.ShortVector)

wsum

public static long wsum(int[] values,
 byte[] weights)

See Also:

• Numeric.wsum(int[],byte[])

wsum

public static double wsum(int[] values,
 double[] weights)

See Also:

• Numeric.wsum(int[],double[])

wsum

public static double wsum(int[] values,
 float[] weights)

See Also:

• Numeric.wsum(int[],float[])

wsum

public static long wsum(int[] values,
 int[] weights)

See Also:

• Numeric.wsum(int[],int[])

wsum

public static long wsum(int[] values,
 long[] weights)

See Also:

• Numeric.wsum(int[],long[])

wsum

public static long wsum(int[] values,
 short[] weights)

See Also:

• Numeric.wsum(int[],short[])

wsum

public static long wsum(int[] values,
 ByteVector weights)

See Also:

• Numeric.wsum(int[],io.deephaven.vector.ByteVector)

wsum

public static double wsum(int[] values,
 DoubleVector weights)

See Also:

• Numeric.wsum(int[],io.deephaven.vector.DoubleVector)

wsum

public static double wsum(int[] values,
 FloatVector weights)

See Also:

• Numeric.wsum(int[],io.deephaven.vector.FloatVector)

wsum

public static long wsum(int[] values,
 IntVector weights)

See Also:

• Numeric.wsum(int[],io.deephaven.vector.IntVector)

wsum

public static long wsum(int[] values,
 LongVector weights)

See Also:

• Numeric.wsum(int[],io.deephaven.vector.LongVector)

wsum

public static long wsum(int[] values,
 ShortVector weights)

See Also:

• Numeric.wsum(int[],io.deephaven.vector.ShortVector)

wsum

public static long wsum(long[] values,
 byte[] weights)

See Also:

• Numeric.wsum(long[],byte[])

wsum

public static double wsum(long[] values,
 double[] weights)

See Also:

• Numeric.wsum(long[],double[])

wsum

public static double wsum(long[] values,
 float[] weights)

See Also:

• Numeric.wsum(long[],float[])

wsum

public static long wsum(long[] values,
 int[] weights)

See Also:

• Numeric.wsum(long[],int[])

wsum

public static long wsum(long[] values,
 long[] weights)

See Also:

• Numeric.wsum(long[],long[])

wsum

public static long wsum(long[] values,
 short[] weights)

See Also:

• Numeric.wsum(long[],short[])

wsum

public static long wsum(long[] values,
 ByteVector weights)

See Also:

• Numeric.wsum(long[],io.deephaven.vector.ByteVector)

wsum

public static double wsum(long[] values,
 DoubleVector weights)

See Also:

• Numeric.wsum(long[],io.deephaven.vector.DoubleVector)

wsum

public static double wsum(long[] values,
 FloatVector weights)

See Also:

• Numeric.wsum(long[],io.deephaven.vector.FloatVector)

wsum

public static long wsum(long[] values,
 IntVector weights)

See Also:

• Numeric.wsum(long[],io.deephaven.vector.IntVector)

wsum

public static long wsum(long[] values,
 LongVector weights)

See Also:

• Numeric.wsum(long[],io.deephaven.vector.LongVector)

wsum

public static long wsum(long[] values,
 ShortVector weights)

See Also:

• Numeric.wsum(long[],io.deephaven.vector.ShortVector)

wsum

public static long wsum(short[] values,
 byte[] weights)

See Also:

• Numeric.wsum(short[],byte[])

wsum

public static double wsum(short[] values,
 double[] weights)

See Also:

• Numeric.wsum(short[],double[])

wsum

public static double wsum(short[] values,
 float[] weights)

See Also:

• Numeric.wsum(short[],float[])

wsum

public static long wsum(short[] values,
 int[] weights)

See Also:

• Numeric.wsum(short[],int[])

wsum

public static long wsum(short[] values,
 long[] weights)

See Also:

• Numeric.wsum(short[],long[])

wsum

public static long wsum(short[] values,
 short[] weights)

See Also:

• Numeric.wsum(short[],short[])

wsum

public static long wsum(short[] values,
 ByteVector weights)

See Also:

• Numeric.wsum(short[],io.deephaven.vector.ByteVector)

wsum

public static double wsum(short[] values,
 DoubleVector weights)

See Also:

• Numeric.wsum(short[],io.deephaven.vector.DoubleVector)

wsum

public static double wsum(short[] values,
 FloatVector weights)

See Also:

• Numeric.wsum(short[],io.deephaven.vector.FloatVector)

wsum

public static long wsum(short[] values,
 IntVector weights)

See Also:

• Numeric.wsum(short[],io.deephaven.vector.IntVector)

wsum

public static long wsum(short[] values,
 LongVector weights)

See Also:

• Numeric.wsum(short[],io.deephaven.vector.LongVector)

wsum

public static long wsum(short[] values,
 ShortVector weights)

See Also:

• Numeric.wsum(short[],io.deephaven.vector.ShortVector)

wsum

public static long wsum(ByteVector values,
 byte[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.ByteVector,byte[])

wsum

public static double wsum(ByteVector values,
 double[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.ByteVector,double[])

wsum

public static double wsum(ByteVector values,
 float[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.ByteVector,float[])

wsum

public static long wsum(ByteVector values,
 int[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.ByteVector,int[])

wsum

public static long wsum(ByteVector values,
 long[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.ByteVector,long[])

wsum

public static long wsum(ByteVector values,
 short[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.ByteVector,short[])

wsum

public static long wsum(ByteVector values,
 ByteVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.ByteVector,io.deephaven.vector.ByteVector)

wsum

public static double wsum(ByteVector values,
 DoubleVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.ByteVector,io.deephaven.vector.DoubleVector)

wsum

public static double wsum(ByteVector values,
 FloatVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.ByteVector,io.deephaven.vector.FloatVector)

wsum

public static long wsum(ByteVector values,
 IntVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.ByteVector,io.deephaven.vector.IntVector)

wsum

public static long wsum(ByteVector values,
 LongVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.ByteVector,io.deephaven.vector.LongVector)

wsum

public static long wsum(ByteVector values,
 ShortVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.ByteVector,io.deephaven.vector.ShortVector)

wsum

public static double wsum(DoubleVector values,
 byte[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.DoubleVector,byte[])

wsum

public static double wsum(DoubleVector values,
 double[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.DoubleVector,double[])

wsum

public static double wsum(DoubleVector values,
 float[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.DoubleVector,float[])

wsum

public static double wsum(DoubleVector values,
 int[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.DoubleVector,int[])

wsum

public static double wsum(DoubleVector values,
 long[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.DoubleVector,long[])

wsum

public static double wsum(DoubleVector values,
 short[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.DoubleVector,short[])

wsum

public static double wsum(DoubleVector values,
 ByteVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.DoubleVector,io.deephaven.vector.ByteVector)

wsum

public static double wsum(DoubleVector values,
 DoubleVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.DoubleVector,io.deephaven.vector.DoubleVector)

wsum

public static double wsum(DoubleVector values,
 FloatVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.DoubleVector,io.deephaven.vector.FloatVector)

wsum

public static double wsum(DoubleVector values,
 IntVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.DoubleVector,io.deephaven.vector.IntVector)

wsum

public static double wsum(DoubleVector values,
 LongVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.DoubleVector,io.deephaven.vector.LongVector)

wsum

public static double wsum(DoubleVector values,
 ShortVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.DoubleVector,io.deephaven.vector.ShortVector)

wsum

public static double wsum(FloatVector values,
 byte[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.FloatVector,byte[])

wsum

public static double wsum(FloatVector values,
 double[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.FloatVector,double[])

wsum

public static double wsum(FloatVector values,
 float[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.FloatVector,float[])

wsum

public static double wsum(FloatVector values,
 int[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.FloatVector,int[])

wsum

public static double wsum(FloatVector values,
 long[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.FloatVector,long[])

wsum

public static double wsum(FloatVector values,
 short[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.FloatVector,short[])

wsum

public static double wsum(FloatVector values,
 ByteVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.FloatVector,io.deephaven.vector.ByteVector)

wsum

public static double wsum(FloatVector values,
 DoubleVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.FloatVector,io.deephaven.vector.DoubleVector)

wsum

public static double wsum(FloatVector values,
 FloatVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.FloatVector,io.deephaven.vector.FloatVector)

wsum

public static double wsum(FloatVector values,
 IntVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.FloatVector,io.deephaven.vector.IntVector)

wsum

public static double wsum(FloatVector values,
 LongVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.FloatVector,io.deephaven.vector.LongVector)

wsum

public static double wsum(FloatVector values,
 ShortVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.FloatVector,io.deephaven.vector.ShortVector)

wsum

public static long wsum(IntVector values,
 byte[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.IntVector,byte[])

wsum

public static double wsum(IntVector values,
 double[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.IntVector,double[])

wsum

public static double wsum(IntVector values,
 float[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.IntVector,float[])

wsum

public static long wsum(IntVector values,
 int[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.IntVector,int[])

wsum

public static long wsum(IntVector values,
 long[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.IntVector,long[])

wsum

public static long wsum(IntVector values,
 short[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.IntVector,short[])

wsum

public static long wsum(IntVector values,
 ByteVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.IntVector,io.deephaven.vector.ByteVector)

wsum

public static double wsum(IntVector values,
 DoubleVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.IntVector,io.deephaven.vector.DoubleVector)

wsum

public static double wsum(IntVector values,
 FloatVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.IntVector,io.deephaven.vector.FloatVector)

wsum

public static long wsum(IntVector values,
 IntVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.IntVector,io.deephaven.vector.IntVector)

wsum

public static long wsum(IntVector values,
 LongVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.IntVector,io.deephaven.vector.LongVector)

wsum

public static long wsum(IntVector values,
 ShortVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.IntVector,io.deephaven.vector.ShortVector)

wsum

public static long wsum(LongVector values,
 byte[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.LongVector,byte[])

wsum

public static double wsum(LongVector values,
 double[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.LongVector,double[])

wsum

public static double wsum(LongVector values,
 float[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.LongVector,float[])

wsum

public static long wsum(LongVector values,
 int[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.LongVector,int[])

wsum

public static long wsum(LongVector values,
 long[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.LongVector,long[])

wsum

public static long wsum(LongVector values,
 short[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.LongVector,short[])

wsum

public static long wsum(LongVector values,
 ByteVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.LongVector,io.deephaven.vector.ByteVector)

wsum

public static double wsum(LongVector values,
 DoubleVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.LongVector,io.deephaven.vector.DoubleVector)

wsum

public static double wsum(LongVector values,
 FloatVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.LongVector,io.deephaven.vector.FloatVector)

wsum

public static long wsum(LongVector values,
 IntVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.LongVector,io.deephaven.vector.IntVector)

wsum

public static long wsum(LongVector values,
 LongVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.LongVector,io.deephaven.vector.LongVector)

wsum

public static long wsum(LongVector values,
 ShortVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.LongVector,io.deephaven.vector.ShortVector)

wsum

public static long wsum(ShortVector values,
 byte[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.ShortVector,byte[])

wsum

public static double wsum(ShortVector values,
 double[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.ShortVector,double[])

wsum

public static double wsum(ShortVector values,
 float[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.ShortVector,float[])

wsum

public static long wsum(ShortVector values,
 int[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.ShortVector,int[])

wsum

public static long wsum(ShortVector values,
 long[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.ShortVector,long[])

wsum

public static long wsum(ShortVector values,
 short[] weights)

See Also:

• Numeric.wsum(io.deephaven.vector.ShortVector,short[])

wsum

public static long wsum(ShortVector values,
 ByteVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.ShortVector,io.deephaven.vector.ByteVector)

wsum

public static double wsum(ShortVector values,
 DoubleVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.ShortVector,io.deephaven.vector.DoubleVector)

wsum

public static double wsum(ShortVector values,
 FloatVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.ShortVector,io.deephaven.vector.FloatVector)

wsum

public static long wsum(ShortVector values,
 IntVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.ShortVector,io.deephaven.vector.IntVector)

wsum

public static long wsum(ShortVector values,
 LongVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.ShortVector,io.deephaven.vector.LongVector)

wsum

public static long wsum(ShortVector values,
 ShortVector weights)

See Also:

• Numeric.wsum(io.deephaven.vector.ShortVector,io.deephaven.vector.ShortVector)

wtstat

public static double wtstat(byte[] values,
 byte[] weights)

See Also:

• Numeric.wtstat(byte[],byte[])

wtstat

public static double wtstat(byte[] values,
 double[] weights)

See Also:

• Numeric.wtstat(byte[],double[])

wtstat

public static double wtstat(byte[] values,
 float[] weights)

See Also:

• Numeric.wtstat(byte[],float[])

wtstat

public static double wtstat(byte[] values,
 int[] weights)

See Also:

• Numeric.wtstat(byte[],int[])

wtstat

public static double wtstat(byte[] values,
 long[] weights)

See Also:

• Numeric.wtstat(byte[],long[])

wtstat

public static double wtstat(byte[] values,
 short[] weights)

See Also:

• Numeric.wtstat(byte[],short[])

wtstat

public static double wtstat(byte[] values,
 ByteVector weights)

See Also:

• Numeric.wtstat(byte[],io.deephaven.vector.ByteVector)

wtstat

public static double wtstat(byte[] values,
 DoubleVector weights)

See Also:

• Numeric.wtstat(byte[],io.deephaven.vector.DoubleVector)

wtstat

public static double wtstat(byte[] values,
 FloatVector weights)

See Also:

• Numeric.wtstat(byte[],io.deephaven.vector.FloatVector)

wtstat

public static double wtstat(byte[] values,
 IntVector weights)

See Also:

• Numeric.wtstat(byte[],io.deephaven.vector.IntVector)

wtstat

public static double wtstat(byte[] values,
 LongVector weights)

See Also:

• Numeric.wtstat(byte[],io.deephaven.vector.LongVector)

wtstat

public static double wtstat(byte[] values,
 ShortVector weights)

See Also:

• Numeric.wtstat(byte[],io.deephaven.vector.ShortVector)

wtstat

public static double wtstat(double[] values,
 byte[] weights)

See Also:

• Numeric.wtstat(double[],byte[])

wtstat

public static double wtstat(double[] values,
 double[] weights)

See Also:

• Numeric.wtstat(double[],double[])

wtstat

public static double wtstat(double[] values,
 float[] weights)

See Also:

• Numeric.wtstat(double[],float[])

wtstat

public static double wtstat(double[] values,
 int[] weights)

See Also:

• Numeric.wtstat(double[],int[])

wtstat

public static double wtstat(double[] values,
 long[] weights)

See Also:

• Numeric.wtstat(double[],long[])

wtstat

public static double wtstat(double[] values,
 short[] weights)

See Also:

• Numeric.wtstat(double[],short[])

wtstat

public static double wtstat(double[] values,
 ByteVector weights)

See Also:

• Numeric.wtstat(double[],io.deephaven.vector.ByteVector)

wtstat

public static double wtstat(double[] values,
 DoubleVector weights)

See Also:

• Numeric.wtstat(double[],io.deephaven.vector.DoubleVector)

wtstat

public static double wtstat(double[] values,
 FloatVector weights)

See Also:

• Numeric.wtstat(double[],io.deephaven.vector.FloatVector)

wtstat

public static double wtstat(double[] values,
 IntVector weights)

See Also:

• Numeric.wtstat(double[],io.deephaven.vector.IntVector)

wtstat

public static double wtstat(double[] values,
 LongVector weights)

See Also:

• Numeric.wtstat(double[],io.deephaven.vector.LongVector)

wtstat

public static double wtstat(double[] values,
 ShortVector weights)

See Also:

• Numeric.wtstat(double[],io.deephaven.vector.ShortVector)

wtstat

public static double wtstat(float[] values,
 byte[] weights)

See Also:

• Numeric.wtstat(float[],byte[])

wtstat

public static double wtstat(float[] values,
 double[] weights)

See Also:

• Numeric.wtstat(float[],double[])

wtstat

public static double wtstat(float[] values,
 float[] weights)

See Also:

• Numeric.wtstat(float[],float[])

wtstat

public static double wtstat(float[] values,
 int[] weights)

See Also:

• Numeric.wtstat(float[],int[])

wtstat

public static double wtstat(float[] values,
 long[] weights)

See Also:

• Numeric.wtstat(float[],long[])

wtstat

public static double wtstat(float[] values,
 short[] weights)

See Also:

• Numeric.wtstat(float[],short[])

wtstat

public static double wtstat(float[] values,
 ByteVector weights)

See Also:

• Numeric.wtstat(float[],io.deephaven.vector.ByteVector)

wtstat

public static double wtstat(float[] values,
 DoubleVector weights)

See Also:

• Numeric.wtstat(float[],io.deephaven.vector.DoubleVector)

wtstat

public static double wtstat(float[] values,
 FloatVector weights)

See Also:

• Numeric.wtstat(float[],io.deephaven.vector.FloatVector)

wtstat

public static double wtstat(float[] values,
 IntVector weights)

See Also:

• Numeric.wtstat(float[],io.deephaven.vector.IntVector)

wtstat

public static double wtstat(float[] values,
 LongVector weights)

See Also:

• Numeric.wtstat(float[],io.deephaven.vector.LongVector)

wtstat

public static double wtstat(float[] values,
 ShortVector weights)

See Also:

• Numeric.wtstat(float[],io.deephaven.vector.ShortVector)

wtstat

public static double wtstat(int[] values,
 byte[] weights)

See Also:

• Numeric.wtstat(int[],byte[])

wtstat

public static double wtstat(int[] values,
 double[] weights)

See Also:

• Numeric.wtstat(int[],double[])

wtstat

public static double wtstat(int[] values,
 float[] weights)

See Also:

• Numeric.wtstat(int[],float[])

wtstat

public static double wtstat(int[] values,
 int[] weights)

See Also:

• Numeric.wtstat(int[],int[])

wtstat

public static double wtstat(int[] values,
 long[] weights)

See Also:

• Numeric.wtstat(int[],long[])

wtstat

public static double wtstat(int[] values,
 short[] weights)

See Also:

• Numeric.wtstat(int[],short[])

wtstat

public static double wtstat(int[] values,
 ByteVector weights)

See Also:

• Numeric.wtstat(int[],io.deephaven.vector.ByteVector)

wtstat

public static double wtstat(int[] values,
 DoubleVector weights)

See Also:

• Numeric.wtstat(int[],io.deephaven.vector.DoubleVector)

wtstat

public static double wtstat(int[] values,
 FloatVector weights)

See Also:

• Numeric.wtstat(int[],io.deephaven.vector.FloatVector)

wtstat

public static double wtstat(int[] values,
 IntVector weights)

See Also:

• Numeric.wtstat(int[],io.deephaven.vector.IntVector)

wtstat

public static double wtstat(int[] values,
 LongVector weights)

See Also:

• Numeric.wtstat(int[],io.deephaven.vector.LongVector)

wtstat

public static double wtstat(int[] values,
 ShortVector weights)

See Also:

• Numeric.wtstat(int[],io.deephaven.vector.ShortVector)

wtstat

public static double wtstat(long[] values,
 byte[] weights)

See Also:

• Numeric.wtstat(long[],byte[])

wtstat

public static double wtstat(long[] values,
 double[] weights)

See Also:

• Numeric.wtstat(long[],double[])

wtstat

public static double wtstat(long[] values,
 float[] weights)

See Also:

• Numeric.wtstat(long[],float[])

wtstat

public static double wtstat(long[] values,
 int[] weights)

See Also:

• Numeric.wtstat(long[],int[])

wtstat

public static double wtstat(long[] values,
 long[] weights)

See Also:

• Numeric.wtstat(long[],long[])

wtstat

public static double wtstat(long[] values,
 short[] weights)

See Also:

• Numeric.wtstat(long[],short[])

wtstat

public static double wtstat(long[] values,
 ByteVector weights)

See Also:

• Numeric.wtstat(long[],io.deephaven.vector.ByteVector)

wtstat

public static double wtstat(long[] values,
 DoubleVector weights)

See Also:

• Numeric.wtstat(long[],io.deephaven.vector.DoubleVector)

wtstat

public static double wtstat(long[] values,
 FloatVector weights)

See Also:

• Numeric.wtstat(long[],io.deephaven.vector.FloatVector)

wtstat

public static double wtstat(long[] values,
 IntVector weights)

See Also:

• Numeric.wtstat(long[],io.deephaven.vector.IntVector)

wtstat

public static double wtstat(long[] values,
 LongVector weights)

See Also:

• Numeric.wtstat(long[],io.deephaven.vector.LongVector)

wtstat

public static double wtstat(long[] values,
 ShortVector weights)

See Also:

• Numeric.wtstat(long[],io.deephaven.vector.ShortVector)

wtstat

public static double wtstat(short[] values,
 byte[] weights)

See Also:

• Numeric.wtstat(short[],byte[])

wtstat

public static double wtstat(short[] values,
 double[] weights)

See Also:

• Numeric.wtstat(short[],double[])

wtstat

public static double wtstat(short[] values,
 float[] weights)

See Also:

• Numeric.wtstat(short[],float[])

wtstat

public static double wtstat(short[] values,
 int[] weights)

See Also:

• Numeric.wtstat(short[],int[])

wtstat

public static double wtstat(short[] values,
 long[] weights)

See Also:

• Numeric.wtstat(short[],long[])

wtstat

public static double wtstat(short[] values,
 short[] weights)

See Also:

• Numeric.wtstat(short[],short[])

wtstat

public static double wtstat(short[] values,
 ByteVector weights)

See Also:

• Numeric.wtstat(short[],io.deephaven.vector.ByteVector)

wtstat

public static double wtstat(short[] values,
 DoubleVector weights)

See Also:

• Numeric.wtstat(short[],io.deephaven.vector.DoubleVector)

wtstat

public static double wtstat(short[] values,
 FloatVector weights)

See Also:

• Numeric.wtstat(short[],io.deephaven.vector.FloatVector)

wtstat

public static double wtstat(short[] values,
 IntVector weights)

See Also:

• Numeric.wtstat(short[],io.deephaven.vector.IntVector)

wtstat

public static double wtstat(short[] values,
 LongVector weights)

See Also:

• Numeric.wtstat(short[],io.deephaven.vector.LongVector)

wtstat

public static double wtstat(short[] values,
 ShortVector weights)

See Also:

• Numeric.wtstat(short[],io.deephaven.vector.ShortVector)

wtstat

public static double wtstat(ByteVector values,
 byte[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.ByteVector,byte[])

wtstat

public static double wtstat(ByteVector values,
 double[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.ByteVector,double[])

wtstat

public static double wtstat(ByteVector values,
 float[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.ByteVector,float[])

wtstat

public static double wtstat(ByteVector values,
 int[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.ByteVector,int[])

wtstat

public static double wtstat(ByteVector values,
 long[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.ByteVector,long[])

wtstat

public static double wtstat(ByteVector values,
 short[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.ByteVector,short[])

wtstat

public static double wtstat(ByteVector values,
 ByteVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.ByteVector,io.deephaven.vector.ByteVector)

wtstat

public static double wtstat(ByteVector values,
 DoubleVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.ByteVector,io.deephaven.vector.DoubleVector)

wtstat

public static double wtstat(ByteVector values,
 FloatVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.ByteVector,io.deephaven.vector.FloatVector)

wtstat

public static double wtstat(ByteVector values,
 IntVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.ByteVector,io.deephaven.vector.IntVector)

wtstat

public static double wtstat(ByteVector values,
 LongVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.ByteVector,io.deephaven.vector.LongVector)

wtstat

public static double wtstat(ByteVector values,
 ShortVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.ByteVector,io.deephaven.vector.ShortVector)

wtstat

public static double wtstat(DoubleVector values,
 byte[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.DoubleVector,byte[])

wtstat

public static double wtstat(DoubleVector values,
 double[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.DoubleVector,double[])

wtstat

public static double wtstat(DoubleVector values,
 float[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.DoubleVector,float[])

wtstat

public static double wtstat(DoubleVector values,
 int[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.DoubleVector,int[])

wtstat

public static double wtstat(DoubleVector values,
 long[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.DoubleVector,long[])

wtstat

public static double wtstat(DoubleVector values,
 short[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.DoubleVector,short[])

wtstat

public static double wtstat(DoubleVector values,
 ByteVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.DoubleVector,io.deephaven.vector.ByteVector)

wtstat

public static double wtstat(DoubleVector values,
 DoubleVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.DoubleVector,io.deephaven.vector.DoubleVector)

wtstat

public static double wtstat(DoubleVector values,
 FloatVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.DoubleVector,io.deephaven.vector.FloatVector)

wtstat

public static double wtstat(DoubleVector values,
 IntVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.DoubleVector,io.deephaven.vector.IntVector)

wtstat

public static double wtstat(DoubleVector values,
 LongVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.DoubleVector,io.deephaven.vector.LongVector)

wtstat

public static double wtstat(DoubleVector values,
 ShortVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.DoubleVector,io.deephaven.vector.ShortVector)

wtstat

public static double wtstat(FloatVector values,
 byte[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.FloatVector,byte[])

wtstat

public static double wtstat(FloatVector values,
 double[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.FloatVector,double[])

wtstat

public static double wtstat(FloatVector values,
 float[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.FloatVector,float[])

wtstat

public static double wtstat(FloatVector values,
 int[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.FloatVector,int[])

wtstat

public static double wtstat(FloatVector values,
 long[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.FloatVector,long[])

wtstat

public static double wtstat(FloatVector values,
 short[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.FloatVector,short[])

wtstat

public static double wtstat(FloatVector values,
 ByteVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.FloatVector,io.deephaven.vector.ByteVector)

wtstat

public static double wtstat(FloatVector values,
 DoubleVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.FloatVector,io.deephaven.vector.DoubleVector)

wtstat

public static double wtstat(FloatVector values,
 FloatVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.FloatVector,io.deephaven.vector.FloatVector)

wtstat

public static double wtstat(FloatVector values,
 IntVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.FloatVector,io.deephaven.vector.IntVector)

wtstat

public static double wtstat(FloatVector values,
 LongVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.FloatVector,io.deephaven.vector.LongVector)

wtstat

public static double wtstat(FloatVector values,
 ShortVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.FloatVector,io.deephaven.vector.ShortVector)

wtstat

public static double wtstat(IntVector values,
 byte[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.IntVector,byte[])

wtstat

public static double wtstat(IntVector values,
 double[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.IntVector,double[])

wtstat

public static double wtstat(IntVector values,
 float[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.IntVector,float[])

wtstat

public static double wtstat(IntVector values,
 int[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.IntVector,int[])

wtstat

public static double wtstat(IntVector values,
 long[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.IntVector,long[])

wtstat

public static double wtstat(IntVector values,
 short[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.IntVector,short[])

wtstat

public static double wtstat(IntVector values,
 ByteVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.IntVector,io.deephaven.vector.ByteVector)

wtstat

public static double wtstat(IntVector values,
 DoubleVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.IntVector,io.deephaven.vector.DoubleVector)

wtstat

public static double wtstat(IntVector values,
 FloatVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.IntVector,io.deephaven.vector.FloatVector)

wtstat

public static double wtstat(IntVector values,
 IntVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.IntVector,io.deephaven.vector.IntVector)

wtstat

public static double wtstat(IntVector values,
 LongVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.IntVector,io.deephaven.vector.LongVector)

wtstat

public static double wtstat(IntVector values,
 ShortVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.IntVector,io.deephaven.vector.ShortVector)

wtstat

public static double wtstat(LongVector values,
 byte[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.LongVector,byte[])

wtstat

public static double wtstat(LongVector values,
 double[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.LongVector,double[])

wtstat

public static double wtstat(LongVector values,
 float[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.LongVector,float[])

wtstat

public static double wtstat(LongVector values,
 int[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.LongVector,int[])

wtstat

public static double wtstat(LongVector values,
 long[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.LongVector,long[])

wtstat

public static double wtstat(LongVector values,
 short[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.LongVector,short[])

wtstat

public static double wtstat(LongVector values,
 ByteVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.LongVector,io.deephaven.vector.ByteVector)

wtstat

public static double wtstat(LongVector values,
 DoubleVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.LongVector,io.deephaven.vector.DoubleVector)

wtstat

public static double wtstat(LongVector values,
 FloatVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.LongVector,io.deephaven.vector.FloatVector)

wtstat

public static double wtstat(LongVector values,
 IntVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.LongVector,io.deephaven.vector.IntVector)

wtstat

public static double wtstat(LongVector values,
 LongVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.LongVector,io.deephaven.vector.LongVector)

wtstat

public static double wtstat(LongVector values,
 ShortVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.LongVector,io.deephaven.vector.ShortVector)

wtstat

public static double wtstat(ShortVector values,
 byte[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.ShortVector,byte[])

wtstat

public static double wtstat(ShortVector values,
 double[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.ShortVector,double[])

wtstat

public static double wtstat(ShortVector values,
 float[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.ShortVector,float[])

wtstat

public static double wtstat(ShortVector values,
 int[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.ShortVector,int[])

wtstat

public static double wtstat(ShortVector values,
 long[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.ShortVector,long[])

wtstat

public static double wtstat(ShortVector values,
 short[] weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.ShortVector,short[])

wtstat

public static double wtstat(ShortVector values,
 ByteVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.ShortVector,io.deephaven.vector.ByteVector)

wtstat

public static double wtstat(ShortVector values,
 DoubleVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.ShortVector,io.deephaven.vector.DoubleVector)

wtstat

public static double wtstat(ShortVector values,
 FloatVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.ShortVector,io.deephaven.vector.FloatVector)

wtstat

public static double wtstat(ShortVector values,
 IntVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.ShortVector,io.deephaven.vector.IntVector)

wtstat

public static double wtstat(ShortVector values,
 LongVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.ShortVector,io.deephaven.vector.LongVector)

wtstat

public static double wtstat(ShortVector values,
 ShortVector weights)

See Also:

• Numeric.wtstat(io.deephaven.vector.ShortVector,io.deephaven.vector.ShortVector)

wvar

public static double wvar(byte[] values,
 byte[] weights)

See Also:

• Numeric.wvar(byte[],byte[])

wvar

public static double wvar(byte[] values,
 double[] weights)

See Also:

• Numeric.wvar(byte[],double[])

wvar

public static double wvar(byte[] values,
 float[] weights)

See Also:

• Numeric.wvar(byte[],float[])

wvar

public static double wvar(byte[] values,
 int[] weights)

See Also:

• Numeric.wvar(byte[],int[])

wvar

public static double wvar(byte[] values,
 long[] weights)

See Also:

• Numeric.wvar(byte[],long[])

wvar

public static double wvar(byte[] values,
 short[] weights)

See Also:

• Numeric.wvar(byte[],short[])

wvar

public static double wvar(byte[] values,
 ByteVector weights)

See Also:

• Numeric.wvar(byte[],io.deephaven.vector.ByteVector)

wvar

public static double wvar(byte[] values,
 DoubleVector weights)

See Also:

• Numeric.wvar(byte[],io.deephaven.vector.DoubleVector)

wvar

public static double wvar(byte[] values,
 FloatVector weights)

See Also:

• Numeric.wvar(byte[],io.deephaven.vector.FloatVector)

wvar

public static double wvar(byte[] values,
 IntVector weights)

See Also:

• Numeric.wvar(byte[],io.deephaven.vector.IntVector)

wvar

public static double wvar(byte[] values,
 LongVector weights)

See Also:

• Numeric.wvar(byte[],io.deephaven.vector.LongVector)

wvar

public static double wvar(byte[] values,
 ShortVector weights)

See Also:

• Numeric.wvar(byte[],io.deephaven.vector.ShortVector)

wvar

public static double wvar(double[] values,
 byte[] weights)

See Also:

• Numeric.wvar(double[],byte[])

wvar

public static double wvar(double[] values,
 double[] weights)

See Also:

• Numeric.wvar(double[],double[])

wvar

public static double wvar(double[] values,
 float[] weights)

See Also:

• Numeric.wvar(double[],float[])

wvar

public static double wvar(double[] values,
 int[] weights)

See Also:

• Numeric.wvar(double[],int[])

wvar

public static double wvar(double[] values,
 long[] weights)

See Also:

• Numeric.wvar(double[],long[])

wvar

public static double wvar(double[] values,
 short[] weights)

See Also:

• Numeric.wvar(double[],short[])

wvar

public static double wvar(double[] values,
 ByteVector weights)

See Also:

• Numeric.wvar(double[],io.deephaven.vector.ByteVector)

wvar

public static double wvar(double[] values,
 DoubleVector weights)

See Also:

• Numeric.wvar(double[],io.deephaven.vector.DoubleVector)

wvar

public static double wvar(double[] values,
 FloatVector weights)

See Also:

• Numeric.wvar(double[],io.deephaven.vector.FloatVector)

wvar

public static double wvar(double[] values,
 IntVector weights)

See Also:

• Numeric.wvar(double[],io.deephaven.vector.IntVector)

wvar

public static double wvar(double[] values,
 LongVector weights)

See Also:

• Numeric.wvar(double[],io.deephaven.vector.LongVector)

wvar

public static double wvar(double[] values,
 ShortVector weights)

See Also:

• Numeric.wvar(double[],io.deephaven.vector.ShortVector)

wvar

public static double wvar(float[] values,
 byte[] weights)

See Also:

• Numeric.wvar(float[],byte[])

wvar

public static double wvar(float[] values,
 double[] weights)

See Also:

• Numeric.wvar(float[],double[])

wvar

public static double wvar(float[] values,
 float[] weights)

See Also:

• Numeric.wvar(float[],float[])

wvar

public static double wvar(float[] values,
 int[] weights)

See Also:

• Numeric.wvar(float[],int[])

wvar

public static double wvar(float[] values,
 long[] weights)

See Also:

• Numeric.wvar(float[],long[])

wvar

public static double wvar(float[] values,
 short[] weights)

See Also:

• Numeric.wvar(float[],short[])

wvar

public static double wvar(float[] values,
 ByteVector weights)

See Also:

• Numeric.wvar(float[],io.deephaven.vector.ByteVector)

wvar

public static double wvar(float[] values,
 DoubleVector weights)

See Also:

• Numeric.wvar(float[],io.deephaven.vector.DoubleVector)

wvar

public static double wvar(float[] values,
 FloatVector weights)

See Also:

• Numeric.wvar(float[],io.deephaven.vector.FloatVector)

wvar

public static double wvar(float[] values,
 IntVector weights)

See Also:

• Numeric.wvar(float[],io.deephaven.vector.IntVector)

wvar

public static double wvar(float[] values,
 LongVector weights)

See Also:

• Numeric.wvar(float[],io.deephaven.vector.LongVector)

wvar

public static double wvar(float[] values,
 ShortVector weights)

See Also:

• Numeric.wvar(float[],io.deephaven.vector.ShortVector)

wvar

public static double wvar(int[] values,
 byte[] weights)

See Also:

• Numeric.wvar(int[],byte[])

wvar

public static double wvar(int[] values,
 double[] weights)

See Also:

• Numeric.wvar(int[],double[])

wvar

public static double wvar(int[] values,
 float[] weights)

See Also:

• Numeric.wvar(int[],float[])

wvar

public static double wvar(int[] values,
 int[] weights)

See Also:

• Numeric.wvar(int[],int[])

wvar

public static double wvar(int[] values,
 long[] weights)

See Also:

• Numeric.wvar(int[],long[])

wvar

public static double wvar(int[] values,
 short[] weights)

See Also:

• Numeric.wvar(int[],short[])

wvar

public static double wvar(int[] values,
 ByteVector weights)

See Also:

• Numeric.wvar(int[],io.deephaven.vector.ByteVector)

wvar

public static double wvar(int[] values,
 DoubleVector weights)

See Also:

• Numeric.wvar(int[],io.deephaven.vector.DoubleVector)

wvar

public static double wvar(int[] values,
 FloatVector weights)

See Also:

• Numeric.wvar(int[],io.deephaven.vector.FloatVector)

wvar

public static double wvar(int[] values,
 IntVector weights)

See Also:

• Numeric.wvar(int[],io.deephaven.vector.IntVector)

wvar

public static double wvar(int[] values,
 LongVector weights)

See Also:

• Numeric.wvar(int[],io.deephaven.vector.LongVector)

wvar

public static double wvar(int[] values,
 ShortVector weights)

See Also:

• Numeric.wvar(int[],io.deephaven.vector.ShortVector)

wvar

public static double wvar(long[] values,
 byte[] weights)

See Also:

• Numeric.wvar(long[],byte[])

wvar

public static double wvar(long[] values,
 double[] weights)

See Also:

• Numeric.wvar(long[],double[])

wvar

public static double wvar(long[] values,
 float[] weights)

See Also:

• Numeric.wvar(long[],float[])

wvar

public static double wvar(long[] values,
 int[] weights)

See Also:

• Numeric.wvar(long[],int[])

wvar

public static double wvar(long[] values,
 long[] weights)

See Also:

• Numeric.wvar(long[],long[])

wvar

public static double wvar(long[] values,
 short[] weights)

See Also:

• Numeric.wvar(long[],short[])

wvar

public static double wvar(long[] values,
 ByteVector weights)

See Also:

• Numeric.wvar(long[],io.deephaven.vector.ByteVector)

wvar

public static double wvar(long[] values,
 DoubleVector weights)

See Also:

• Numeric.wvar(long[],io.deephaven.vector.DoubleVector)

wvar

public static double wvar(long[] values,
 FloatVector weights)

See Also:

• Numeric.wvar(long[],io.deephaven.vector.FloatVector)

wvar

public static double wvar(long[] values,
 IntVector weights)

See Also:

• Numeric.wvar(long[],io.deephaven.vector.IntVector)

wvar

public static double wvar(long[] values,
 LongVector weights)

See Also:

• Numeric.wvar(long[],io.deephaven.vector.LongVector)

wvar

public static double wvar(long[] values,
 ShortVector weights)

See Also:

• Numeric.wvar(long[],io.deephaven.vector.ShortVector)

wvar

public static double wvar(short[] values,
 byte[] weights)

See Also:

• Numeric.wvar(short[],byte[])

wvar

public static double wvar(short[] values,
 double[] weights)

See Also:

• Numeric.wvar(short[],double[])

wvar

public static double wvar(short[] values,
 float[] weights)

See Also:

• Numeric.wvar(short[],float[])

wvar

public static double wvar(short[] values,
 int[] weights)

See Also:

• Numeric.wvar(short[],int[])

wvar

public static double wvar(short[] values,
 long[] weights)

See Also:

• Numeric.wvar(short[],long[])

wvar

public static double wvar(short[] values,
 short[] weights)

See Also:

• Numeric.wvar(short[],short[])

wvar

public static double wvar(short[] values,
 ByteVector weights)

See Also:

• Numeric.wvar(short[],io.deephaven.vector.ByteVector)

wvar

public static double wvar(short[] values,
 DoubleVector weights)

See Also:

• Numeric.wvar(short[],io.deephaven.vector.DoubleVector)

wvar

public static double wvar(short[] values,
 FloatVector weights)

See Also:

• Numeric.wvar(short[],io.deephaven.vector.FloatVector)

wvar

public static double wvar(short[] values,
 IntVector weights)

See Also:

• Numeric.wvar(short[],io.deephaven.vector.IntVector)

wvar

public static double wvar(short[] values,
 LongVector weights)

See Also:

• Numeric.wvar(short[],io.deephaven.vector.LongVector)

wvar

public static double wvar(short[] values,
 ShortVector weights)

See Also:

• Numeric.wvar(short[],io.deephaven.vector.ShortVector)

wvar

public static double wvar(ByteVector values,
 byte[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.ByteVector,byte[])

wvar

public static double wvar(ByteVector values,
 double[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.ByteVector,double[])

wvar

public static double wvar(ByteVector values,
 float[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.ByteVector,float[])

wvar

public static double wvar(ByteVector values,
 int[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.ByteVector,int[])

wvar

public static double wvar(ByteVector values,
 long[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.ByteVector,long[])

wvar

public static double wvar(ByteVector values,
 short[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.ByteVector,short[])

wvar

public static double wvar(ByteVector values,
 ByteVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.ByteVector,io.deephaven.vector.ByteVector)

wvar

public static double wvar(ByteVector values,
 DoubleVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.ByteVector,io.deephaven.vector.DoubleVector)

wvar

public static double wvar(ByteVector values,
 FloatVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.ByteVector,io.deephaven.vector.FloatVector)

wvar

public static double wvar(ByteVector values,
 IntVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.ByteVector,io.deephaven.vector.IntVector)

wvar

public static double wvar(ByteVector values,
 LongVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.ByteVector,io.deephaven.vector.LongVector)

wvar

public static double wvar(ByteVector values,
 ShortVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.ByteVector,io.deephaven.vector.ShortVector)

wvar

public static double wvar(DoubleVector values,
 byte[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.DoubleVector,byte[])

wvar

public static double wvar(DoubleVector values,
 double[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.DoubleVector,double[])

wvar

public static double wvar(DoubleVector values,
 float[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.DoubleVector,float[])

wvar

public static double wvar(DoubleVector values,
 int[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.DoubleVector,int[])

wvar

public static double wvar(DoubleVector values,
 long[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.DoubleVector,long[])

wvar

public static double wvar(DoubleVector values,
 short[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.DoubleVector,short[])

wvar

public static double wvar(DoubleVector values,
 ByteVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.DoubleVector,io.deephaven.vector.ByteVector)

wvar

public static double wvar(DoubleVector values,
 DoubleVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.DoubleVector,io.deephaven.vector.DoubleVector)

wvar

public static double wvar(DoubleVector values,
 FloatVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.DoubleVector,io.deephaven.vector.FloatVector)

wvar

public static double wvar(DoubleVector values,
 IntVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.DoubleVector,io.deephaven.vector.IntVector)

wvar

public static double wvar(DoubleVector values,
 LongVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.DoubleVector,io.deephaven.vector.LongVector)

wvar

public static double wvar(DoubleVector values,
 ShortVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.DoubleVector,io.deephaven.vector.ShortVector)

wvar

public static double wvar(FloatVector values,
 byte[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.FloatVector,byte[])

wvar

public static double wvar(FloatVector values,
 double[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.FloatVector,double[])

wvar

public static double wvar(FloatVector values,
 float[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.FloatVector,float[])

wvar

public static double wvar(FloatVector values,
 int[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.FloatVector,int[])

wvar

public static double wvar(FloatVector values,
 long[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.FloatVector,long[])

wvar

public static double wvar(FloatVector values,
 short[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.FloatVector,short[])

wvar

public static double wvar(FloatVector values,
 ByteVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.FloatVector,io.deephaven.vector.ByteVector)

wvar

public static double wvar(FloatVector values,
 DoubleVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.FloatVector,io.deephaven.vector.DoubleVector)

wvar

public static double wvar(FloatVector values,
 FloatVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.FloatVector,io.deephaven.vector.FloatVector)

wvar

public static double wvar(FloatVector values,
 IntVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.FloatVector,io.deephaven.vector.IntVector)

wvar

public static double wvar(FloatVector values,
 LongVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.FloatVector,io.deephaven.vector.LongVector)

wvar

public static double wvar(FloatVector values,
 ShortVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.FloatVector,io.deephaven.vector.ShortVector)

wvar

public static double wvar(IntVector values,
 byte[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.IntVector,byte[])

wvar

public static double wvar(IntVector values,
 double[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.IntVector,double[])

wvar

public static double wvar(IntVector values,
 float[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.IntVector,float[])

wvar

public static double wvar(IntVector values,
 int[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.IntVector,int[])

wvar

public static double wvar(IntVector values,
 long[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.IntVector,long[])

wvar

public static double wvar(IntVector values,
 short[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.IntVector,short[])

wvar

public static double wvar(IntVector values,
 ByteVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.IntVector,io.deephaven.vector.ByteVector)

wvar

public static double wvar(IntVector values,
 DoubleVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.IntVector,io.deephaven.vector.DoubleVector)

wvar

public static double wvar(IntVector values,
 FloatVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.IntVector,io.deephaven.vector.FloatVector)

wvar

public static double wvar(IntVector values,
 IntVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.IntVector,io.deephaven.vector.IntVector)

wvar

public static double wvar(IntVector values,
 LongVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.IntVector,io.deephaven.vector.LongVector)

wvar

public static double wvar(IntVector values,
 ShortVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.IntVector,io.deephaven.vector.ShortVector)

wvar

public static double wvar(LongVector values,
 byte[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.LongVector,byte[])

wvar

public static double wvar(LongVector values,
 double[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.LongVector,double[])

wvar

public static double wvar(LongVector values,
 float[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.LongVector,float[])

wvar

public static double wvar(LongVector values,
 int[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.LongVector,int[])

wvar

public static double wvar(LongVector values,
 long[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.LongVector,long[])

wvar

public static double wvar(LongVector values,
 short[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.LongVector,short[])

wvar

public static double wvar(LongVector values,
 ByteVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.LongVector,io.deephaven.vector.ByteVector)

wvar

public static double wvar(LongVector values,
 DoubleVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.LongVector,io.deephaven.vector.DoubleVector)

wvar

public static double wvar(LongVector values,
 FloatVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.LongVector,io.deephaven.vector.FloatVector)

wvar

public static double wvar(LongVector values,
 IntVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.LongVector,io.deephaven.vector.IntVector)

wvar

public static double wvar(LongVector values,
 LongVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.LongVector,io.deephaven.vector.LongVector)

wvar

public static double wvar(LongVector values,
 ShortVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.LongVector,io.deephaven.vector.ShortVector)

wvar

public static double wvar(ShortVector values,
 byte[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.ShortVector,byte[])

wvar

public static double wvar(ShortVector values,
 double[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.ShortVector,double[])

wvar

public static double wvar(ShortVector values,
 float[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.ShortVector,float[])

wvar

public static double wvar(ShortVector values,
 int[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.ShortVector,int[])

wvar

public static double wvar(ShortVector values,
 long[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.ShortVector,long[])

wvar

public static double wvar(ShortVector values,
 short[] weights)

See Also:

• Numeric.wvar(io.deephaven.vector.ShortVector,short[])

wvar

public static double wvar(ShortVector values,
 ByteVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.ShortVector,io.deephaven.vector.ByteVector)

wvar

public static double wvar(ShortVector values,
 DoubleVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.ShortVector,io.deephaven.vector.DoubleVector)

wvar

public static double wvar(ShortVector values,
 FloatVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.ShortVector,io.deephaven.vector.FloatVector)

wvar

public static double wvar(ShortVector values,
 IntVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.ShortVector,io.deephaven.vector.IntVector)

wvar

public static double wvar(ShortVector values,
 LongVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.ShortVector,io.deephaven.vector.LongVector)

wvar

public static double wvar(ShortVector values,
 ShortVector weights)

See Also:

• Numeric.wvar(io.deephaven.vector.ShortVector,io.deephaven.vector.ShortVector)