• Home
• io.deephaven
• deephaven-engine-table
• 0.32.0
• source code
• GroovyStaticImports.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

io.deephaven.libs.GroovyStaticImports Maven / Gradle / Ivy

/**
 * Copyright (c) 2016-2023 Deephaven Data Labs and Patent Pending
 */
/****************************************************************************************************************************
 ****** AUTO-GENERATED CLASS - DO NOT EDIT MANUALLY - Run GroovyStaticImportGenerator or "./gradlew :Generators:groovyStaticImportGenerator" to regenerate
 ****************************************************************************************************************************/

package io.deephaven.libs;

import io.deephaven.function.Basic;
import io.deephaven.function.BinSearch;
import io.deephaven.function.BinSearchAlgo;
import io.deephaven.function.Cast;
import io.deephaven.function.Logic;
import io.deephaven.function.Numeric;
import io.deephaven.function.Parse;
import io.deephaven.function.Random;
import io.deephaven.function.Sort;
import io.deephaven.util.datastructures.LongSizedDataStructure;
import io.deephaven.vector.ByteVector;
import io.deephaven.vector.CharVector;
import io.deephaven.vector.DoubleVector;
import io.deephaven.vector.FloatVector;
import io.deephaven.vector.IntVector;
import io.deephaven.vector.LongVector;
import io.deephaven.vector.ObjectVector;
import io.deephaven.vector.ShortVector;
import java.lang.Boolean;
import java.lang.Byte;
import java.lang.Character;
import java.lang.Class;
import java.lang.Double;
import java.lang.Float;
import java.lang.Integer;
import java.lang.Long;
import java.lang.Short;
import java.lang.String;
import java.util.Comparator;

/**
 * Functions statically imported into Groovy.
 *
 * @see io.deephaven.function
 */
public class GroovyStaticImports {
    /** @see io.deephaven.function.Numeric#abs(byte) */
    public static  byte abs( byte value ) {return Numeric.abs( value );}

    /** @see io.deephaven.function.Numeric#abs(double) */
    public static  double abs( double value ) {return Numeric.abs( value );}

    /** @see io.deephaven.function.Numeric#abs(float) */
    public static  float abs( float value ) {return Numeric.abs( value );}

    /** @see io.deephaven.function.Numeric#abs(int) */
    public static  int abs( int value ) {return Numeric.abs( value );}

    /** @see io.deephaven.function.Numeric#abs(long) */
    public static  long abs( long value ) {return Numeric.abs( value );}

    /** @see io.deephaven.function.Numeric#abs(short) */
    public static  short abs( short value ) {return Numeric.abs( value );}

    /** @see io.deephaven.function.Numeric#absAvg(byte[]) */
    public static  double absAvg( byte... values ) {return Numeric.absAvg( values );}

    /** @see io.deephaven.function.Numeric#absAvg(double[]) */
    public static  double absAvg( double... values ) {return Numeric.absAvg( values );}

    /** @see io.deephaven.function.Numeric#absAvg(float[]) */
    public static  double absAvg( float... values ) {return Numeric.absAvg( values );}

    /** @see io.deephaven.function.Numeric#absAvg(int[]) */
    public static  double absAvg( int... values ) {return Numeric.absAvg( values );}

    /** @see io.deephaven.function.Numeric#absAvg(long[]) */
    public static  double absAvg( long... values ) {return Numeric.absAvg( values );}

    /** @see io.deephaven.function.Numeric#absAvg(java.lang.Byte[]) */
    public static  double absAvg( java.lang.Byte[] values ) {return Numeric.absAvg( values );}

    /** @see io.deephaven.function.Numeric#absAvg(java.lang.Double[]) */
    public static  double absAvg( java.lang.Double[] values ) {return Numeric.absAvg( values );}

    /** @see io.deephaven.function.Numeric#absAvg(java.lang.Float[]) */
    public static  double absAvg( java.lang.Float[] values ) {return Numeric.absAvg( values );}

    /** @see io.deephaven.function.Numeric#absAvg(java.lang.Integer[]) */
    public static  double absAvg( java.lang.Integer[] values ) {return Numeric.absAvg( values );}

    /** @see io.deephaven.function.Numeric#absAvg(java.lang.Long[]) */
    public static  double absAvg( java.lang.Long[] values ) {return Numeric.absAvg( values );}

    /** @see io.deephaven.function.Numeric#absAvg(java.lang.Short[]) */
    public static  double absAvg( java.lang.Short[] values ) {return Numeric.absAvg( values );}

    /** @see io.deephaven.function.Numeric#absAvg(short[]) */
    public static  double absAvg( short... values ) {return Numeric.absAvg( values );}

    /** @see io.deephaven.function.Numeric#absAvg(io.deephaven.vector.ByteVector) */
    public static  double absAvg( io.deephaven.vector.ByteVector values ) {return Numeric.absAvg( values );}

    /** @see io.deephaven.function.Numeric#absAvg(io.deephaven.vector.DoubleVector) */
    public static  double absAvg( io.deephaven.vector.DoubleVector values ) {return Numeric.absAvg( values );}

    /** @see io.deephaven.function.Numeric#absAvg(io.deephaven.vector.FloatVector) */
    public static  double absAvg( io.deephaven.vector.FloatVector values ) {return Numeric.absAvg( values );}

    /** @see io.deephaven.function.Numeric#absAvg(io.deephaven.vector.IntVector) */
    public static  double absAvg( io.deephaven.vector.IntVector values ) {return Numeric.absAvg( values );}

    /** @see io.deephaven.function.Numeric#absAvg(io.deephaven.vector.LongVector) */
    public static  double absAvg( io.deephaven.vector.LongVector values ) {return Numeric.absAvg( values );}

    /** @see io.deephaven.function.Numeric#absAvg(io.deephaven.vector.ShortVector) */
    public static  double absAvg( io.deephaven.vector.ShortVector values ) {return Numeric.absAvg( values );}

    /** @see io.deephaven.function.Numeric#acos(byte) */
    public static  double acos( byte value ) {return Numeric.acos( value );}

    /** @see io.deephaven.function.Numeric#acos(double) */
    public static  double acos( double value ) {return Numeric.acos( value );}

    /** @see io.deephaven.function.Numeric#acos(float) */
    public static  double acos( float value ) {return Numeric.acos( value );}

    /** @see io.deephaven.function.Numeric#acos(int) */
    public static  double acos( int value ) {return Numeric.acos( value );}

    /** @see io.deephaven.function.Numeric#acos(long) */
    public static  double acos( long value ) {return Numeric.acos( value );}

    /** @see io.deephaven.function.Numeric#acos(short) */
    public static  double acos( short value ) {return Numeric.acos( value );}

    /** @see io.deephaven.function.Logic#and(java.lang.Boolean[]) */
    public static  java.lang.Boolean and( java.lang.Boolean... values ) {return Logic.and( values );}

    /** @see io.deephaven.function.Logic#and(boolean[]) */
    public static  java.lang.Boolean and( boolean... values ) {return Logic.and( values );}

    /** @see io.deephaven.function.Logic#and(io.deephaven.vector.ObjectVector) */
    public static  java.lang.Boolean and( io.deephaven.vector.ObjectVector values ) {return Logic.and( values );}

    /** @see io.deephaven.function.Logic#and(java.lang.Boolean[],java.lang.Boolean) */
    public static  java.lang.Boolean and( java.lang.Boolean[] values, java.lang.Boolean nullValue ) {return Logic.and( values, nullValue );}

    /** @see io.deephaven.function.Logic#and(io.deephaven.vector.ObjectVector,java.lang.Boolean) */
    public static  java.lang.Boolean and( io.deephaven.vector.ObjectVector values, java.lang.Boolean nullValue ) {return Logic.and( values, nullValue );}

    /** @see io.deephaven.function.Basic#array(io.deephaven.vector.ByteVector) */
    public static  byte[] array( io.deephaven.vector.ByteVector values ) {return Basic.array( values );}

    /** @see io.deephaven.function.Basic#array(io.deephaven.vector.CharVector) */
    public static  char[] array( io.deephaven.vector.CharVector values ) {return Basic.array( values );}

    /** @see io.deephaven.function.Basic#array(io.deephaven.vector.DoubleVector) */
    public static  double[] array( io.deephaven.vector.DoubleVector values ) {return Basic.array( values );}

    /** @see io.deephaven.function.Basic#array(io.deephaven.vector.FloatVector) */
    public static  float[] array( io.deephaven.vector.FloatVector values ) {return Basic.array( values );}

    /** @see io.deephaven.function.Basic#array(io.deephaven.vector.IntVector) */
    public static  int[] array( io.deephaven.vector.IntVector values ) {return Basic.array( values );}

    /** @see io.deephaven.function.Basic#array(io.deephaven.vector.LongVector) */
    public static  long[] array( io.deephaven.vector.LongVector values ) {return Basic.array( values );}

    /** @see io.deephaven.function.Basic#array(io.deephaven.vector.ShortVector) */
    public static  short[] array( io.deephaven.vector.ShortVector values ) {return Basic.array( values );}

    /** @see io.deephaven.function.Basic#arrayObj(io.deephaven.vector.ObjectVector) */
    public static  T[] arrayObj( io.deephaven.vector.ObjectVector values ) {return Basic.arrayObj( values );}

    /** @see io.deephaven.function.Numeric#asin(byte) */
    public static  double asin( byte value ) {return Numeric.asin( value );}

    /** @see io.deephaven.function.Numeric#asin(double) */
    public static  double asin( double value ) {return Numeric.asin( value );}

    /** @see io.deephaven.function.Numeric#asin(float) */
    public static  double asin( float value ) {return Numeric.asin( value );}

    /** @see io.deephaven.function.Numeric#asin(int) */
    public static  double asin( int value ) {return Numeric.asin( value );}

    /** @see io.deephaven.function.Numeric#asin(long) */
    public static  double asin( long value ) {return Numeric.asin( value );}

    /** @see io.deephaven.function.Numeric#asin(short) */
    public static  double asin( short value ) {return Numeric.asin( value );}

    /** @see io.deephaven.function.Numeric#atan(byte) */
    public static  double atan( byte value ) {return Numeric.atan( value );}

    /** @see io.deephaven.function.Numeric#atan(double) */
    public static  double atan( double value ) {return Numeric.atan( value );}

    /** @see io.deephaven.function.Numeric#atan(float) */
    public static  double atan( float value ) {return Numeric.atan( value );}

    /** @see io.deephaven.function.Numeric#atan(int) */
    public static  double atan( int value ) {return Numeric.atan( value );}

    /** @see io.deephaven.function.Numeric#atan(long) */
    public static  double atan( long value ) {return Numeric.atan( value );}

    /** @see io.deephaven.function.Numeric#atan(short) */
    public static  double atan( short value ) {return Numeric.atan( value );}

    /** @see io.deephaven.function.Numeric#avg(byte[]) */
    public static  double avg( byte... values ) {return Numeric.avg( values );}

    /** @see io.deephaven.function.Numeric#avg(double[]) */
    public static  double avg( double... values ) {return Numeric.avg( values );}

    /** @see io.deephaven.function.Numeric#avg(float[]) */
    public static  double avg( float... values ) {return Numeric.avg( values );}

    /** @see io.deephaven.function.Numeric#avg(int[]) */
    public static  double avg( int... values ) {return Numeric.avg( values );}

    /** @see io.deephaven.function.Numeric#avg(long[]) */
    public static  double avg( long... values ) {return Numeric.avg( values );}

    /** @see io.deephaven.function.Numeric#avg(java.lang.Byte[]) */
    public static  double avg( java.lang.Byte[] values ) {return Numeric.avg( values );}

    /** @see io.deephaven.function.Numeric#avg(java.lang.Double[]) */
    public static  double avg( java.lang.Double[] values ) {return Numeric.avg( values );}

    /** @see io.deephaven.function.Numeric#avg(java.lang.Float[]) */
    public static  double avg( java.lang.Float[] values ) {return Numeric.avg( values );}

    /** @see io.deephaven.function.Numeric#avg(java.lang.Integer[]) */
    public static  double avg( java.lang.Integer[] values ) {return Numeric.avg( values );}

    /** @see io.deephaven.function.Numeric#avg(java.lang.Long[]) */
    public static  double avg( java.lang.Long[] values ) {return Numeric.avg( values );}

    /** @see io.deephaven.function.Numeric#avg(java.lang.Short[]) */
    public static  double avg( java.lang.Short[] values ) {return Numeric.avg( values );}

    /** @see io.deephaven.function.Numeric#avg(short[]) */
    public static  double avg( short... values ) {return Numeric.avg( values );}

    /** @see io.deephaven.function.Numeric#avg(io.deephaven.vector.ByteVector) */
    public static  double avg( io.deephaven.vector.ByteVector values ) {return Numeric.avg( values );}

    /** @see io.deephaven.function.Numeric#avg(io.deephaven.vector.DoubleVector) */
    public static  double avg( io.deephaven.vector.DoubleVector values ) {return Numeric.avg( values );}

    /** @see io.deephaven.function.Numeric#avg(io.deephaven.vector.FloatVector) */
    public static  double avg( io.deephaven.vector.FloatVector values ) {return Numeric.avg( values );}

    /** @see io.deephaven.function.Numeric#avg(io.deephaven.vector.IntVector) */
    public static  double avg( io.deephaven.vector.IntVector values ) {return Numeric.avg( values );}

    /** @see io.deephaven.function.Numeric#avg(io.deephaven.vector.LongVector) */
    public static  double avg( io.deephaven.vector.LongVector values ) {return Numeric.avg( values );}

    /** @see io.deephaven.function.Numeric#avg(io.deephaven.vector.ShortVector) */
    public static  double avg( io.deephaven.vector.ShortVector values ) {return Numeric.avg( values );}

    /** @see io.deephaven.function.BinSearch#binSearchIndex(java.lang.Comparable[],java.lang.Comparable,io.deephaven.function.BinSearchAlgo) */
    public static > int binSearchIndex( T[] values, T key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.binSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#binSearchIndex(byte[],byte,io.deephaven.function.BinSearchAlgo) */
    public static  int binSearchIndex( byte[] values, byte key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.binSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#binSearchIndex(char[],char,io.deephaven.function.BinSearchAlgo) */
    public static  int binSearchIndex( char[] values, char key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.binSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#binSearchIndex(double[],double,io.deephaven.function.BinSearchAlgo) */
    public static  int binSearchIndex( double[] values, double key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.binSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#binSearchIndex(float[],float,io.deephaven.function.BinSearchAlgo) */
    public static  int binSearchIndex( float[] values, float key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.binSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#binSearchIndex(int[],int,io.deephaven.function.BinSearchAlgo) */
    public static  int binSearchIndex( int[] values, int key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.binSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#binSearchIndex(long[],long,io.deephaven.function.BinSearchAlgo) */
    public static  int binSearchIndex( long[] values, long key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.binSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#binSearchIndex(short[],short,io.deephaven.function.BinSearchAlgo) */
    public static  int binSearchIndex( short[] values, short key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.binSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#binSearchIndex(io.deephaven.vector.ByteVector,byte,io.deephaven.function.BinSearchAlgo) */
    public static  int binSearchIndex( io.deephaven.vector.ByteVector values, byte key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.binSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#binSearchIndex(io.deephaven.vector.CharVector,char,io.deephaven.function.BinSearchAlgo) */
    public static  int binSearchIndex( io.deephaven.vector.CharVector values, char key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.binSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#binSearchIndex(io.deephaven.vector.DoubleVector,double,io.deephaven.function.BinSearchAlgo) */
    public static  int binSearchIndex( io.deephaven.vector.DoubleVector values, double key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.binSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#binSearchIndex(io.deephaven.vector.FloatVector,float,io.deephaven.function.BinSearchAlgo) */
    public static  int binSearchIndex( io.deephaven.vector.FloatVector values, float key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.binSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#binSearchIndex(io.deephaven.vector.IntVector,int,io.deephaven.function.BinSearchAlgo) */
    public static  int binSearchIndex( io.deephaven.vector.IntVector values, int key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.binSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#binSearchIndex(io.deephaven.vector.LongVector,long,io.deephaven.function.BinSearchAlgo) */
    public static  int binSearchIndex( io.deephaven.vector.LongVector values, long key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.binSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#binSearchIndex(io.deephaven.vector.ShortVector,short,io.deephaven.function.BinSearchAlgo) */
    public static  int binSearchIndex( io.deephaven.vector.ShortVector values, short key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.binSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#binSearchIndex(io.deephaven.vector.ObjectVector,java.lang.Comparable,io.deephaven.function.BinSearchAlgo) */
    public static > int binSearchIndex( io.deephaven.vector.ObjectVector values, T key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.binSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.Cast#castDouble(byte) */
    public static  double castDouble( byte value ) {return Cast.castDouble( value );}

    /** @see io.deephaven.function.Cast#castDouble(byte[]) */
    public static  double[] castDouble( byte... values ) {return Cast.castDouble( values );}

    /** @see io.deephaven.function.Cast#castDouble(double[]) */
    public static  double[] castDouble( double... values ) {return Cast.castDouble( values );}

    /** @see io.deephaven.function.Cast#castDouble(float[]) */
    public static  double[] castDouble( float... values ) {return Cast.castDouble( values );}

    /** @see io.deephaven.function.Cast#castDouble(int[]) */
    public static  double[] castDouble( int... values ) {return Cast.castDouble( values );}

    /** @see io.deephaven.function.Cast#castDouble(long[]) */
    public static  double[] castDouble( long... values ) {return Cast.castDouble( values );}

    /** @see io.deephaven.function.Cast#castDouble(short[]) */
    public static  double[] castDouble( short... values ) {return Cast.castDouble( values );}

    /** @see io.deephaven.function.Cast#castDouble(double) */
    public static  double castDouble( double value ) {return Cast.castDouble( value );}

    /** @see io.deephaven.function.Cast#castDouble(float) */
    public static  double castDouble( float value ) {return Cast.castDouble( value );}

    /** @see io.deephaven.function.Cast#castDouble(int) */
    public static  double castDouble( int value ) {return Cast.castDouble( value );}

    /** @see io.deephaven.function.Cast#castDouble(io.deephaven.vector.ByteVector) */
    public static  double[] castDouble( io.deephaven.vector.ByteVector values ) {return Cast.castDouble( values );}

    /** @see io.deephaven.function.Cast#castDouble(io.deephaven.vector.DoubleVector) */
    public static  double[] castDouble( io.deephaven.vector.DoubleVector values ) {return Cast.castDouble( values );}

    /** @see io.deephaven.function.Cast#castDouble(io.deephaven.vector.FloatVector) */
    public static  double[] castDouble( io.deephaven.vector.FloatVector values ) {return Cast.castDouble( values );}

    /** @see io.deephaven.function.Cast#castDouble(io.deephaven.vector.IntVector) */
    public static  double[] castDouble( io.deephaven.vector.IntVector values ) {return Cast.castDouble( values );}

    /** @see io.deephaven.function.Cast#castDouble(io.deephaven.vector.LongVector) */
    public static  double[] castDouble( io.deephaven.vector.LongVector values ) {return Cast.castDouble( values );}

    /** @see io.deephaven.function.Cast#castDouble(io.deephaven.vector.ShortVector) */
    public static  double[] castDouble( io.deephaven.vector.ShortVector values ) {return Cast.castDouble( values );}

    /** @see io.deephaven.function.Cast#castDouble(long) */
    public static  double castDouble( long value ) {return Cast.castDouble( value );}

    /** @see io.deephaven.function.Cast#castDouble(short) */
    public static  double castDouble( short value ) {return Cast.castDouble( value );}

    /** @see io.deephaven.function.Cast#castDouble(byte,boolean) */
    public static  double castDouble( byte value, boolean checkFidelity ) {return Cast.castDouble( value, checkFidelity );}

    /** @see io.deephaven.function.Cast#castDouble(byte[],boolean) */
    public static  double[] castDouble( byte[] values, boolean checkFidelity ) {return Cast.castDouble( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castDouble(double[],boolean) */
    public static  double[] castDouble( double[] values, boolean checkFidelity ) {return Cast.castDouble( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castDouble(float[],boolean) */
    public static  double[] castDouble( float[] values, boolean checkFidelity ) {return Cast.castDouble( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castDouble(int[],boolean) */
    public static  double[] castDouble( int[] values, boolean checkFidelity ) {return Cast.castDouble( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castDouble(long[],boolean) */
    public static  double[] castDouble( long[] values, boolean checkFidelity ) {return Cast.castDouble( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castDouble(short[],boolean) */
    public static  double[] castDouble( short[] values, boolean checkFidelity ) {return Cast.castDouble( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castDouble(double,boolean) */
    public static  double castDouble( double value, boolean checkFidelity ) {return Cast.castDouble( value, checkFidelity );}

    /** @see io.deephaven.function.Cast#castDouble(float,boolean) */
    public static  double castDouble( float value, boolean checkFidelity ) {return Cast.castDouble( value, checkFidelity );}

    /** @see io.deephaven.function.Cast#castDouble(int,boolean) */
    public static  double castDouble( int value, boolean checkFidelity ) {return Cast.castDouble( value, checkFidelity );}

    /** @see io.deephaven.function.Cast#castDouble(io.deephaven.vector.ByteVector,boolean) */
    public static  double[] castDouble( io.deephaven.vector.ByteVector values, boolean checkFidelity ) {return Cast.castDouble( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castDouble(io.deephaven.vector.DoubleVector,boolean) */
    public static  double[] castDouble( io.deephaven.vector.DoubleVector values, boolean checkFidelity ) {return Cast.castDouble( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castDouble(io.deephaven.vector.FloatVector,boolean) */
    public static  double[] castDouble( io.deephaven.vector.FloatVector values, boolean checkFidelity ) {return Cast.castDouble( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castDouble(io.deephaven.vector.IntVector,boolean) */
    public static  double[] castDouble( io.deephaven.vector.IntVector values, boolean checkFidelity ) {return Cast.castDouble( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castDouble(io.deephaven.vector.LongVector,boolean) */
    public static  double[] castDouble( io.deephaven.vector.LongVector values, boolean checkFidelity ) {return Cast.castDouble( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castDouble(io.deephaven.vector.ShortVector,boolean) */
    public static  double[] castDouble( io.deephaven.vector.ShortVector values, boolean checkFidelity ) {return Cast.castDouble( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castDouble(long,boolean) */
    public static  double castDouble( long value, boolean checkFidelity ) {return Cast.castDouble( value, checkFidelity );}

    /** @see io.deephaven.function.Cast#castDouble(short,boolean) */
    public static  double castDouble( short value, boolean checkFidelity ) {return Cast.castDouble( value, checkFidelity );}

    /** @see io.deephaven.function.Cast#castInt(byte) */
    public static  int castInt( byte value ) {return Cast.castInt( value );}

    /** @see io.deephaven.function.Cast#castInt(byte[]) */
    public static  int[] castInt( byte... values ) {return Cast.castInt( values );}

    /** @see io.deephaven.function.Cast#castInt(int[]) */
    public static  int[] castInt( int... values ) {return Cast.castInt( values );}

    /** @see io.deephaven.function.Cast#castInt(long[]) */
    public static  int[] castInt( long... values ) {return Cast.castInt( values );}

    /** @see io.deephaven.function.Cast#castInt(short[]) */
    public static  int[] castInt( short... values ) {return Cast.castInt( values );}

    /** @see io.deephaven.function.Cast#castInt(int) */
    public static  int castInt( int value ) {return Cast.castInt( value );}

    /** @see io.deephaven.function.Cast#castInt(io.deephaven.vector.ByteVector) */
    public static  int[] castInt( io.deephaven.vector.ByteVector values ) {return Cast.castInt( values );}

    /** @see io.deephaven.function.Cast#castInt(io.deephaven.vector.IntVector) */
    public static  int[] castInt( io.deephaven.vector.IntVector values ) {return Cast.castInt( values );}

    /** @see io.deephaven.function.Cast#castInt(io.deephaven.vector.LongVector) */
    public static  int[] castInt( io.deephaven.vector.LongVector values ) {return Cast.castInt( values );}

    /** @see io.deephaven.function.Cast#castInt(io.deephaven.vector.ShortVector) */
    public static  int[] castInt( io.deephaven.vector.ShortVector values ) {return Cast.castInt( values );}

    /** @see io.deephaven.function.Cast#castInt(long) */
    public static  int castInt( long value ) {return Cast.castInt( value );}

    /** @see io.deephaven.function.Cast#castInt(short) */
    public static  int castInt( short value ) {return Cast.castInt( value );}

    /** @see io.deephaven.function.Cast#castInt(byte,boolean) */
    public static  int castInt( byte value, boolean checkFidelity ) {return Cast.castInt( value, checkFidelity );}

    /** @see io.deephaven.function.Cast#castInt(byte[],boolean) */
    public static  int[] castInt( byte[] values, boolean checkFidelity ) {return Cast.castInt( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castInt(int[],boolean) */
    public static  int[] castInt( int[] values, boolean checkFidelity ) {return Cast.castInt( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castInt(long[],boolean) */
    public static  int[] castInt( long[] values, boolean checkFidelity ) {return Cast.castInt( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castInt(short[],boolean) */
    public static  int[] castInt( short[] values, boolean checkFidelity ) {return Cast.castInt( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castInt(int,boolean) */
    public static  int castInt( int value, boolean checkFidelity ) {return Cast.castInt( value, checkFidelity );}

    /** @see io.deephaven.function.Cast#castInt(io.deephaven.vector.ByteVector,boolean) */
    public static  int[] castInt( io.deephaven.vector.ByteVector values, boolean checkFidelity ) {return Cast.castInt( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castInt(io.deephaven.vector.IntVector,boolean) */
    public static  int[] castInt( io.deephaven.vector.IntVector values, boolean checkFidelity ) {return Cast.castInt( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castInt(io.deephaven.vector.LongVector,boolean) */
    public static  int[] castInt( io.deephaven.vector.LongVector values, boolean checkFidelity ) {return Cast.castInt( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castInt(io.deephaven.vector.ShortVector,boolean) */
    public static  int[] castInt( io.deephaven.vector.ShortVector values, boolean checkFidelity ) {return Cast.castInt( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castInt(long,boolean) */
    public static  int castInt( long value, boolean checkFidelity ) {return Cast.castInt( value, checkFidelity );}

    /** @see io.deephaven.function.Cast#castInt(short,boolean) */
    public static  int castInt( short value, boolean checkFidelity ) {return Cast.castInt( value, checkFidelity );}

    /** @see io.deephaven.function.Cast#castLong(byte) */
    public static  long castLong( byte value ) {return Cast.castLong( value );}

    /** @see io.deephaven.function.Cast#castLong(byte[]) */
    public static  long[] castLong( byte... values ) {return Cast.castLong( values );}

    /** @see io.deephaven.function.Cast#castLong(int[]) */
    public static  long[] castLong( int... values ) {return Cast.castLong( values );}

    /** @see io.deephaven.function.Cast#castLong(long[]) */
    public static  long[] castLong( long... values ) {return Cast.castLong( values );}

    /** @see io.deephaven.function.Cast#castLong(short[]) */
    public static  long[] castLong( short... values ) {return Cast.castLong( values );}

    /** @see io.deephaven.function.Cast#castLong(int) */
    public static  long castLong( int value ) {return Cast.castLong( value );}

    /** @see io.deephaven.function.Cast#castLong(io.deephaven.vector.ByteVector) */
    public static  long[] castLong( io.deephaven.vector.ByteVector values ) {return Cast.castLong( values );}

    /** @see io.deephaven.function.Cast#castLong(io.deephaven.vector.IntVector) */
    public static  long[] castLong( io.deephaven.vector.IntVector values ) {return Cast.castLong( values );}

    /** @see io.deephaven.function.Cast#castLong(io.deephaven.vector.LongVector) */
    public static  long[] castLong( io.deephaven.vector.LongVector values ) {return Cast.castLong( values );}

    /** @see io.deephaven.function.Cast#castLong(io.deephaven.vector.ShortVector) */
    public static  long[] castLong( io.deephaven.vector.ShortVector values ) {return Cast.castLong( values );}

    /** @see io.deephaven.function.Cast#castLong(long) */
    public static  long castLong( long value ) {return Cast.castLong( value );}

    /** @see io.deephaven.function.Cast#castLong(short) */
    public static  long castLong( short value ) {return Cast.castLong( value );}

    /** @see io.deephaven.function.Cast#castLong(byte,boolean) */
    public static  long castLong( byte value, boolean checkFidelity ) {return Cast.castLong( value, checkFidelity );}

    /** @see io.deephaven.function.Cast#castLong(byte[],boolean) */
    public static  long[] castLong( byte[] values, boolean checkFidelity ) {return Cast.castLong( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castLong(int[],boolean) */
    public static  long[] castLong( int[] values, boolean checkFidelity ) {return Cast.castLong( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castLong(long[],boolean) */
    public static  long[] castLong( long[] values, boolean checkFidelity ) {return Cast.castLong( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castLong(short[],boolean) */
    public static  long[] castLong( short[] values, boolean checkFidelity ) {return Cast.castLong( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castLong(int,boolean) */
    public static  long castLong( int value, boolean checkFidelity ) {return Cast.castLong( value, checkFidelity );}

    /** @see io.deephaven.function.Cast#castLong(io.deephaven.vector.ByteVector,boolean) */
    public static  long[] castLong( io.deephaven.vector.ByteVector values, boolean checkFidelity ) {return Cast.castLong( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castLong(io.deephaven.vector.IntVector,boolean) */
    public static  long[] castLong( io.deephaven.vector.IntVector values, boolean checkFidelity ) {return Cast.castLong( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castLong(io.deephaven.vector.LongVector,boolean) */
    public static  long[] castLong( io.deephaven.vector.LongVector values, boolean checkFidelity ) {return Cast.castLong( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castLong(io.deephaven.vector.ShortVector,boolean) */
    public static  long[] castLong( io.deephaven.vector.ShortVector values, boolean checkFidelity ) {return Cast.castLong( values, checkFidelity );}

    /** @see io.deephaven.function.Cast#castLong(long,boolean) */
    public static  long castLong( long value, boolean checkFidelity ) {return Cast.castLong( value, checkFidelity );}

    /** @see io.deephaven.function.Cast#castLong(short,boolean) */
    public static  long castLong( short value, boolean checkFidelity ) {return Cast.castLong( value, checkFidelity );}

    /** @see io.deephaven.function.Numeric#ceil(byte) */
    public static  double ceil( byte value ) {return Numeric.ceil( value );}

    /** @see io.deephaven.function.Numeric#ceil(double) */
    public static  double ceil( double value ) {return Numeric.ceil( value );}

    /** @see io.deephaven.function.Numeric#ceil(float) */
    public static  double ceil( float value ) {return Numeric.ceil( value );}

    /** @see io.deephaven.function.Numeric#ceil(int) */
    public static  double ceil( int value ) {return Numeric.ceil( value );}

    /** @see io.deephaven.function.Numeric#ceil(long) */
    public static  double ceil( long value ) {return Numeric.ceil( value );}

    /** @see io.deephaven.function.Numeric#ceil(short) */
    public static  double ceil( short value ) {return Numeric.ceil( value );}

    /** @see io.deephaven.function.Numeric#clamp(byte,byte,byte) */
    public static  byte clamp( byte value, byte min, byte max ) {return Numeric.clamp( value, min, max );}

    /** @see io.deephaven.function.Numeric#clamp(double,double,double) */
    public static  double clamp( double value, double min, double max ) {return Numeric.clamp( value, min, max );}

    /** @see io.deephaven.function.Numeric#clamp(float,float,float) */
    public static  float clamp( float value, float min, float max ) {return Numeric.clamp( value, min, max );}

    /** @see io.deephaven.function.Numeric#clamp(int,int,int) */
    public static  int clamp( int value, int min, int max ) {return Numeric.clamp( value, min, max );}

    /** @see io.deephaven.function.Numeric#clamp(long,long,long) */
    public static  long clamp( long value, long min, long max ) {return Numeric.clamp( value, min, max );}

    /** @see io.deephaven.function.Numeric#clamp(short,short,short) */
    public static  short clamp( short value, short min, short max ) {return Numeric.clamp( value, min, max );}

    /** @see io.deephaven.function.Basic#concat(java.lang.Object[][]) */
    public static  T[] concat( T[]... values ) {return Basic.concat( values );}

    /** @see io.deephaven.function.Basic#concat(io.deephaven.vector.ByteVector[]) */
    public static  byte[] concat( io.deephaven.vector.ByteVector... values ) {return Basic.concat( values );}

    /** @see io.deephaven.function.Basic#concat(io.deephaven.vector.CharVector[]) */
    public static  char[] concat( io.deephaven.vector.CharVector... values ) {return Basic.concat( values );}

    /** @see io.deephaven.function.Basic#concat(io.deephaven.vector.DoubleVector[]) */
    public static  double[] concat( io.deephaven.vector.DoubleVector... values ) {return Basic.concat( values );}

    /** @see io.deephaven.function.Basic#concat(io.deephaven.vector.FloatVector[]) */
    public static  float[] concat( io.deephaven.vector.FloatVector... values ) {return Basic.concat( values );}

    /** @see io.deephaven.function.Basic#concat(io.deephaven.vector.IntVector[]) */
    public static  int[] concat( io.deephaven.vector.IntVector... values ) {return Basic.concat( values );}

    /** @see io.deephaven.function.Basic#concat(io.deephaven.vector.LongVector[]) */
    public static  long[] concat( io.deephaven.vector.LongVector... values ) {return Basic.concat( values );}

    /** @see io.deephaven.function.Basic#concat(io.deephaven.vector.ShortVector[]) */
    public static  short[] concat( io.deephaven.vector.ShortVector... values ) {return Basic.concat( values );}

    /** @see io.deephaven.function.Basic#concat(byte[][]) */
    public static  byte[] concat( byte[]... values ) {return Basic.concat( values );}

    /** @see io.deephaven.function.Basic#concat(char[][]) */
    public static  char[] concat( char[]... values ) {return Basic.concat( values );}

    /** @see io.deephaven.function.Basic#concat(double[][]) */
    public static  double[] concat( double[]... values ) {return Basic.concat( values );}

    /** @see io.deephaven.function.Basic#concat(float[][]) */
    public static  float[] concat( float[]... values ) {return Basic.concat( values );}

    /** @see io.deephaven.function.Basic#concat(int[][]) */
    public static  int[] concat( int[]... values ) {return Basic.concat( values );}

    /** @see io.deephaven.function.Basic#concat(long[][]) */
    public static  long[] concat( long[]... values ) {return Basic.concat( values );}

    /** @see io.deephaven.function.Basic#concat(short[][]) */
    public static  short[] concat( short[]... values ) {return Basic.concat( values );}

    /** @see io.deephaven.function.Basic#concat(io.deephaven.vector.ObjectVector[]) */
    public static  T[] concat( io.deephaven.vector.ObjectVector... values ) {return Basic.concat( values );}

    /** @see io.deephaven.function.Numeric#containsNonFinite(byte[]) */
    public static  boolean containsNonFinite( byte... values ) {return Numeric.containsNonFinite( values );}

    /** @see io.deephaven.function.Numeric#containsNonFinite(double[]) */
    public static  boolean containsNonFinite( double... values ) {return Numeric.containsNonFinite( values );}

    /** @see io.deephaven.function.Numeric#containsNonFinite(float[]) */
    public static  boolean containsNonFinite( float... values ) {return Numeric.containsNonFinite( values );}

    /** @see io.deephaven.function.Numeric#containsNonFinite(int[]) */
    public static  boolean containsNonFinite( int... values ) {return Numeric.containsNonFinite( values );}

    /** @see io.deephaven.function.Numeric#containsNonFinite(long[]) */
    public static  boolean containsNonFinite( long... values ) {return Numeric.containsNonFinite( values );}

    /** @see io.deephaven.function.Numeric#containsNonFinite(java.lang.Byte[]) */
    public static  boolean containsNonFinite( java.lang.Byte[] values ) {return Numeric.containsNonFinite( values );}

    /** @see io.deephaven.function.Numeric#containsNonFinite(java.lang.Double[]) */
    public static  boolean containsNonFinite( java.lang.Double[] values ) {return Numeric.containsNonFinite( values );}

    /** @see io.deephaven.function.Numeric#containsNonFinite(java.lang.Float[]) */
    public static  boolean containsNonFinite( java.lang.Float[] values ) {return Numeric.containsNonFinite( values );}

    /** @see io.deephaven.function.Numeric#containsNonFinite(java.lang.Integer[]) */
    public static  boolean containsNonFinite( java.lang.Integer[] values ) {return Numeric.containsNonFinite( values );}

    /** @see io.deephaven.function.Numeric#containsNonFinite(java.lang.Long[]) */
    public static  boolean containsNonFinite( java.lang.Long[] values ) {return Numeric.containsNonFinite( values );}

    /** @see io.deephaven.function.Numeric#containsNonFinite(java.lang.Short[]) */
    public static  boolean containsNonFinite( java.lang.Short[] values ) {return Numeric.containsNonFinite( values );}

    /** @see io.deephaven.function.Numeric#containsNonFinite(short[]) */
    public static  boolean containsNonFinite( short... values ) {return Numeric.containsNonFinite( values );}

    /** @see io.deephaven.function.Numeric#cor(byte[],byte[]) */
    public static  double cor( byte[] values0, byte[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(byte[],double[]) */
    public static  double cor( byte[] values0, double[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(byte[],float[]) */
    public static  double cor( byte[] values0, float[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(byte[],int[]) */
    public static  double cor( byte[] values0, int[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(byte[],long[]) */
    public static  double cor( byte[] values0, long[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(byte[],short[]) */
    public static  double cor( byte[] values0, short[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(byte[],io.deephaven.vector.ByteVector) */
    public static  double cor( byte[] values0, io.deephaven.vector.ByteVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(byte[],io.deephaven.vector.DoubleVector) */
    public static  double cor( byte[] values0, io.deephaven.vector.DoubleVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(byte[],io.deephaven.vector.FloatVector) */
    public static  double cor( byte[] values0, io.deephaven.vector.FloatVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(byte[],io.deephaven.vector.IntVector) */
    public static  double cor( byte[] values0, io.deephaven.vector.IntVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(byte[],io.deephaven.vector.LongVector) */
    public static  double cor( byte[] values0, io.deephaven.vector.LongVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(byte[],io.deephaven.vector.ShortVector) */
    public static  double cor( byte[] values0, io.deephaven.vector.ShortVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(double[],byte[]) */
    public static  double cor( double[] values0, byte[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(double[],double[]) */
    public static  double cor( double[] values0, double[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(double[],float[]) */
    public static  double cor( double[] values0, float[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(double[],int[]) */
    public static  double cor( double[] values0, int[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(double[],long[]) */
    public static  double cor( double[] values0, long[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(double[],short[]) */
    public static  double cor( double[] values0, short[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(double[],io.deephaven.vector.ByteVector) */
    public static  double cor( double[] values0, io.deephaven.vector.ByteVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(double[],io.deephaven.vector.DoubleVector) */
    public static  double cor( double[] values0, io.deephaven.vector.DoubleVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(double[],io.deephaven.vector.FloatVector) */
    public static  double cor( double[] values0, io.deephaven.vector.FloatVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(double[],io.deephaven.vector.IntVector) */
    public static  double cor( double[] values0, io.deephaven.vector.IntVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(double[],io.deephaven.vector.LongVector) */
    public static  double cor( double[] values0, io.deephaven.vector.LongVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(double[],io.deephaven.vector.ShortVector) */
    public static  double cor( double[] values0, io.deephaven.vector.ShortVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(float[],byte[]) */
    public static  double cor( float[] values0, byte[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(float[],double[]) */
    public static  double cor( float[] values0, double[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(float[],float[]) */
    public static  double cor( float[] values0, float[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(float[],int[]) */
    public static  double cor( float[] values0, int[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(float[],long[]) */
    public static  double cor( float[] values0, long[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(float[],short[]) */
    public static  double cor( float[] values0, short[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(float[],io.deephaven.vector.ByteVector) */
    public static  double cor( float[] values0, io.deephaven.vector.ByteVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(float[],io.deephaven.vector.DoubleVector) */
    public static  double cor( float[] values0, io.deephaven.vector.DoubleVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(float[],io.deephaven.vector.FloatVector) */
    public static  double cor( float[] values0, io.deephaven.vector.FloatVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(float[],io.deephaven.vector.IntVector) */
    public static  double cor( float[] values0, io.deephaven.vector.IntVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(float[],io.deephaven.vector.LongVector) */
    public static  double cor( float[] values0, io.deephaven.vector.LongVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(float[],io.deephaven.vector.ShortVector) */
    public static  double cor( float[] values0, io.deephaven.vector.ShortVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(int[],byte[]) */
    public static  double cor( int[] values0, byte[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(int[],double[]) */
    public static  double cor( int[] values0, double[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(int[],float[]) */
    public static  double cor( int[] values0, float[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(int[],int[]) */
    public static  double cor( int[] values0, int[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(int[],long[]) */
    public static  double cor( int[] values0, long[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(int[],short[]) */
    public static  double cor( int[] values0, short[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(int[],io.deephaven.vector.ByteVector) */
    public static  double cor( int[] values0, io.deephaven.vector.ByteVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(int[],io.deephaven.vector.DoubleVector) */
    public static  double cor( int[] values0, io.deephaven.vector.DoubleVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(int[],io.deephaven.vector.FloatVector) */
    public static  double cor( int[] values0, io.deephaven.vector.FloatVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(int[],io.deephaven.vector.IntVector) */
    public static  double cor( int[] values0, io.deephaven.vector.IntVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(int[],io.deephaven.vector.LongVector) */
    public static  double cor( int[] values0, io.deephaven.vector.LongVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(int[],io.deephaven.vector.ShortVector) */
    public static  double cor( int[] values0, io.deephaven.vector.ShortVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(long[],byte[]) */
    public static  double cor( long[] values0, byte[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(long[],double[]) */
    public static  double cor( long[] values0, double[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(long[],float[]) */
    public static  double cor( long[] values0, float[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(long[],int[]) */
    public static  double cor( long[] values0, int[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(long[],long[]) */
    public static  double cor( long[] values0, long[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(long[],short[]) */
    public static  double cor( long[] values0, short[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(long[],io.deephaven.vector.ByteVector) */
    public static  double cor( long[] values0, io.deephaven.vector.ByteVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(long[],io.deephaven.vector.DoubleVector) */
    public static  double cor( long[] values0, io.deephaven.vector.DoubleVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(long[],io.deephaven.vector.FloatVector) */
    public static  double cor( long[] values0, io.deephaven.vector.FloatVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(long[],io.deephaven.vector.IntVector) */
    public static  double cor( long[] values0, io.deephaven.vector.IntVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(long[],io.deephaven.vector.LongVector) */
    public static  double cor( long[] values0, io.deephaven.vector.LongVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(long[],io.deephaven.vector.ShortVector) */
    public static  double cor( long[] values0, io.deephaven.vector.ShortVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(short[],byte[]) */
    public static  double cor( short[] values0, byte[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(short[],double[]) */
    public static  double cor( short[] values0, double[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(short[],float[]) */
    public static  double cor( short[] values0, float[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(short[],int[]) */
    public static  double cor( short[] values0, int[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(short[],long[]) */
    public static  double cor( short[] values0, long[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(short[],short[]) */
    public static  double cor( short[] values0, short[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(short[],io.deephaven.vector.ByteVector) */
    public static  double cor( short[] values0, io.deephaven.vector.ByteVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(short[],io.deephaven.vector.DoubleVector) */
    public static  double cor( short[] values0, io.deephaven.vector.DoubleVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(short[],io.deephaven.vector.FloatVector) */
    public static  double cor( short[] values0, io.deephaven.vector.FloatVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(short[],io.deephaven.vector.IntVector) */
    public static  double cor( short[] values0, io.deephaven.vector.IntVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(short[],io.deephaven.vector.LongVector) */
    public static  double cor( short[] values0, io.deephaven.vector.LongVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(short[],io.deephaven.vector.ShortVector) */
    public static  double cor( short[] values0, io.deephaven.vector.ShortVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.ByteVector,byte[]) */
    public static  double cor( io.deephaven.vector.ByteVector values0, byte[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.ByteVector,double[]) */
    public static  double cor( io.deephaven.vector.ByteVector values0, double[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.ByteVector,float[]) */
    public static  double cor( io.deephaven.vector.ByteVector values0, float[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.ByteVector,int[]) */
    public static  double cor( io.deephaven.vector.ByteVector values0, int[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.ByteVector,long[]) */
    public static  double cor( io.deephaven.vector.ByteVector values0, long[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.ByteVector,short[]) */
    public static  double cor( io.deephaven.vector.ByteVector values0, short[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.ByteVector,io.deephaven.vector.ByteVector) */
    public static  double cor( io.deephaven.vector.ByteVector values0, io.deephaven.vector.ByteVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.ByteVector,io.deephaven.vector.DoubleVector) */
    public static  double cor( io.deephaven.vector.ByteVector values0, io.deephaven.vector.DoubleVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.ByteVector,io.deephaven.vector.FloatVector) */
    public static  double cor( io.deephaven.vector.ByteVector values0, io.deephaven.vector.FloatVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.ByteVector,io.deephaven.vector.IntVector) */
    public static  double cor( io.deephaven.vector.ByteVector values0, io.deephaven.vector.IntVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.ByteVector,io.deephaven.vector.LongVector) */
    public static  double cor( io.deephaven.vector.ByteVector values0, io.deephaven.vector.LongVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.ByteVector,io.deephaven.vector.ShortVector) */
    public static  double cor( io.deephaven.vector.ByteVector values0, io.deephaven.vector.ShortVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.DoubleVector,byte[]) */
    public static  double cor( io.deephaven.vector.DoubleVector values0, byte[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.DoubleVector,double[]) */
    public static  double cor( io.deephaven.vector.DoubleVector values0, double[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.DoubleVector,float[]) */
    public static  double cor( io.deephaven.vector.DoubleVector values0, float[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.DoubleVector,int[]) */
    public static  double cor( io.deephaven.vector.DoubleVector values0, int[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.DoubleVector,long[]) */
    public static  double cor( io.deephaven.vector.DoubleVector values0, long[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.DoubleVector,short[]) */
    public static  double cor( io.deephaven.vector.DoubleVector values0, short[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.DoubleVector,io.deephaven.vector.ByteVector) */
    public static  double cor( io.deephaven.vector.DoubleVector values0, io.deephaven.vector.ByteVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.DoubleVector,io.deephaven.vector.DoubleVector) */
    public static  double cor( io.deephaven.vector.DoubleVector values0, io.deephaven.vector.DoubleVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.DoubleVector,io.deephaven.vector.FloatVector) */
    public static  double cor( io.deephaven.vector.DoubleVector values0, io.deephaven.vector.FloatVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.DoubleVector,io.deephaven.vector.IntVector) */
    public static  double cor( io.deephaven.vector.DoubleVector values0, io.deephaven.vector.IntVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.DoubleVector,io.deephaven.vector.LongVector) */
    public static  double cor( io.deephaven.vector.DoubleVector values0, io.deephaven.vector.LongVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.DoubleVector,io.deephaven.vector.ShortVector) */
    public static  double cor( io.deephaven.vector.DoubleVector values0, io.deephaven.vector.ShortVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.FloatVector,byte[]) */
    public static  double cor( io.deephaven.vector.FloatVector values0, byte[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.FloatVector,double[]) */
    public static  double cor( io.deephaven.vector.FloatVector values0, double[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.FloatVector,float[]) */
    public static  double cor( io.deephaven.vector.FloatVector values0, float[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.FloatVector,int[]) */
    public static  double cor( io.deephaven.vector.FloatVector values0, int[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.FloatVector,long[]) */
    public static  double cor( io.deephaven.vector.FloatVector values0, long[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.FloatVector,short[]) */
    public static  double cor( io.deephaven.vector.FloatVector values0, short[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.FloatVector,io.deephaven.vector.ByteVector) */
    public static  double cor( io.deephaven.vector.FloatVector values0, io.deephaven.vector.ByteVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.FloatVector,io.deephaven.vector.DoubleVector) */
    public static  double cor( io.deephaven.vector.FloatVector values0, io.deephaven.vector.DoubleVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.FloatVector,io.deephaven.vector.FloatVector) */
    public static  double cor( io.deephaven.vector.FloatVector values0, io.deephaven.vector.FloatVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.FloatVector,io.deephaven.vector.IntVector) */
    public static  double cor( io.deephaven.vector.FloatVector values0, io.deephaven.vector.IntVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.FloatVector,io.deephaven.vector.LongVector) */
    public static  double cor( io.deephaven.vector.FloatVector values0, io.deephaven.vector.LongVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.FloatVector,io.deephaven.vector.ShortVector) */
    public static  double cor( io.deephaven.vector.FloatVector values0, io.deephaven.vector.ShortVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.IntVector,byte[]) */
    public static  double cor( io.deephaven.vector.IntVector values0, byte[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.IntVector,double[]) */
    public static  double cor( io.deephaven.vector.IntVector values0, double[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.IntVector,float[]) */
    public static  double cor( io.deephaven.vector.IntVector values0, float[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.IntVector,int[]) */
    public static  double cor( io.deephaven.vector.IntVector values0, int[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.IntVector,long[]) */
    public static  double cor( io.deephaven.vector.IntVector values0, long[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.IntVector,short[]) */
    public static  double cor( io.deephaven.vector.IntVector values0, short[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.IntVector,io.deephaven.vector.ByteVector) */
    public static  double cor( io.deephaven.vector.IntVector values0, io.deephaven.vector.ByteVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.IntVector,io.deephaven.vector.DoubleVector) */
    public static  double cor( io.deephaven.vector.IntVector values0, io.deephaven.vector.DoubleVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.IntVector,io.deephaven.vector.FloatVector) */
    public static  double cor( io.deephaven.vector.IntVector values0, io.deephaven.vector.FloatVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.IntVector,io.deephaven.vector.IntVector) */
    public static  double cor( io.deephaven.vector.IntVector values0, io.deephaven.vector.IntVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.IntVector,io.deephaven.vector.LongVector) */
    public static  double cor( io.deephaven.vector.IntVector values0, io.deephaven.vector.LongVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.IntVector,io.deephaven.vector.ShortVector) */
    public static  double cor( io.deephaven.vector.IntVector values0, io.deephaven.vector.ShortVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.LongVector,byte[]) */
    public static  double cor( io.deephaven.vector.LongVector values0, byte[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.LongVector,double[]) */
    public static  double cor( io.deephaven.vector.LongVector values0, double[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.LongVector,float[]) */
    public static  double cor( io.deephaven.vector.LongVector values0, float[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.LongVector,int[]) */
    public static  double cor( io.deephaven.vector.LongVector values0, int[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.LongVector,long[]) */
    public static  double cor( io.deephaven.vector.LongVector values0, long[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.LongVector,short[]) */
    public static  double cor( io.deephaven.vector.LongVector values0, short[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.LongVector,io.deephaven.vector.ByteVector) */
    public static  double cor( io.deephaven.vector.LongVector values0, io.deephaven.vector.ByteVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.LongVector,io.deephaven.vector.DoubleVector) */
    public static  double cor( io.deephaven.vector.LongVector values0, io.deephaven.vector.DoubleVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.LongVector,io.deephaven.vector.FloatVector) */
    public static  double cor( io.deephaven.vector.LongVector values0, io.deephaven.vector.FloatVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.LongVector,io.deephaven.vector.IntVector) */
    public static  double cor( io.deephaven.vector.LongVector values0, io.deephaven.vector.IntVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.LongVector,io.deephaven.vector.LongVector) */
    public static  double cor( io.deephaven.vector.LongVector values0, io.deephaven.vector.LongVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.LongVector,io.deephaven.vector.ShortVector) */
    public static  double cor( io.deephaven.vector.LongVector values0, io.deephaven.vector.ShortVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.ShortVector,byte[]) */
    public static  double cor( io.deephaven.vector.ShortVector values0, byte[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.ShortVector,double[]) */
    public static  double cor( io.deephaven.vector.ShortVector values0, double[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.ShortVector,float[]) */
    public static  double cor( io.deephaven.vector.ShortVector values0, float[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.ShortVector,int[]) */
    public static  double cor( io.deephaven.vector.ShortVector values0, int[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.ShortVector,long[]) */
    public static  double cor( io.deephaven.vector.ShortVector values0, long[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.ShortVector,short[]) */
    public static  double cor( io.deephaven.vector.ShortVector values0, short[] values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.ShortVector,io.deephaven.vector.ByteVector) */
    public static  double cor( io.deephaven.vector.ShortVector values0, io.deephaven.vector.ByteVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.ShortVector,io.deephaven.vector.DoubleVector) */
    public static  double cor( io.deephaven.vector.ShortVector values0, io.deephaven.vector.DoubleVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.ShortVector,io.deephaven.vector.FloatVector) */
    public static  double cor( io.deephaven.vector.ShortVector values0, io.deephaven.vector.FloatVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.ShortVector,io.deephaven.vector.IntVector) */
    public static  double cor( io.deephaven.vector.ShortVector values0, io.deephaven.vector.IntVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.ShortVector,io.deephaven.vector.LongVector) */
    public static  double cor( io.deephaven.vector.ShortVector values0, io.deephaven.vector.LongVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cor(io.deephaven.vector.ShortVector,io.deephaven.vector.ShortVector) */
    public static  double cor( io.deephaven.vector.ShortVector values0, io.deephaven.vector.ShortVector values1 ) {return Numeric.cor( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cos(byte) */
    public static  double cos( byte value ) {return Numeric.cos( value );}

    /** @see io.deephaven.function.Numeric#cos(double) */
    public static  double cos( double value ) {return Numeric.cos( value );}

    /** @see io.deephaven.function.Numeric#cos(float) */
    public static  double cos( float value ) {return Numeric.cos( value );}

    /** @see io.deephaven.function.Numeric#cos(int) */
    public static  double cos( int value ) {return Numeric.cos( value );}

    /** @see io.deephaven.function.Numeric#cos(long) */
    public static  double cos( long value ) {return Numeric.cos( value );}

    /** @see io.deephaven.function.Numeric#cos(short) */
    public static  double cos( short value ) {return Numeric.cos( value );}

    /** @see io.deephaven.function.Basic#count(byte[]) */
    public static  long count( byte... values ) {return Basic.count( values );}

    /** @see io.deephaven.function.Basic#count(char[]) */
    public static  long count( char... values ) {return Basic.count( values );}

    /** @see io.deephaven.function.Basic#count(double[]) */
    public static  long count( double... values ) {return Basic.count( values );}

    /** @see io.deephaven.function.Basic#count(float[]) */
    public static  long count( float... values ) {return Basic.count( values );}

    /** @see io.deephaven.function.Basic#count(int[]) */
    public static  long count( int... values ) {return Basic.count( values );}

    /** @see io.deephaven.function.Basic#count(long[]) */
    public static  long count( long... values ) {return Basic.count( values );}

    /** @see io.deephaven.function.Basic#count(short[]) */
    public static  long count( short... values ) {return Basic.count( values );}

    /** @see io.deephaven.function.Basic#count(io.deephaven.vector.ByteVector) */
    public static  long count( io.deephaven.vector.ByteVector values ) {return Basic.count( values );}

    /** @see io.deephaven.function.Basic#count(io.deephaven.vector.CharVector) */
    public static  long count( io.deephaven.vector.CharVector values ) {return Basic.count( values );}

    /** @see io.deephaven.function.Basic#count(io.deephaven.vector.DoubleVector) */
    public static  long count( io.deephaven.vector.DoubleVector values ) {return Basic.count( values );}

    /** @see io.deephaven.function.Basic#count(io.deephaven.vector.FloatVector) */
    public static  long count( io.deephaven.vector.FloatVector values ) {return Basic.count( values );}

    /** @see io.deephaven.function.Basic#count(io.deephaven.vector.IntVector) */
    public static  long count( io.deephaven.vector.IntVector values ) {return Basic.count( values );}

    /** @see io.deephaven.function.Basic#count(io.deephaven.vector.LongVector) */
    public static  long count( io.deephaven.vector.LongVector values ) {return Basic.count( values );}

    /** @see io.deephaven.function.Basic#count(io.deephaven.vector.ShortVector) */
    public static  long count( io.deephaven.vector.ShortVector values ) {return Basic.count( values );}

    /** @see io.deephaven.function.Basic#countDistinct(byte[]) */
    public static  long countDistinct( byte... values ) {return Basic.countDistinct( values );}

    /** @see io.deephaven.function.Basic#countDistinct(char[]) */
    public static  long countDistinct( char... values ) {return Basic.countDistinct( values );}

    /** @see io.deephaven.function.Basic#countDistinct(double[]) */
    public static  long countDistinct( double... values ) {return Basic.countDistinct( values );}

    /** @see io.deephaven.function.Basic#countDistinct(float[]) */
    public static  long countDistinct( float... values ) {return Basic.countDistinct( values );}

    /** @see io.deephaven.function.Basic#countDistinct(int[]) */
    public static  long countDistinct( int... values ) {return Basic.countDistinct( values );}

    /** @see io.deephaven.function.Basic#countDistinct(long[]) */
    public static  long countDistinct( long... values ) {return Basic.countDistinct( values );}

    /** @see io.deephaven.function.Basic#countDistinct(short[]) */
    public static  long countDistinct( short... values ) {return Basic.countDistinct( values );}

    /** @see io.deephaven.function.Basic#countDistinct(io.deephaven.vector.ByteVector) */
    public static  long countDistinct( io.deephaven.vector.ByteVector values ) {return Basic.countDistinct( values );}

    /** @see io.deephaven.function.Basic#countDistinct(io.deephaven.vector.CharVector) */
    public static  long countDistinct( io.deephaven.vector.CharVector values ) {return Basic.countDistinct( values );}

    /** @see io.deephaven.function.Basic#countDistinct(io.deephaven.vector.DoubleVector) */
    public static  long countDistinct( io.deephaven.vector.DoubleVector values ) {return Basic.countDistinct( values );}

    /** @see io.deephaven.function.Basic#countDistinct(io.deephaven.vector.FloatVector) */
    public static  long countDistinct( io.deephaven.vector.FloatVector values ) {return Basic.countDistinct( values );}

    /** @see io.deephaven.function.Basic#countDistinct(io.deephaven.vector.IntVector) */
    public static  long countDistinct( io.deephaven.vector.IntVector values ) {return Basic.countDistinct( values );}

    /** @see io.deephaven.function.Basic#countDistinct(io.deephaven.vector.LongVector) */
    public static  long countDistinct( io.deephaven.vector.LongVector values ) {return Basic.countDistinct( values );}

    /** @see io.deephaven.function.Basic#countDistinct(io.deephaven.vector.ShortVector) */
    public static  long countDistinct( io.deephaven.vector.ShortVector values ) {return Basic.countDistinct( values );}

    /** @see io.deephaven.function.Basic#countDistinct(byte[],boolean) */
    public static  long countDistinct( byte[] values, boolean countNull ) {return Basic.countDistinct( values, countNull );}

    /** @see io.deephaven.function.Basic#countDistinct(char[],boolean) */
    public static  long countDistinct( char[] values, boolean countNull ) {return Basic.countDistinct( values, countNull );}

    /** @see io.deephaven.function.Basic#countDistinct(double[],boolean) */
    public static  long countDistinct( double[] values, boolean countNull ) {return Basic.countDistinct( values, countNull );}

    /** @see io.deephaven.function.Basic#countDistinct(float[],boolean) */
    public static  long countDistinct( float[] values, boolean countNull ) {return Basic.countDistinct( values, countNull );}

    /** @see io.deephaven.function.Basic#countDistinct(int[],boolean) */
    public static  long countDistinct( int[] values, boolean countNull ) {return Basic.countDistinct( values, countNull );}

    /** @see io.deephaven.function.Basic#countDistinct(long[],boolean) */
    public static  long countDistinct( long[] values, boolean countNull ) {return Basic.countDistinct( values, countNull );}

    /** @see io.deephaven.function.Basic#countDistinct(short[],boolean) */
    public static  long countDistinct( short[] values, boolean countNull ) {return Basic.countDistinct( values, countNull );}

    /** @see io.deephaven.function.Basic#countDistinct(io.deephaven.vector.ByteVector,boolean) */
    public static  long countDistinct( io.deephaven.vector.ByteVector values, boolean countNull ) {return Basic.countDistinct( values, countNull );}

    /** @see io.deephaven.function.Basic#countDistinct(io.deephaven.vector.CharVector,boolean) */
    public static  long countDistinct( io.deephaven.vector.CharVector values, boolean countNull ) {return Basic.countDistinct( values, countNull );}

    /** @see io.deephaven.function.Basic#countDistinct(io.deephaven.vector.DoubleVector,boolean) */
    public static  long countDistinct( io.deephaven.vector.DoubleVector values, boolean countNull ) {return Basic.countDistinct( values, countNull );}

    /** @see io.deephaven.function.Basic#countDistinct(io.deephaven.vector.FloatVector,boolean) */
    public static  long countDistinct( io.deephaven.vector.FloatVector values, boolean countNull ) {return Basic.countDistinct( values, countNull );}

    /** @see io.deephaven.function.Basic#countDistinct(io.deephaven.vector.IntVector,boolean) */
    public static  long countDistinct( io.deephaven.vector.IntVector values, boolean countNull ) {return Basic.countDistinct( values, countNull );}

    /** @see io.deephaven.function.Basic#countDistinct(io.deephaven.vector.LongVector,boolean) */
    public static  long countDistinct( io.deephaven.vector.LongVector values, boolean countNull ) {return Basic.countDistinct( values, countNull );}

    /** @see io.deephaven.function.Basic#countDistinct(io.deephaven.vector.ShortVector,boolean) */
    public static  long countDistinct( io.deephaven.vector.ShortVector values, boolean countNull ) {return Basic.countDistinct( values, countNull );}

    /** @see io.deephaven.function.Basic#countDistinctObj(java.lang.Comparable[]) */
    public static > long countDistinctObj( T... values ) {return Basic.countDistinctObj( values );}

    /** @see io.deephaven.function.Basic#countDistinctObj(io.deephaven.vector.ObjectVector) */
    public static > long countDistinctObj( io.deephaven.vector.ObjectVector values ) {return Basic.countDistinctObj( values );}

    /** @see io.deephaven.function.Basic#countDistinctObj(java.lang.Comparable[],boolean) */
    public static > long countDistinctObj( T[] values, boolean countNull ) {return Basic.countDistinctObj( values, countNull );}

    /** @see io.deephaven.function.Basic#countDistinctObj(io.deephaven.vector.ObjectVector,boolean) */
    public static > long countDistinctObj( io.deephaven.vector.ObjectVector values, boolean countNull ) {return Basic.countDistinctObj( values, countNull );}

    /** @see io.deephaven.function.Numeric#countNeg(byte[]) */
    public static  long countNeg( byte... values ) {return Numeric.countNeg( values );}

    /** @see io.deephaven.function.Numeric#countNeg(double[]) */
    public static  long countNeg( double... values ) {return Numeric.countNeg( values );}

    /** @see io.deephaven.function.Numeric#countNeg(float[]) */
    public static  long countNeg( float... values ) {return Numeric.countNeg( values );}

    /** @see io.deephaven.function.Numeric#countNeg(int[]) */
    public static  long countNeg( int... values ) {return Numeric.countNeg( values );}

    /** @see io.deephaven.function.Numeric#countNeg(long[]) */
    public static  long countNeg( long... values ) {return Numeric.countNeg( values );}

    /** @see io.deephaven.function.Numeric#countNeg(java.lang.Byte[]) */
    public static  long countNeg( java.lang.Byte[] values ) {return Numeric.countNeg( values );}

    /** @see io.deephaven.function.Numeric#countNeg(java.lang.Double[]) */
    public static  long countNeg( java.lang.Double[] values ) {return Numeric.countNeg( values );}

    /** @see io.deephaven.function.Numeric#countNeg(java.lang.Float[]) */
    public static  long countNeg( java.lang.Float[] values ) {return Numeric.countNeg( values );}

    /** @see io.deephaven.function.Numeric#countNeg(java.lang.Integer[]) */
    public static  long countNeg( java.lang.Integer[] values ) {return Numeric.countNeg( values );}

    /** @see io.deephaven.function.Numeric#countNeg(java.lang.Long[]) */
    public static  long countNeg( java.lang.Long[] values ) {return Numeric.countNeg( values );}

    /** @see io.deephaven.function.Numeric#countNeg(java.lang.Short[]) */
    public static  long countNeg( java.lang.Short[] values ) {return Numeric.countNeg( values );}

    /** @see io.deephaven.function.Numeric#countNeg(short[]) */
    public static  long countNeg( short... values ) {return Numeric.countNeg( values );}

    /** @see io.deephaven.function.Numeric#countNeg(io.deephaven.vector.ByteVector) */
    public static  long countNeg( io.deephaven.vector.ByteVector values ) {return Numeric.countNeg( values );}

    /** @see io.deephaven.function.Numeric#countNeg(io.deephaven.vector.DoubleVector) */
    public static  long countNeg( io.deephaven.vector.DoubleVector values ) {return Numeric.countNeg( values );}

    /** @see io.deephaven.function.Numeric#countNeg(io.deephaven.vector.FloatVector) */
    public static  long countNeg( io.deephaven.vector.FloatVector values ) {return Numeric.countNeg( values );}

    /** @see io.deephaven.function.Numeric#countNeg(io.deephaven.vector.IntVector) */
    public static  long countNeg( io.deephaven.vector.IntVector values ) {return Numeric.countNeg( values );}

    /** @see io.deephaven.function.Numeric#countNeg(io.deephaven.vector.LongVector) */
    public static  long countNeg( io.deephaven.vector.LongVector values ) {return Numeric.countNeg( values );}

    /** @see io.deephaven.function.Numeric#countNeg(io.deephaven.vector.ShortVector) */
    public static  long countNeg( io.deephaven.vector.ShortVector values ) {return Numeric.countNeg( values );}

    /** @see io.deephaven.function.Basic#countObj(java.lang.Object[]) */
    public static  long countObj( T... values ) {return Basic.countObj( values );}

    /** @see io.deephaven.function.Basic#countObj(io.deephaven.vector.ObjectVector) */
    public static  long countObj( io.deephaven.vector.ObjectVector values ) {return Basic.countObj( values );}

    /** @see io.deephaven.function.Numeric#countPos(byte[]) */
    public static  long countPos( byte... values ) {return Numeric.countPos( values );}

    /** @see io.deephaven.function.Numeric#countPos(double[]) */
    public static  long countPos( double... values ) {return Numeric.countPos( values );}

    /** @see io.deephaven.function.Numeric#countPos(float[]) */
    public static  long countPos( float... values ) {return Numeric.countPos( values );}

    /** @see io.deephaven.function.Numeric#countPos(int[]) */
    public static  long countPos( int... values ) {return Numeric.countPos( values );}

    /** @see io.deephaven.function.Numeric#countPos(long[]) */
    public static  long countPos( long... values ) {return Numeric.countPos( values );}

    /** @see io.deephaven.function.Numeric#countPos(java.lang.Byte[]) */
    public static  long countPos( java.lang.Byte[] values ) {return Numeric.countPos( values );}

    /** @see io.deephaven.function.Numeric#countPos(java.lang.Double[]) */
    public static  long countPos( java.lang.Double[] values ) {return Numeric.countPos( values );}

    /** @see io.deephaven.function.Numeric#countPos(java.lang.Float[]) */
    public static  long countPos( java.lang.Float[] values ) {return Numeric.countPos( values );}

    /** @see io.deephaven.function.Numeric#countPos(java.lang.Integer[]) */
    public static  long countPos( java.lang.Integer[] values ) {return Numeric.countPos( values );}

    /** @see io.deephaven.function.Numeric#countPos(java.lang.Long[]) */
    public static  long countPos( java.lang.Long[] values ) {return Numeric.countPos( values );}

    /** @see io.deephaven.function.Numeric#countPos(java.lang.Short[]) */
    public static  long countPos( java.lang.Short[] values ) {return Numeric.countPos( values );}

    /** @see io.deephaven.function.Numeric#countPos(short[]) */
    public static  long countPos( short... values ) {return Numeric.countPos( values );}

    /** @see io.deephaven.function.Numeric#countPos(io.deephaven.vector.ByteVector) */
    public static  long countPos( io.deephaven.vector.ByteVector values ) {return Numeric.countPos( values );}

    /** @see io.deephaven.function.Numeric#countPos(io.deephaven.vector.DoubleVector) */
    public static  long countPos( io.deephaven.vector.DoubleVector values ) {return Numeric.countPos( values );}

    /** @see io.deephaven.function.Numeric#countPos(io.deephaven.vector.FloatVector) */
    public static  long countPos( io.deephaven.vector.FloatVector values ) {return Numeric.countPos( values );}

    /** @see io.deephaven.function.Numeric#countPos(io.deephaven.vector.IntVector) */
    public static  long countPos( io.deephaven.vector.IntVector values ) {return Numeric.countPos( values );}

    /** @see io.deephaven.function.Numeric#countPos(io.deephaven.vector.LongVector) */
    public static  long countPos( io.deephaven.vector.LongVector values ) {return Numeric.countPos( values );}

    /** @see io.deephaven.function.Numeric#countPos(io.deephaven.vector.ShortVector) */
    public static  long countPos( io.deephaven.vector.ShortVector values ) {return Numeric.countPos( values );}

    /** @see io.deephaven.function.Numeric#countZero(byte[]) */
    public static  long countZero( byte... values ) {return Numeric.countZero( values );}

    /** @see io.deephaven.function.Numeric#countZero(double[]) */
    public static  long countZero( double... values ) {return Numeric.countZero( values );}

    /** @see io.deephaven.function.Numeric#countZero(float[]) */
    public static  long countZero( float... values ) {return Numeric.countZero( values );}

    /** @see io.deephaven.function.Numeric#countZero(int[]) */
    public static  long countZero( int... values ) {return Numeric.countZero( values );}

    /** @see io.deephaven.function.Numeric#countZero(long[]) */
    public static  long countZero( long... values ) {return Numeric.countZero( values );}

    /** @see io.deephaven.function.Numeric#countZero(java.lang.Byte[]) */
    public static  long countZero( java.lang.Byte[] values ) {return Numeric.countZero( values );}

    /** @see io.deephaven.function.Numeric#countZero(java.lang.Double[]) */
    public static  long countZero( java.lang.Double[] values ) {return Numeric.countZero( values );}

    /** @see io.deephaven.function.Numeric#countZero(java.lang.Float[]) */
    public static  long countZero( java.lang.Float[] values ) {return Numeric.countZero( values );}

    /** @see io.deephaven.function.Numeric#countZero(java.lang.Integer[]) */
    public static  long countZero( java.lang.Integer[] values ) {return Numeric.countZero( values );}

    /** @see io.deephaven.function.Numeric#countZero(java.lang.Long[]) */
    public static  long countZero( java.lang.Long[] values ) {return Numeric.countZero( values );}

    /** @see io.deephaven.function.Numeric#countZero(java.lang.Short[]) */
    public static  long countZero( java.lang.Short[] values ) {return Numeric.countZero( values );}

    /** @see io.deephaven.function.Numeric#countZero(short[]) */
    public static  long countZero( short... values ) {return Numeric.countZero( values );}

    /** @see io.deephaven.function.Numeric#countZero(io.deephaven.vector.ByteVector) */
    public static  long countZero( io.deephaven.vector.ByteVector values ) {return Numeric.countZero( values );}

    /** @see io.deephaven.function.Numeric#countZero(io.deephaven.vector.DoubleVector) */
    public static  long countZero( io.deephaven.vector.DoubleVector values ) {return Numeric.countZero( values );}

    /** @see io.deephaven.function.Numeric#countZero(io.deephaven.vector.FloatVector) */
    public static  long countZero( io.deephaven.vector.FloatVector values ) {return Numeric.countZero( values );}

    /** @see io.deephaven.function.Numeric#countZero(io.deephaven.vector.IntVector) */
    public static  long countZero( io.deephaven.vector.IntVector values ) {return Numeric.countZero( values );}

    /** @see io.deephaven.function.Numeric#countZero(io.deephaven.vector.LongVector) */
    public static  long countZero( io.deephaven.vector.LongVector values ) {return Numeric.countZero( values );}

    /** @see io.deephaven.function.Numeric#countZero(io.deephaven.vector.ShortVector) */
    public static  long countZero( io.deephaven.vector.ShortVector values ) {return Numeric.countZero( values );}

    /** @see io.deephaven.function.Numeric#cov(byte[],byte[]) */
    public static  double cov( byte[] values0, byte[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(byte[],double[]) */
    public static  double cov( byte[] values0, double[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(byte[],float[]) */
    public static  double cov( byte[] values0, float[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(byte[],int[]) */
    public static  double cov( byte[] values0, int[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(byte[],long[]) */
    public static  double cov( byte[] values0, long[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(byte[],short[]) */
    public static  double cov( byte[] values0, short[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(byte[],io.deephaven.vector.ByteVector) */
    public static  double cov( byte[] values0, io.deephaven.vector.ByteVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(byte[],io.deephaven.vector.DoubleVector) */
    public static  double cov( byte[] values0, io.deephaven.vector.DoubleVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(byte[],io.deephaven.vector.FloatVector) */
    public static  double cov( byte[] values0, io.deephaven.vector.FloatVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(byte[],io.deephaven.vector.IntVector) */
    public static  double cov( byte[] values0, io.deephaven.vector.IntVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(byte[],io.deephaven.vector.LongVector) */
    public static  double cov( byte[] values0, io.deephaven.vector.LongVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(byte[],io.deephaven.vector.ShortVector) */
    public static  double cov( byte[] values0, io.deephaven.vector.ShortVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(double[],byte[]) */
    public static  double cov( double[] values0, byte[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(double[],double[]) */
    public static  double cov( double[] values0, double[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(double[],float[]) */
    public static  double cov( double[] values0, float[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(double[],int[]) */
    public static  double cov( double[] values0, int[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(double[],long[]) */
    public static  double cov( double[] values0, long[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(double[],short[]) */
    public static  double cov( double[] values0, short[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(double[],io.deephaven.vector.ByteVector) */
    public static  double cov( double[] values0, io.deephaven.vector.ByteVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(double[],io.deephaven.vector.DoubleVector) */
    public static  double cov( double[] values0, io.deephaven.vector.DoubleVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(double[],io.deephaven.vector.FloatVector) */
    public static  double cov( double[] values0, io.deephaven.vector.FloatVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(double[],io.deephaven.vector.IntVector) */
    public static  double cov( double[] values0, io.deephaven.vector.IntVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(double[],io.deephaven.vector.LongVector) */
    public static  double cov( double[] values0, io.deephaven.vector.LongVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(double[],io.deephaven.vector.ShortVector) */
    public static  double cov( double[] values0, io.deephaven.vector.ShortVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(float[],byte[]) */
    public static  double cov( float[] values0, byte[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(float[],double[]) */
    public static  double cov( float[] values0, double[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(float[],float[]) */
    public static  double cov( float[] values0, float[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(float[],int[]) */
    public static  double cov( float[] values0, int[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(float[],long[]) */
    public static  double cov( float[] values0, long[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(float[],short[]) */
    public static  double cov( float[] values0, short[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(float[],io.deephaven.vector.ByteVector) */
    public static  double cov( float[] values0, io.deephaven.vector.ByteVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(float[],io.deephaven.vector.DoubleVector) */
    public static  double cov( float[] values0, io.deephaven.vector.DoubleVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(float[],io.deephaven.vector.FloatVector) */
    public static  double cov( float[] values0, io.deephaven.vector.FloatVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(float[],io.deephaven.vector.IntVector) */
    public static  double cov( float[] values0, io.deephaven.vector.IntVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(float[],io.deephaven.vector.LongVector) */
    public static  double cov( float[] values0, io.deephaven.vector.LongVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(float[],io.deephaven.vector.ShortVector) */
    public static  double cov( float[] values0, io.deephaven.vector.ShortVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(int[],byte[]) */
    public static  double cov( int[] values0, byte[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(int[],double[]) */
    public static  double cov( int[] values0, double[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(int[],float[]) */
    public static  double cov( int[] values0, float[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(int[],int[]) */
    public static  double cov( int[] values0, int[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(int[],long[]) */
    public static  double cov( int[] values0, long[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(int[],short[]) */
    public static  double cov( int[] values0, short[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(int[],io.deephaven.vector.ByteVector) */
    public static  double cov( int[] values0, io.deephaven.vector.ByteVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(int[],io.deephaven.vector.DoubleVector) */
    public static  double cov( int[] values0, io.deephaven.vector.DoubleVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(int[],io.deephaven.vector.FloatVector) */
    public static  double cov( int[] values0, io.deephaven.vector.FloatVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(int[],io.deephaven.vector.IntVector) */
    public static  double cov( int[] values0, io.deephaven.vector.IntVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(int[],io.deephaven.vector.LongVector) */
    public static  double cov( int[] values0, io.deephaven.vector.LongVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(int[],io.deephaven.vector.ShortVector) */
    public static  double cov( int[] values0, io.deephaven.vector.ShortVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(long[],byte[]) */
    public static  double cov( long[] values0, byte[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(long[],double[]) */
    public static  double cov( long[] values0, double[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(long[],float[]) */
    public static  double cov( long[] values0, float[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(long[],int[]) */
    public static  double cov( long[] values0, int[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(long[],long[]) */
    public static  double cov( long[] values0, long[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(long[],short[]) */
    public static  double cov( long[] values0, short[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(long[],io.deephaven.vector.ByteVector) */
    public static  double cov( long[] values0, io.deephaven.vector.ByteVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(long[],io.deephaven.vector.DoubleVector) */
    public static  double cov( long[] values0, io.deephaven.vector.DoubleVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(long[],io.deephaven.vector.FloatVector) */
    public static  double cov( long[] values0, io.deephaven.vector.FloatVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(long[],io.deephaven.vector.IntVector) */
    public static  double cov( long[] values0, io.deephaven.vector.IntVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(long[],io.deephaven.vector.LongVector) */
    public static  double cov( long[] values0, io.deephaven.vector.LongVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(long[],io.deephaven.vector.ShortVector) */
    public static  double cov( long[] values0, io.deephaven.vector.ShortVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(short[],byte[]) */
    public static  double cov( short[] values0, byte[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(short[],double[]) */
    public static  double cov( short[] values0, double[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(short[],float[]) */
    public static  double cov( short[] values0, float[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(short[],int[]) */
    public static  double cov( short[] values0, int[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(short[],long[]) */
    public static  double cov( short[] values0, long[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(short[],short[]) */
    public static  double cov( short[] values0, short[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(short[],io.deephaven.vector.ByteVector) */
    public static  double cov( short[] values0, io.deephaven.vector.ByteVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(short[],io.deephaven.vector.DoubleVector) */
    public static  double cov( short[] values0, io.deephaven.vector.DoubleVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(short[],io.deephaven.vector.FloatVector) */
    public static  double cov( short[] values0, io.deephaven.vector.FloatVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(short[],io.deephaven.vector.IntVector) */
    public static  double cov( short[] values0, io.deephaven.vector.IntVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(short[],io.deephaven.vector.LongVector) */
    public static  double cov( short[] values0, io.deephaven.vector.LongVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(short[],io.deephaven.vector.ShortVector) */
    public static  double cov( short[] values0, io.deephaven.vector.ShortVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.ByteVector,byte[]) */
    public static  double cov( io.deephaven.vector.ByteVector values0, byte[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.ByteVector,double[]) */
    public static  double cov( io.deephaven.vector.ByteVector values0, double[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.ByteVector,float[]) */
    public static  double cov( io.deephaven.vector.ByteVector values0, float[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.ByteVector,int[]) */
    public static  double cov( io.deephaven.vector.ByteVector values0, int[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.ByteVector,long[]) */
    public static  double cov( io.deephaven.vector.ByteVector values0, long[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.ByteVector,short[]) */
    public static  double cov( io.deephaven.vector.ByteVector values0, short[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.ByteVector,io.deephaven.vector.ByteVector) */
    public static  double cov( io.deephaven.vector.ByteVector values0, io.deephaven.vector.ByteVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.ByteVector,io.deephaven.vector.DoubleVector) */
    public static  double cov( io.deephaven.vector.ByteVector values0, io.deephaven.vector.DoubleVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.ByteVector,io.deephaven.vector.FloatVector) */
    public static  double cov( io.deephaven.vector.ByteVector values0, io.deephaven.vector.FloatVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.ByteVector,io.deephaven.vector.IntVector) */
    public static  double cov( io.deephaven.vector.ByteVector values0, io.deephaven.vector.IntVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.ByteVector,io.deephaven.vector.LongVector) */
    public static  double cov( io.deephaven.vector.ByteVector values0, io.deephaven.vector.LongVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.ByteVector,io.deephaven.vector.ShortVector) */
    public static  double cov( io.deephaven.vector.ByteVector values0, io.deephaven.vector.ShortVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.DoubleVector,byte[]) */
    public static  double cov( io.deephaven.vector.DoubleVector values0, byte[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.DoubleVector,double[]) */
    public static  double cov( io.deephaven.vector.DoubleVector values0, double[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.DoubleVector,float[]) */
    public static  double cov( io.deephaven.vector.DoubleVector values0, float[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.DoubleVector,int[]) */
    public static  double cov( io.deephaven.vector.DoubleVector values0, int[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.DoubleVector,long[]) */
    public static  double cov( io.deephaven.vector.DoubleVector values0, long[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.DoubleVector,short[]) */
    public static  double cov( io.deephaven.vector.DoubleVector values0, short[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.DoubleVector,io.deephaven.vector.ByteVector) */
    public static  double cov( io.deephaven.vector.DoubleVector values0, io.deephaven.vector.ByteVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.DoubleVector,io.deephaven.vector.DoubleVector) */
    public static  double cov( io.deephaven.vector.DoubleVector values0, io.deephaven.vector.DoubleVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.DoubleVector,io.deephaven.vector.FloatVector) */
    public static  double cov( io.deephaven.vector.DoubleVector values0, io.deephaven.vector.FloatVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.DoubleVector,io.deephaven.vector.IntVector) */
    public static  double cov( io.deephaven.vector.DoubleVector values0, io.deephaven.vector.IntVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.DoubleVector,io.deephaven.vector.LongVector) */
    public static  double cov( io.deephaven.vector.DoubleVector values0, io.deephaven.vector.LongVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.DoubleVector,io.deephaven.vector.ShortVector) */
    public static  double cov( io.deephaven.vector.DoubleVector values0, io.deephaven.vector.ShortVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.FloatVector,byte[]) */
    public static  double cov( io.deephaven.vector.FloatVector values0, byte[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.FloatVector,double[]) */
    public static  double cov( io.deephaven.vector.FloatVector values0, double[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.FloatVector,float[]) */
    public static  double cov( io.deephaven.vector.FloatVector values0, float[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.FloatVector,int[]) */
    public static  double cov( io.deephaven.vector.FloatVector values0, int[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.FloatVector,long[]) */
    public static  double cov( io.deephaven.vector.FloatVector values0, long[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.FloatVector,short[]) */
    public static  double cov( io.deephaven.vector.FloatVector values0, short[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.FloatVector,io.deephaven.vector.ByteVector) */
    public static  double cov( io.deephaven.vector.FloatVector values0, io.deephaven.vector.ByteVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.FloatVector,io.deephaven.vector.DoubleVector) */
    public static  double cov( io.deephaven.vector.FloatVector values0, io.deephaven.vector.DoubleVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.FloatVector,io.deephaven.vector.FloatVector) */
    public static  double cov( io.deephaven.vector.FloatVector values0, io.deephaven.vector.FloatVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.FloatVector,io.deephaven.vector.IntVector) */
    public static  double cov( io.deephaven.vector.FloatVector values0, io.deephaven.vector.IntVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.FloatVector,io.deephaven.vector.LongVector) */
    public static  double cov( io.deephaven.vector.FloatVector values0, io.deephaven.vector.LongVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.FloatVector,io.deephaven.vector.ShortVector) */
    public static  double cov( io.deephaven.vector.FloatVector values0, io.deephaven.vector.ShortVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.IntVector,byte[]) */
    public static  double cov( io.deephaven.vector.IntVector values0, byte[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.IntVector,double[]) */
    public static  double cov( io.deephaven.vector.IntVector values0, double[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.IntVector,float[]) */
    public static  double cov( io.deephaven.vector.IntVector values0, float[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.IntVector,int[]) */
    public static  double cov( io.deephaven.vector.IntVector values0, int[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.IntVector,long[]) */
    public static  double cov( io.deephaven.vector.IntVector values0, long[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.IntVector,short[]) */
    public static  double cov( io.deephaven.vector.IntVector values0, short[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.IntVector,io.deephaven.vector.ByteVector) */
    public static  double cov( io.deephaven.vector.IntVector values0, io.deephaven.vector.ByteVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.IntVector,io.deephaven.vector.DoubleVector) */
    public static  double cov( io.deephaven.vector.IntVector values0, io.deephaven.vector.DoubleVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.IntVector,io.deephaven.vector.FloatVector) */
    public static  double cov( io.deephaven.vector.IntVector values0, io.deephaven.vector.FloatVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.IntVector,io.deephaven.vector.IntVector) */
    public static  double cov( io.deephaven.vector.IntVector values0, io.deephaven.vector.IntVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.IntVector,io.deephaven.vector.LongVector) */
    public static  double cov( io.deephaven.vector.IntVector values0, io.deephaven.vector.LongVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.IntVector,io.deephaven.vector.ShortVector) */
    public static  double cov( io.deephaven.vector.IntVector values0, io.deephaven.vector.ShortVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.LongVector,byte[]) */
    public static  double cov( io.deephaven.vector.LongVector values0, byte[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.LongVector,double[]) */
    public static  double cov( io.deephaven.vector.LongVector values0, double[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.LongVector,float[]) */
    public static  double cov( io.deephaven.vector.LongVector values0, float[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.LongVector,int[]) */
    public static  double cov( io.deephaven.vector.LongVector values0, int[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.LongVector,long[]) */
    public static  double cov( io.deephaven.vector.LongVector values0, long[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.LongVector,short[]) */
    public static  double cov( io.deephaven.vector.LongVector values0, short[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.LongVector,io.deephaven.vector.ByteVector) */
    public static  double cov( io.deephaven.vector.LongVector values0, io.deephaven.vector.ByteVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.LongVector,io.deephaven.vector.DoubleVector) */
    public static  double cov( io.deephaven.vector.LongVector values0, io.deephaven.vector.DoubleVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.LongVector,io.deephaven.vector.FloatVector) */
    public static  double cov( io.deephaven.vector.LongVector values0, io.deephaven.vector.FloatVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.LongVector,io.deephaven.vector.IntVector) */
    public static  double cov( io.deephaven.vector.LongVector values0, io.deephaven.vector.IntVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.LongVector,io.deephaven.vector.LongVector) */
    public static  double cov( io.deephaven.vector.LongVector values0, io.deephaven.vector.LongVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.LongVector,io.deephaven.vector.ShortVector) */
    public static  double cov( io.deephaven.vector.LongVector values0, io.deephaven.vector.ShortVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.ShortVector,byte[]) */
    public static  double cov( io.deephaven.vector.ShortVector values0, byte[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.ShortVector,double[]) */
    public static  double cov( io.deephaven.vector.ShortVector values0, double[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.ShortVector,float[]) */
    public static  double cov( io.deephaven.vector.ShortVector values0, float[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.ShortVector,int[]) */
    public static  double cov( io.deephaven.vector.ShortVector values0, int[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.ShortVector,long[]) */
    public static  double cov( io.deephaven.vector.ShortVector values0, long[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.ShortVector,short[]) */
    public static  double cov( io.deephaven.vector.ShortVector values0, short[] values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.ShortVector,io.deephaven.vector.ByteVector) */
    public static  double cov( io.deephaven.vector.ShortVector values0, io.deephaven.vector.ByteVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.ShortVector,io.deephaven.vector.DoubleVector) */
    public static  double cov( io.deephaven.vector.ShortVector values0, io.deephaven.vector.DoubleVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.ShortVector,io.deephaven.vector.FloatVector) */
    public static  double cov( io.deephaven.vector.ShortVector values0, io.deephaven.vector.FloatVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.ShortVector,io.deephaven.vector.IntVector) */
    public static  double cov( io.deephaven.vector.ShortVector values0, io.deephaven.vector.IntVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.ShortVector,io.deephaven.vector.LongVector) */
    public static  double cov( io.deephaven.vector.ShortVector values0, io.deephaven.vector.LongVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cov(io.deephaven.vector.ShortVector,io.deephaven.vector.ShortVector) */
    public static  double cov( io.deephaven.vector.ShortVector values0, io.deephaven.vector.ShortVector values1 ) {return Numeric.cov( values0, values1 );}

    /** @see io.deephaven.function.Numeric#cummax(byte[]) */
    public static  byte[] cummax( byte... values ) {return Numeric.cummax( values );}

    /** @see io.deephaven.function.Numeric#cummax(double[]) */
    public static  double[] cummax( double... values ) {return Numeric.cummax( values );}

    /** @see io.deephaven.function.Numeric#cummax(float[]) */
    public static  float[] cummax( float... values ) {return Numeric.cummax( values );}

    /** @see io.deephaven.function.Numeric#cummax(int[]) */
    public static  int[] cummax( int... values ) {return Numeric.cummax( values );}

    /** @see io.deephaven.function.Numeric#cummax(long[]) */
    public static  long[] cummax( long... values ) {return Numeric.cummax( values );}

    /** @see io.deephaven.function.Numeric#cummax(java.lang.Byte[]) */
    public static  byte[] cummax( java.lang.Byte[] values ) {return Numeric.cummax( values );}

    /** @see io.deephaven.function.Numeric#cummax(java.lang.Double[]) */
    public static  double[] cummax( java.lang.Double[] values ) {return Numeric.cummax( values );}

    /** @see io.deephaven.function.Numeric#cummax(java.lang.Float[]) */
    public static  float[] cummax( java.lang.Float[] values ) {return Numeric.cummax( values );}

    /** @see io.deephaven.function.Numeric#cummax(java.lang.Integer[]) */
    public static  int[] cummax( java.lang.Integer[] values ) {return Numeric.cummax( values );}

    /** @see io.deephaven.function.Numeric#cummax(java.lang.Long[]) */
    public static  long[] cummax( java.lang.Long[] values ) {return Numeric.cummax( values );}

    /** @see io.deephaven.function.Numeric#cummax(java.lang.Short[]) */
    public static  short[] cummax( java.lang.Short[] values ) {return Numeric.cummax( values );}

    /** @see io.deephaven.function.Numeric#cummax(short[]) */
    public static  short[] cummax( short... values ) {return Numeric.cummax( values );}

    /** @see io.deephaven.function.Numeric#cummax(io.deephaven.vector.ByteVector) */
    public static  byte[] cummax( io.deephaven.vector.ByteVector values ) {return Numeric.cummax( values );}

    /** @see io.deephaven.function.Numeric#cummax(io.deephaven.vector.DoubleVector) */
    public static  double[] cummax( io.deephaven.vector.DoubleVector values ) {return Numeric.cummax( values );}

    /** @see io.deephaven.function.Numeric#cummax(io.deephaven.vector.FloatVector) */
    public static  float[] cummax( io.deephaven.vector.FloatVector values ) {return Numeric.cummax( values );}

    /** @see io.deephaven.function.Numeric#cummax(io.deephaven.vector.IntVector) */
    public static  int[] cummax( io.deephaven.vector.IntVector values ) {return Numeric.cummax( values );}

    /** @see io.deephaven.function.Numeric#cummax(io.deephaven.vector.LongVector) */
    public static  long[] cummax( io.deephaven.vector.LongVector values ) {return Numeric.cummax( values );}

    /** @see io.deephaven.function.Numeric#cummax(io.deephaven.vector.ShortVector) */
    public static  short[] cummax( io.deephaven.vector.ShortVector values ) {return Numeric.cummax( values );}

    /** @see io.deephaven.function.Numeric#cummin(byte[]) */
    public static  byte[] cummin( byte... values ) {return Numeric.cummin( values );}

    /** @see io.deephaven.function.Numeric#cummin(double[]) */
    public static  double[] cummin( double... values ) {return Numeric.cummin( values );}

    /** @see io.deephaven.function.Numeric#cummin(float[]) */
    public static  float[] cummin( float... values ) {return Numeric.cummin( values );}

    /** @see io.deephaven.function.Numeric#cummin(int[]) */
    public static  int[] cummin( int... values ) {return Numeric.cummin( values );}

    /** @see io.deephaven.function.Numeric#cummin(long[]) */
    public static  long[] cummin( long... values ) {return Numeric.cummin( values );}

    /** @see io.deephaven.function.Numeric#cummin(java.lang.Byte[]) */
    public static  byte[] cummin( java.lang.Byte[] values ) {return Numeric.cummin( values );}

    /** @see io.deephaven.function.Numeric#cummin(java.lang.Double[]) */
    public static  double[] cummin( java.lang.Double[] values ) {return Numeric.cummin( values );}

    /** @see io.deephaven.function.Numeric#cummin(java.lang.Float[]) */
    public static  float[] cummin( java.lang.Float[] values ) {return Numeric.cummin( values );}

    /** @see io.deephaven.function.Numeric#cummin(java.lang.Integer[]) */
    public static  int[] cummin( java.lang.Integer[] values ) {return Numeric.cummin( values );}

    /** @see io.deephaven.function.Numeric#cummin(java.lang.Long[]) */
    public static  long[] cummin( java.lang.Long[] values ) {return Numeric.cummin( values );}

    /** @see io.deephaven.function.Numeric#cummin(java.lang.Short[]) */
    public static  short[] cummin( java.lang.Short[] values ) {return Numeric.cummin( values );}

    /** @see io.deephaven.function.Numeric#cummin(short[]) */
    public static  short[] cummin( short... values ) {return Numeric.cummin( values );}

    /** @see io.deephaven.function.Numeric#cummin(io.deephaven.vector.ByteVector) */
    public static  byte[] cummin( io.deephaven.vector.ByteVector values ) {return Numeric.cummin( values );}

    /** @see io.deephaven.function.Numeric#cummin(io.deephaven.vector.DoubleVector) */
    public static  double[] cummin( io.deephaven.vector.DoubleVector values ) {return Numeric.cummin( values );}

    /** @see io.deephaven.function.Numeric#cummin(io.deephaven.vector.FloatVector) */
    public static  float[] cummin( io.deephaven.vector.FloatVector values ) {return Numeric.cummin( values );}

    /** @see io.deephaven.function.Numeric#cummin(io.deephaven.vector.IntVector) */
    public static  int[] cummin( io.deephaven.vector.IntVector values ) {return Numeric.cummin( values );}

    /** @see io.deephaven.function.Numeric#cummin(io.deephaven.vector.LongVector) */
    public static  long[] cummin( io.deephaven.vector.LongVector values ) {return Numeric.cummin( values );}

    /** @see io.deephaven.function.Numeric#cummin(io.deephaven.vector.ShortVector) */
    public static  short[] cummin( io.deephaven.vector.ShortVector values ) {return Numeric.cummin( values );}

    /** @see io.deephaven.function.Numeric#cumprod(byte[]) */
    public static  byte[] cumprod( byte... values ) {return Numeric.cumprod( values );}

    /** @see io.deephaven.function.Numeric#cumprod(double[]) */
    public static  double[] cumprod( double... values ) {return Numeric.cumprod( values );}

    /** @see io.deephaven.function.Numeric#cumprod(float[]) */
    public static  float[] cumprod( float... values ) {return Numeric.cumprod( values );}

    /** @see io.deephaven.function.Numeric#cumprod(int[]) */
    public static  int[] cumprod( int... values ) {return Numeric.cumprod( values );}

    /** @see io.deephaven.function.Numeric#cumprod(long[]) */
    public static  long[] cumprod( long... values ) {return Numeric.cumprod( values );}

    /** @see io.deephaven.function.Numeric#cumprod(java.lang.Byte[]) */
    public static  byte[] cumprod( java.lang.Byte[] values ) {return Numeric.cumprod( values );}

    /** @see io.deephaven.function.Numeric#cumprod(java.lang.Double[]) */
    public static  double[] cumprod( java.lang.Double[] values ) {return Numeric.cumprod( values );}

    /** @see io.deephaven.function.Numeric#cumprod(java.lang.Float[]) */
    public static  float[] cumprod( java.lang.Float[] values ) {return Numeric.cumprod( values );}

    /** @see io.deephaven.function.Numeric#cumprod(java.lang.Integer[]) */
    public static  int[] cumprod( java.lang.Integer[] values ) {return Numeric.cumprod( values );}

    /** @see io.deephaven.function.Numeric#cumprod(java.lang.Long[]) */
    public static  long[] cumprod( java.lang.Long[] values ) {return Numeric.cumprod( values );}

    /** @see io.deephaven.function.Numeric#cumprod(java.lang.Short[]) */
    public static  short[] cumprod( java.lang.Short[] values ) {return Numeric.cumprod( values );}

    /** @see io.deephaven.function.Numeric#cumprod(short[]) */
    public static  short[] cumprod( short... values ) {return Numeric.cumprod( values );}

    /** @see io.deephaven.function.Numeric#cumprod(io.deephaven.vector.ByteVector) */
    public static  byte[] cumprod( io.deephaven.vector.ByteVector values ) {return Numeric.cumprod( values );}

    /** @see io.deephaven.function.Numeric#cumprod(io.deephaven.vector.DoubleVector) */
    public static  double[] cumprod( io.deephaven.vector.DoubleVector values ) {return Numeric.cumprod( values );}

    /** @see io.deephaven.function.Numeric#cumprod(io.deephaven.vector.FloatVector) */
    public static  float[] cumprod( io.deephaven.vector.FloatVector values ) {return Numeric.cumprod( values );}

    /** @see io.deephaven.function.Numeric#cumprod(io.deephaven.vector.IntVector) */
    public static  int[] cumprod( io.deephaven.vector.IntVector values ) {return Numeric.cumprod( values );}

    /** @see io.deephaven.function.Numeric#cumprod(io.deephaven.vector.LongVector) */
    public static  long[] cumprod( io.deephaven.vector.LongVector values ) {return Numeric.cumprod( values );}

    /** @see io.deephaven.function.Numeric#cumprod(io.deephaven.vector.ShortVector) */
    public static  short[] cumprod( io.deephaven.vector.ShortVector values ) {return Numeric.cumprod( values );}

    /** @see io.deephaven.function.Numeric#cumsum(byte[]) */
    public static  byte[] cumsum( byte... values ) {return Numeric.cumsum( values );}

    /** @see io.deephaven.function.Numeric#cumsum(double[]) */
    public static  double[] cumsum( double... values ) {return Numeric.cumsum( values );}

    /** @see io.deephaven.function.Numeric#cumsum(float[]) */
    public static  float[] cumsum( float... values ) {return Numeric.cumsum( values );}

    /** @see io.deephaven.function.Numeric#cumsum(int[]) */
    public static  int[] cumsum( int... values ) {return Numeric.cumsum( values );}

    /** @see io.deephaven.function.Numeric#cumsum(long[]) */
    public static  long[] cumsum( long... values ) {return Numeric.cumsum( values );}

    /** @see io.deephaven.function.Numeric#cumsum(java.lang.Byte[]) */
    public static  byte[] cumsum( java.lang.Byte[] values ) {return Numeric.cumsum( values );}

    /** @see io.deephaven.function.Numeric#cumsum(java.lang.Double[]) */
    public static  double[] cumsum( java.lang.Double[] values ) {return Numeric.cumsum( values );}

    /** @see io.deephaven.function.Numeric#cumsum(java.lang.Float[]) */
    public static  float[] cumsum( java.lang.Float[] values ) {return Numeric.cumsum( values );}

    /** @see io.deephaven.function.Numeric#cumsum(java.lang.Integer[]) */
    public static  int[] cumsum( java.lang.Integer[] values ) {return Numeric.cumsum( values );}

    /** @see io.deephaven.function.Numeric#cumsum(java.lang.Long[]) */
    public static  long[] cumsum( java.lang.Long[] values ) {return Numeric.cumsum( values );}

    /** @see io.deephaven.function.Numeric#cumsum(java.lang.Short[]) */
    public static  short[] cumsum( java.lang.Short[] values ) {return Numeric.cumsum( values );}

    /** @see io.deephaven.function.Numeric#cumsum(short[]) */
    public static  short[] cumsum( short... values ) {return Numeric.cumsum( values );}

    /** @see io.deephaven.function.Numeric#cumsum(io.deephaven.vector.ByteVector) */
    public static  byte[] cumsum( io.deephaven.vector.ByteVector values ) {return Numeric.cumsum( values );}

    /** @see io.deephaven.function.Numeric#cumsum(io.deephaven.vector.DoubleVector) */
    public static  double[] cumsum( io.deephaven.vector.DoubleVector values ) {return Numeric.cumsum( values );}

    /** @see io.deephaven.function.Numeric#cumsum(io.deephaven.vector.FloatVector) */
    public static  float[] cumsum( io.deephaven.vector.FloatVector values ) {return Numeric.cumsum( values );}

    /** @see io.deephaven.function.Numeric#cumsum(io.deephaven.vector.IntVector) */
    public static  int[] cumsum( io.deephaven.vector.IntVector values ) {return Numeric.cumsum( values );}

    /** @see io.deephaven.function.Numeric#cumsum(io.deephaven.vector.LongVector) */
    public static  long[] cumsum( io.deephaven.vector.LongVector values ) {return Numeric.cumsum( values );}

    /** @see io.deephaven.function.Numeric#cumsum(io.deephaven.vector.ShortVector) */
    public static  short[] cumsum( io.deephaven.vector.ShortVector values ) {return Numeric.cumsum( values );}

    /** @see io.deephaven.function.Basic#distinct(byte[]) */
    public static  byte[] distinct( byte... values ) {return Basic.distinct( values );}

    /** @see io.deephaven.function.Basic#distinct(char[]) */
    public static  char[] distinct( char... values ) {return Basic.distinct( values );}

    /** @see io.deephaven.function.Basic#distinct(double[]) */
    public static  double[] distinct( double... values ) {return Basic.distinct( values );}

    /** @see io.deephaven.function.Basic#distinct(float[]) */
    public static  float[] distinct( float... values ) {return Basic.distinct( values );}

    /** @see io.deephaven.function.Basic#distinct(int[]) */
    public static  int[] distinct( int... values ) {return Basic.distinct( values );}

    /** @see io.deephaven.function.Basic#distinct(long[]) */
    public static  long[] distinct( long... values ) {return Basic.distinct( values );}

    /** @see io.deephaven.function.Basic#distinct(short[]) */
    public static  short[] distinct( short... values ) {return Basic.distinct( values );}

    /** @see io.deephaven.function.Basic#distinct(io.deephaven.vector.ByteVector) */
    public static  byte[] distinct( io.deephaven.vector.ByteVector values ) {return Basic.distinct( values );}

    /** @see io.deephaven.function.Basic#distinct(io.deephaven.vector.CharVector) */
    public static  char[] distinct( io.deephaven.vector.CharVector values ) {return Basic.distinct( values );}

    /** @see io.deephaven.function.Basic#distinct(io.deephaven.vector.DoubleVector) */
    public static  double[] distinct( io.deephaven.vector.DoubleVector values ) {return Basic.distinct( values );}

    /** @see io.deephaven.function.Basic#distinct(io.deephaven.vector.FloatVector) */
    public static  float[] distinct( io.deephaven.vector.FloatVector values ) {return Basic.distinct( values );}

    /** @see io.deephaven.function.Basic#distinct(io.deephaven.vector.IntVector) */
    public static  int[] distinct( io.deephaven.vector.IntVector values ) {return Basic.distinct( values );}

    /** @see io.deephaven.function.Basic#distinct(io.deephaven.vector.LongVector) */
    public static  long[] distinct( io.deephaven.vector.LongVector values ) {return Basic.distinct( values );}

    /** @see io.deephaven.function.Basic#distinct(io.deephaven.vector.ShortVector) */
    public static  short[] distinct( io.deephaven.vector.ShortVector values ) {return Basic.distinct( values );}

    /** @see io.deephaven.function.Basic#distinct(byte[],boolean) */
    public static  byte[] distinct( byte[] values, boolean includeNull ) {return Basic.distinct( values, includeNull );}

    /** @see io.deephaven.function.Basic#distinct(char[],boolean) */
    public static  char[] distinct( char[] values, boolean includeNull ) {return Basic.distinct( values, includeNull );}

    /** @see io.deephaven.function.Basic#distinct(double[],boolean) */
    public static  double[] distinct( double[] values, boolean includeNull ) {return Basic.distinct( values, includeNull );}

    /** @see io.deephaven.function.Basic#distinct(float[],boolean) */
    public static  float[] distinct( float[] values, boolean includeNull ) {return Basic.distinct( values, includeNull );}

    /** @see io.deephaven.function.Basic#distinct(int[],boolean) */
    public static  int[] distinct( int[] values, boolean includeNull ) {return Basic.distinct( values, includeNull );}

    /** @see io.deephaven.function.Basic#distinct(long[],boolean) */
    public static  long[] distinct( long[] values, boolean includeNull ) {return Basic.distinct( values, includeNull );}

    /** @see io.deephaven.function.Basic#distinct(short[],boolean) */
    public static  short[] distinct( short[] values, boolean includeNull ) {return Basic.distinct( values, includeNull );}

    /** @see io.deephaven.function.Basic#distinct(io.deephaven.vector.ByteVector,boolean) */
    public static  byte[] distinct( io.deephaven.vector.ByteVector values, boolean includeNull ) {return Basic.distinct( values, includeNull );}

    /** @see io.deephaven.function.Basic#distinct(io.deephaven.vector.CharVector,boolean) */
    public static  char[] distinct( io.deephaven.vector.CharVector values, boolean includeNull ) {return Basic.distinct( values, includeNull );}

    /** @see io.deephaven.function.Basic#distinct(io.deephaven.vector.DoubleVector,boolean) */
    public static  double[] distinct( io.deephaven.vector.DoubleVector values, boolean includeNull ) {return Basic.distinct( values, includeNull );}

    /** @see io.deephaven.function.Basic#distinct(io.deephaven.vector.FloatVector,boolean) */
    public static  float[] distinct( io.deephaven.vector.FloatVector values, boolean includeNull ) {return Basic.distinct( values, includeNull );}

    /** @see io.deephaven.function.Basic#distinct(io.deephaven.vector.IntVector,boolean) */
    public static  int[] distinct( io.deephaven.vector.IntVector values, boolean includeNull ) {return Basic.distinct( values, includeNull );}

    /** @see io.deephaven.function.Basic#distinct(io.deephaven.vector.LongVector,boolean) */
    public static  long[] distinct( io.deephaven.vector.LongVector values, boolean includeNull ) {return Basic.distinct( values, includeNull );}

    /** @see io.deephaven.function.Basic#distinct(io.deephaven.vector.ShortVector,boolean) */
    public static  short[] distinct( io.deephaven.vector.ShortVector values, boolean includeNull ) {return Basic.distinct( values, includeNull );}

    /** @see io.deephaven.function.Basic#distinctObj(java.lang.Comparable[]) */
    public static > T[] distinctObj( T... values ) {return Basic.distinctObj( values );}

    /** @see io.deephaven.function.Basic#distinctObj(io.deephaven.vector.ObjectVector) */
    public static > T[] distinctObj( io.deephaven.vector.ObjectVector values ) {return Basic.distinctObj( values );}

    /** @see io.deephaven.function.Basic#distinctObj(java.lang.Comparable[],boolean) */
    public static > T[] distinctObj( T[] values, boolean includeNull ) {return Basic.distinctObj( values, includeNull );}

    /** @see io.deephaven.function.Basic#distinctObj(io.deephaven.vector.ObjectVector,boolean) */
    public static > T[] distinctObj( io.deephaven.vector.ObjectVector values, boolean includeNull ) {return Basic.distinctObj( values, includeNull );}

    /** @see io.deephaven.function.Basic#enlist(byte[]) */
    public static  byte[] enlist( byte... values ) {return Basic.enlist( values );}

    /** @see io.deephaven.function.Basic#enlist(char[]) */
    public static  char[] enlist( char... values ) {return Basic.enlist( values );}

    /** @see io.deephaven.function.Basic#enlist(double[]) */
    public static  double[] enlist( double... values ) {return Basic.enlist( values );}

    /** @see io.deephaven.function.Basic#enlist(float[]) */
    public static  float[] enlist( float... values ) {return Basic.enlist( values );}

    /** @see io.deephaven.function.Basic#enlist(int[]) */
    public static  int[] enlist( int... values ) {return Basic.enlist( values );}

    /** @see io.deephaven.function.Basic#enlist(long[]) */
    public static  long[] enlist( long... values ) {return Basic.enlist( values );}

    /** @see io.deephaven.function.Basic#enlist(short[]) */
    public static  short[] enlist( short... values ) {return Basic.enlist( values );}

    /** @see io.deephaven.function.Numeric#exp(byte) */
    public static  double exp( byte value ) {return Numeric.exp( value );}

    /** @see io.deephaven.function.Numeric#exp(double) */
    public static  double exp( double value ) {return Numeric.exp( value );}

    /** @see io.deephaven.function.Numeric#exp(float) */
    public static  double exp( float value ) {return Numeric.exp( value );}

    /** @see io.deephaven.function.Numeric#exp(int) */
    public static  double exp( int value ) {return Numeric.exp( value );}

    /** @see io.deephaven.function.Numeric#exp(long) */
    public static  double exp( long value ) {return Numeric.exp( value );}

    /** @see io.deephaven.function.Numeric#exp(short) */
    public static  double exp( short value ) {return Numeric.exp( value );}

    /** @see io.deephaven.function.Basic#first(byte[]) */
    public static  byte first( byte... values ) {return Basic.first( values );}

    /** @see io.deephaven.function.Basic#first(char[]) */
    public static  char first( char... values ) {return Basic.first( values );}

    /** @see io.deephaven.function.Basic#first(double[]) */
    public static  double first( double... values ) {return Basic.first( values );}

    /** @see io.deephaven.function.Basic#first(float[]) */
    public static  float first( float... values ) {return Basic.first( values );}

    /** @see io.deephaven.function.Basic#first(int[]) */
    public static  int first( int... values ) {return Basic.first( values );}

    /** @see io.deephaven.function.Basic#first(long[]) */
    public static  long first( long... values ) {return Basic.first( values );}

    /** @see io.deephaven.function.Basic#first(short[]) */
    public static  short first( short... values ) {return Basic.first( values );}

    /** @see io.deephaven.function.Basic#first(io.deephaven.vector.ByteVector) */
    public static  byte first( io.deephaven.vector.ByteVector values ) {return Basic.first( values );}

    /** @see io.deephaven.function.Basic#first(io.deephaven.vector.CharVector) */
    public static  char first( io.deephaven.vector.CharVector values ) {return Basic.first( values );}

    /** @see io.deephaven.function.Basic#first(io.deephaven.vector.DoubleVector) */
    public static  double first( io.deephaven.vector.DoubleVector values ) {return Basic.first( values );}

    /** @see io.deephaven.function.Basic#first(io.deephaven.vector.FloatVector) */
    public static  float first( io.deephaven.vector.FloatVector values ) {return Basic.first( values );}

    /** @see io.deephaven.function.Basic#first(io.deephaven.vector.IntVector) */
    public static  int first( io.deephaven.vector.IntVector values ) {return Basic.first( values );}

    /** @see io.deephaven.function.Basic#first(io.deephaven.vector.LongVector) */
    public static  long first( io.deephaven.vector.LongVector values ) {return Basic.first( values );}

    /** @see io.deephaven.function.Basic#first(io.deephaven.vector.ShortVector) */
    public static  short first( io.deephaven.vector.ShortVector values ) {return Basic.first( values );}

    /** @see io.deephaven.function.Basic#firstIndexOf(byte,byte[]) */
    public static  long firstIndexOf( byte val, byte... values ) {return Basic.firstIndexOf( val, values );}

    /** @see io.deephaven.function.Basic#firstIndexOf(byte,io.deephaven.vector.ByteVector) */
    public static  long firstIndexOf( byte val, io.deephaven.vector.ByteVector values ) {return Basic.firstIndexOf( val, values );}

    /** @see io.deephaven.function.Basic#firstIndexOf(char,char[]) */
    public static  long firstIndexOf( char val, char... values ) {return Basic.firstIndexOf( val, values );}

    /** @see io.deephaven.function.Basic#firstIndexOf(char,io.deephaven.vector.CharVector) */
    public static  long firstIndexOf( char val, io.deephaven.vector.CharVector values ) {return Basic.firstIndexOf( val, values );}

    /** @see io.deephaven.function.Basic#firstIndexOf(double,double[]) */
    public static  long firstIndexOf( double val, double... values ) {return Basic.firstIndexOf( val, values );}

    /** @see io.deephaven.function.Basic#firstIndexOf(double,io.deephaven.vector.DoubleVector) */
    public static  long firstIndexOf( double val, io.deephaven.vector.DoubleVector values ) {return Basic.firstIndexOf( val, values );}

    /** @see io.deephaven.function.Basic#firstIndexOf(float,float[]) */
    public static  long firstIndexOf( float val, float... values ) {return Basic.firstIndexOf( val, values );}

    /** @see io.deephaven.function.Basic#firstIndexOf(float,io.deephaven.vector.FloatVector) */
    public static  long firstIndexOf( float val, io.deephaven.vector.FloatVector values ) {return Basic.firstIndexOf( val, values );}

    /** @see io.deephaven.function.Basic#firstIndexOf(int,int[]) */
    public static  long firstIndexOf( int val, int... values ) {return Basic.firstIndexOf( val, values );}

    /** @see io.deephaven.function.Basic#firstIndexOf(int,io.deephaven.vector.IntVector) */
    public static  long firstIndexOf( int val, io.deephaven.vector.IntVector values ) {return Basic.firstIndexOf( val, values );}

    /** @see io.deephaven.function.Basic#firstIndexOf(long,long[]) */
    public static  long firstIndexOf( long val, long... values ) {return Basic.firstIndexOf( val, values );}

    /** @see io.deephaven.function.Basic#firstIndexOf(long,io.deephaven.vector.LongVector) */
    public static  long firstIndexOf( long val, io.deephaven.vector.LongVector values ) {return Basic.firstIndexOf( val, values );}

    /** @see io.deephaven.function.Basic#firstIndexOf(short,short[]) */
    public static  long firstIndexOf( short val, short... values ) {return Basic.firstIndexOf( val, values );}

    /** @see io.deephaven.function.Basic#firstIndexOf(short,io.deephaven.vector.ShortVector) */
    public static  long firstIndexOf( short val, io.deephaven.vector.ShortVector values ) {return Basic.firstIndexOf( val, values );}

    /** @see io.deephaven.function.Basic#firstIndexOfObj(java.lang.Object,java.lang.Object[]) */
    public static  long firstIndexOfObj( T val, T... values ) {return Basic.firstIndexOfObj( val, values );}

    /** @see io.deephaven.function.Basic#firstIndexOfObj(java.lang.Object,io.deephaven.vector.ObjectVector) */
    public static  long firstIndexOfObj( T val, io.deephaven.vector.ObjectVector values ) {return Basic.firstIndexOfObj( val, values );}

    /** @see io.deephaven.function.Basic#firstObj(java.lang.Object[]) */
    public static  T firstObj( T... values ) {return Basic.firstObj( values );}

    /** @see io.deephaven.function.Basic#firstObj(io.deephaven.vector.ObjectVector) */
    public static  T firstObj( io.deephaven.vector.ObjectVector values ) {return Basic.firstObj( values );}

    /** @see io.deephaven.function.Numeric#floor(byte) */
    public static  double floor( byte value ) {return Numeric.floor( value );}

    /** @see io.deephaven.function.Numeric#floor(double) */
    public static  double floor( double value ) {return Numeric.floor( value );}

    /** @see io.deephaven.function.Numeric#floor(float) */
    public static  double floor( float value ) {return Numeric.floor( value );}

    /** @see io.deephaven.function.Numeric#floor(int) */
    public static  double floor( int value ) {return Numeric.floor( value );}

    /** @see io.deephaven.function.Numeric#floor(long) */
    public static  double floor( long value ) {return Numeric.floor( value );}

    /** @see io.deephaven.function.Numeric#floor(short) */
    public static  double floor( short value ) {return Numeric.floor( value );}

    /** @see io.deephaven.function.Basic#forwardFill(byte[]) */
    public static  byte[] forwardFill( byte... values ) {return Basic.forwardFill( values );}

    /** @see io.deephaven.function.Basic#forwardFill(char[]) */
    public static  char[] forwardFill( char... values ) {return Basic.forwardFill( values );}

    /** @see io.deephaven.function.Basic#forwardFill(double[]) */
    public static  double[] forwardFill( double... values ) {return Basic.forwardFill( values );}

    /** @see io.deephaven.function.Basic#forwardFill(float[]) */
    public static  float[] forwardFill( float... values ) {return Basic.forwardFill( values );}

    /** @see io.deephaven.function.Basic#forwardFill(int[]) */
    public static  int[] forwardFill( int... values ) {return Basic.forwardFill( values );}

    /** @see io.deephaven.function.Basic#forwardFill(long[]) */
    public static  long[] forwardFill( long... values ) {return Basic.forwardFill( values );}

    /** @see io.deephaven.function.Basic#forwardFill(short[]) */
    public static  short[] forwardFill( short... values ) {return Basic.forwardFill( values );}

    /** @see io.deephaven.function.Basic#forwardFill(io.deephaven.vector.ByteVector) */
    public static  byte[] forwardFill( io.deephaven.vector.ByteVector values ) {return Basic.forwardFill( values );}

    /** @see io.deephaven.function.Basic#forwardFill(io.deephaven.vector.CharVector) */
    public static  char[] forwardFill( io.deephaven.vector.CharVector values ) {return Basic.forwardFill( values );}

    /** @see io.deephaven.function.Basic#forwardFill(io.deephaven.vector.DoubleVector) */
    public static  double[] forwardFill( io.deephaven.vector.DoubleVector values ) {return Basic.forwardFill( values );}

    /** @see io.deephaven.function.Basic#forwardFill(io.deephaven.vector.FloatVector) */
    public static  float[] forwardFill( io.deephaven.vector.FloatVector values ) {return Basic.forwardFill( values );}

    /** @see io.deephaven.function.Basic#forwardFill(io.deephaven.vector.IntVector) */
    public static  int[] forwardFill( io.deephaven.vector.IntVector values ) {return Basic.forwardFill( values );}

    /** @see io.deephaven.function.Basic#forwardFill(io.deephaven.vector.LongVector) */
    public static  long[] forwardFill( io.deephaven.vector.LongVector values ) {return Basic.forwardFill( values );}

    /** @see io.deephaven.function.Basic#forwardFill(io.deephaven.vector.ShortVector) */
    public static  short[] forwardFill( io.deephaven.vector.ShortVector values ) {return Basic.forwardFill( values );}

    /** @see io.deephaven.function.Basic#forwardFillObj(java.lang.Object[]) */
    public static  T[] forwardFillObj( T... values ) {return Basic.forwardFillObj( values );}

    /** @see io.deephaven.function.Basic#forwardFillObj(io.deephaven.vector.ObjectVector) */
    public static  T[] forwardFillObj( io.deephaven.vector.ObjectVector values ) {return Basic.forwardFillObj( values );}

    /** @see io.deephaven.function.Basic#ifelse(java.lang.Boolean[],byte,byte) */
    public static  byte[] ifelse( java.lang.Boolean[] condition, byte trueCase, byte falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(java.lang.Boolean[],char,char) */
    public static  char[] ifelse( java.lang.Boolean[] condition, char trueCase, char falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(java.lang.Boolean[],byte[],byte[]) */
    public static  byte[] ifelse( java.lang.Boolean[] condition, byte[] trueCase, byte[] falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(java.lang.Boolean[],char[],char[]) */
    public static  char[] ifelse( java.lang.Boolean[] condition, char[] trueCase, char[] falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(java.lang.Boolean[],double[],double[]) */
    public static  double[] ifelse( java.lang.Boolean[] condition, double[] trueCase, double[] falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(java.lang.Boolean[],float[],float[]) */
    public static  float[] ifelse( java.lang.Boolean[] condition, float[] trueCase, float[] falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(java.lang.Boolean[],int[],int[]) */
    public static  int[] ifelse( java.lang.Boolean[] condition, int[] trueCase, int[] falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(java.lang.Boolean[],long[],long[]) */
    public static  long[] ifelse( java.lang.Boolean[] condition, long[] trueCase, long[] falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(java.lang.Boolean[],short[],short[]) */
    public static  short[] ifelse( java.lang.Boolean[] condition, short[] trueCase, short[] falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(java.lang.Boolean[],double,double) */
    public static  double[] ifelse( java.lang.Boolean[] condition, double trueCase, double falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(java.lang.Boolean[],float,float) */
    public static  float[] ifelse( java.lang.Boolean[] condition, float trueCase, float falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(java.lang.Boolean[],int,int) */
    public static  int[] ifelse( java.lang.Boolean[] condition, int trueCase, int falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(java.lang.Boolean[],long,long) */
    public static  long[] ifelse( java.lang.Boolean[] condition, long trueCase, long falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(java.lang.Boolean[],short,short) */
    public static  short[] ifelse( java.lang.Boolean[] condition, short trueCase, short falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(java.lang.Boolean,byte,byte) */
    public static  byte ifelse( java.lang.Boolean condition, byte trueCase, byte falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(java.lang.Boolean,char,char) */
    public static  char ifelse( java.lang.Boolean condition, char trueCase, char falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(java.lang.Boolean,double,double) */
    public static  double ifelse( java.lang.Boolean condition, double trueCase, double falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(java.lang.Boolean,float,float) */
    public static  float ifelse( java.lang.Boolean condition, float trueCase, float falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(java.lang.Boolean,int,int) */
    public static  int ifelse( java.lang.Boolean condition, int trueCase, int falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(java.lang.Boolean,long,long) */
    public static  long ifelse( java.lang.Boolean condition, long trueCase, long falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(java.lang.Boolean,short,short) */
    public static  short ifelse( java.lang.Boolean condition, short trueCase, short falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(io.deephaven.vector.ObjectVector,byte,byte) */
    public static  byte[] ifelse( io.deephaven.vector.ObjectVector condition, byte trueCase, byte falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(io.deephaven.vector.ObjectVector,char,char) */
    public static  char[] ifelse( io.deephaven.vector.ObjectVector condition, char trueCase, char falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(io.deephaven.vector.ObjectVector,double,double) */
    public static  double[] ifelse( io.deephaven.vector.ObjectVector condition, double trueCase, double falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(io.deephaven.vector.ObjectVector,float,float) */
    public static  float[] ifelse( io.deephaven.vector.ObjectVector condition, float trueCase, float falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(io.deephaven.vector.ObjectVector,int,int) */
    public static  int[] ifelse( io.deephaven.vector.ObjectVector condition, int trueCase, int falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(io.deephaven.vector.ObjectVector,io.deephaven.vector.ByteVector,io.deephaven.vector.ByteVector) */
    public static  byte[] ifelse( io.deephaven.vector.ObjectVector condition, io.deephaven.vector.ByteVector trueCase, io.deephaven.vector.ByteVector falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(io.deephaven.vector.ObjectVector,io.deephaven.vector.CharVector,io.deephaven.vector.CharVector) */
    public static  char[] ifelse( io.deephaven.vector.ObjectVector condition, io.deephaven.vector.CharVector trueCase, io.deephaven.vector.CharVector falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(io.deephaven.vector.ObjectVector,io.deephaven.vector.DoubleVector,io.deephaven.vector.DoubleVector) */
    public static  double[] ifelse( io.deephaven.vector.ObjectVector condition, io.deephaven.vector.DoubleVector trueCase, io.deephaven.vector.DoubleVector falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(io.deephaven.vector.ObjectVector,io.deephaven.vector.FloatVector,io.deephaven.vector.FloatVector) */
    public static  float[] ifelse( io.deephaven.vector.ObjectVector condition, io.deephaven.vector.FloatVector trueCase, io.deephaven.vector.FloatVector falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(io.deephaven.vector.ObjectVector,io.deephaven.vector.IntVector,io.deephaven.vector.IntVector) */
    public static  int[] ifelse( io.deephaven.vector.ObjectVector condition, io.deephaven.vector.IntVector trueCase, io.deephaven.vector.IntVector falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(io.deephaven.vector.ObjectVector,io.deephaven.vector.LongVector,io.deephaven.vector.LongVector) */
    public static  long[] ifelse( io.deephaven.vector.ObjectVector condition, io.deephaven.vector.LongVector trueCase, io.deephaven.vector.LongVector falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(io.deephaven.vector.ObjectVector,io.deephaven.vector.ShortVector,io.deephaven.vector.ShortVector) */
    public static  short[] ifelse( io.deephaven.vector.ObjectVector condition, io.deephaven.vector.ShortVector trueCase, io.deephaven.vector.ShortVector falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(io.deephaven.vector.ObjectVector,long,long) */
    public static  long[] ifelse( io.deephaven.vector.ObjectVector condition, long trueCase, long falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelse(io.deephaven.vector.ObjectVector,short,short) */
    public static  short[] ifelse( io.deephaven.vector.ObjectVector condition, short trueCase, short falseCase ) {return Basic.ifelse( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelseObj(java.lang.Boolean[],java.lang.Object,java.lang.Object) */
    public static  T[] ifelseObj( java.lang.Boolean[] condition, T trueCase, T falseCase ) {return Basic.ifelseObj( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelseObj(java.lang.Boolean[],java.lang.Object[],java.lang.Object[]) */
    public static  T[] ifelseObj( java.lang.Boolean[] condition, T[] trueCase, T[] falseCase ) {return Basic.ifelseObj( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelseObj(java.lang.Boolean,java.lang.Object,java.lang.Object) */
    public static  T ifelseObj( java.lang.Boolean condition, T trueCase, T falseCase ) {return Basic.ifelseObj( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelseObj(io.deephaven.vector.ObjectVector,java.lang.Object,java.lang.Object) */
    public static  T[] ifelseObj( io.deephaven.vector.ObjectVector condition, T trueCase, T falseCase ) {return Basic.ifelseObj( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#ifelseObj(io.deephaven.vector.ObjectVector,io.deephaven.vector.ObjectVector,io.deephaven.vector.ObjectVector) */
    public static  T[] ifelseObj( io.deephaven.vector.ObjectVector condition, io.deephaven.vector.ObjectVector trueCase, io.deephaven.vector.ObjectVector falseCase ) {return Basic.ifelseObj( condition, trueCase, falseCase );}

    /** @see io.deephaven.function.Basic#in(byte,byte[]) */
    public static  boolean in( byte testedValues, byte... possibleValues ) {return Basic.in( testedValues, possibleValues );}

    /** @see io.deephaven.function.Basic#in(char,char[]) */
    public static  boolean in( char testedValues, char... possibleValues ) {return Basic.in( testedValues, possibleValues );}

    /** @see io.deephaven.function.Basic#in(double,double[]) */
    public static  boolean in( double testedValues, double... possibleValues ) {return Basic.in( testedValues, possibleValues );}

    /** @see io.deephaven.function.Basic#in(float,float[]) */
    public static  boolean in( float testedValues, float... possibleValues ) {return Basic.in( testedValues, possibleValues );}

    /** @see io.deephaven.function.Basic#in(int,int[]) */
    public static  boolean in( int testedValues, int... possibleValues ) {return Basic.in( testedValues, possibleValues );}

    /** @see io.deephaven.function.Basic#in(long,long[]) */
    public static  boolean in( long testedValues, long... possibleValues ) {return Basic.in( testedValues, possibleValues );}

    /** @see io.deephaven.function.Basic#in(short,short[]) */
    public static  boolean in( short testedValues, short... possibleValues ) {return Basic.in( testedValues, possibleValues );}

    /** @see io.deephaven.function.Basic#inObj(java.lang.Object,java.lang.Object[]) */
    public static  boolean inObj( T testedValue, T... possibleValues ) {return Basic.inObj( testedValue, possibleValues );}

    /** @see io.deephaven.function.Basic#inObj(java.lang.Object,io.deephaven.vector.ObjectVector) */
    public static  boolean inObj( T testedValue, io.deephaven.vector.ObjectVector possibleValues ) {return Basic.inObj( testedValue, possibleValues );}

    /** @see io.deephaven.function.Basic#inRange(java.lang.Comparable,java.lang.Comparable,java.lang.Comparable) */
    public static > boolean inRange( T testedValue, T lowInclusiveValue, T highInclusiveValue ) {return Basic.inRange( testedValue, lowInclusiveValue, highInclusiveValue );}

    /** @see io.deephaven.function.Basic#inRange(byte,byte,byte) */
    public static  boolean inRange( byte testedValue, byte lowInclusiveValue, byte highInclusiveValue ) {return Basic.inRange( testedValue, lowInclusiveValue, highInclusiveValue );}

    /** @see io.deephaven.function.Basic#inRange(char,char,char) */
    public static  boolean inRange( char testedValue, char lowInclusiveValue, char highInclusiveValue ) {return Basic.inRange( testedValue, lowInclusiveValue, highInclusiveValue );}

    /** @see io.deephaven.function.Basic#inRange(double,double,double) */
    public static  boolean inRange( double testedValue, double lowInclusiveValue, double highInclusiveValue ) {return Basic.inRange( testedValue, lowInclusiveValue, highInclusiveValue );}

    /** @see io.deephaven.function.Basic#inRange(float,float,float) */
    public static  boolean inRange( float testedValue, float lowInclusiveValue, float highInclusiveValue ) {return Basic.inRange( testedValue, lowInclusiveValue, highInclusiveValue );}

    /** @see io.deephaven.function.Basic#inRange(int,int,int) */
    public static  boolean inRange( int testedValue, int lowInclusiveValue, int highInclusiveValue ) {return Basic.inRange( testedValue, lowInclusiveValue, highInclusiveValue );}

    /** @see io.deephaven.function.Basic#inRange(long,long,long) */
    public static  boolean inRange( long testedValue, long lowInclusiveValue, long highInclusiveValue ) {return Basic.inRange( testedValue, lowInclusiveValue, highInclusiveValue );}

    /** @see io.deephaven.function.Basic#inRange(short,short,short) */
    public static  boolean inRange( short testedValue, short lowInclusiveValue, short highInclusiveValue ) {return Basic.inRange( testedValue, lowInclusiveValue, highInclusiveValue );}

    /** @see io.deephaven.function.Numeric#indexOfMax(byte[]) */
    public static  long indexOfMax( byte... values ) {return Numeric.indexOfMax( values );}

    /** @see io.deephaven.function.Numeric#indexOfMax(double[]) */
    public static  long indexOfMax( double... values ) {return Numeric.indexOfMax( values );}

    /** @see io.deephaven.function.Numeric#indexOfMax(float[]) */
    public static  long indexOfMax( float... values ) {return Numeric.indexOfMax( values );}

    /** @see io.deephaven.function.Numeric#indexOfMax(int[]) */
    public static  long indexOfMax( int... values ) {return Numeric.indexOfMax( values );}

    /** @see io.deephaven.function.Numeric#indexOfMax(long[]) */
    public static  long indexOfMax( long... values ) {return Numeric.indexOfMax( values );}

    /** @see io.deephaven.function.Numeric#indexOfMax(java.lang.Byte[]) */
    public static  long indexOfMax( java.lang.Byte[] values ) {return Numeric.indexOfMax( values );}

    /** @see io.deephaven.function.Numeric#indexOfMax(java.lang.Double[]) */
    public static  long indexOfMax( java.lang.Double[] values ) {return Numeric.indexOfMax( values );}

    /** @see io.deephaven.function.Numeric#indexOfMax(java.lang.Float[]) */
    public static  long indexOfMax( java.lang.Float[] values ) {return Numeric.indexOfMax( values );}

    /** @see io.deephaven.function.Numeric#indexOfMax(java.lang.Integer[]) */
    public static  long indexOfMax( java.lang.Integer[] values ) {return Numeric.indexOfMax( values );}

    /** @see io.deephaven.function.Numeric#indexOfMax(java.lang.Long[]) */
    public static  long indexOfMax( java.lang.Long[] values ) {return Numeric.indexOfMax( values );}

    /** @see io.deephaven.function.Numeric#indexOfMax(java.lang.Short[]) */
    public static  long indexOfMax( java.lang.Short[] values ) {return Numeric.indexOfMax( values );}

    /** @see io.deephaven.function.Numeric#indexOfMax(short[]) */
    public static  long indexOfMax( short... values ) {return Numeric.indexOfMax( values );}

    /** @see io.deephaven.function.Numeric#indexOfMax(io.deephaven.vector.ByteVector) */
    public static  long indexOfMax( io.deephaven.vector.ByteVector values ) {return Numeric.indexOfMax( values );}

    /** @see io.deephaven.function.Numeric#indexOfMax(io.deephaven.vector.DoubleVector) */
    public static  long indexOfMax( io.deephaven.vector.DoubleVector values ) {return Numeric.indexOfMax( values );}

    /** @see io.deephaven.function.Numeric#indexOfMax(io.deephaven.vector.FloatVector) */
    public static  long indexOfMax( io.deephaven.vector.FloatVector values ) {return Numeric.indexOfMax( values );}

    /** @see io.deephaven.function.Numeric#indexOfMax(io.deephaven.vector.IntVector) */
    public static  long indexOfMax( io.deephaven.vector.IntVector values ) {return Numeric.indexOfMax( values );}

    /** @see io.deephaven.function.Numeric#indexOfMax(io.deephaven.vector.LongVector) */
    public static  long indexOfMax( io.deephaven.vector.LongVector values ) {return Numeric.indexOfMax( values );}

    /** @see io.deephaven.function.Numeric#indexOfMax(io.deephaven.vector.ShortVector) */
    public static  long indexOfMax( io.deephaven.vector.ShortVector values ) {return Numeric.indexOfMax( values );}

    /** @see io.deephaven.function.Numeric#indexOfMaxObj(java.lang.Comparable[]) */
    public static > long indexOfMaxObj( T... values ) {return Numeric.indexOfMaxObj( values );}

    /** @see io.deephaven.function.Numeric#indexOfMaxObj(io.deephaven.vector.ObjectVector) */
    public static > long indexOfMaxObj( io.deephaven.vector.ObjectVector values ) {return Numeric.indexOfMaxObj( values );}

    /** @see io.deephaven.function.Numeric#indexOfMin(byte[]) */
    public static  long indexOfMin( byte... values ) {return Numeric.indexOfMin( values );}

    /** @see io.deephaven.function.Numeric#indexOfMin(double[]) */
    public static  long indexOfMin( double... values ) {return Numeric.indexOfMin( values );}

    /** @see io.deephaven.function.Numeric#indexOfMin(float[]) */
    public static  long indexOfMin( float... values ) {return Numeric.indexOfMin( values );}

    /** @see io.deephaven.function.Numeric#indexOfMin(int[]) */
    public static  long indexOfMin( int... values ) {return Numeric.indexOfMin( values );}

    /** @see io.deephaven.function.Numeric#indexOfMin(long[]) */
    public static  long indexOfMin( long... values ) {return Numeric.indexOfMin( values );}

    /** @see io.deephaven.function.Numeric#indexOfMin(java.lang.Byte[]) */
    public static  long indexOfMin( java.lang.Byte[] values ) {return Numeric.indexOfMin( values );}

    /** @see io.deephaven.function.Numeric#indexOfMin(java.lang.Double[]) */
    public static  long indexOfMin( java.lang.Double[] values ) {return Numeric.indexOfMin( values );}

    /** @see io.deephaven.function.Numeric#indexOfMin(java.lang.Float[]) */
    public static  long indexOfMin( java.lang.Float[] values ) {return Numeric.indexOfMin( values );}

    /** @see io.deephaven.function.Numeric#indexOfMin(java.lang.Integer[]) */
    public static  long indexOfMin( java.lang.Integer[] values ) {return Numeric.indexOfMin( values );}

    /** @see io.deephaven.function.Numeric#indexOfMin(java.lang.Long[]) */
    public static  long indexOfMin( java.lang.Long[] values ) {return Numeric.indexOfMin( values );}

    /** @see io.deephaven.function.Numeric#indexOfMin(java.lang.Short[]) */
    public static  long indexOfMin( java.lang.Short[] values ) {return Numeric.indexOfMin( values );}

    /** @see io.deephaven.function.Numeric#indexOfMin(short[]) */
    public static  long indexOfMin( short... values ) {return Numeric.indexOfMin( values );}

    /** @see io.deephaven.function.Numeric#indexOfMin(io.deephaven.vector.ByteVector) */
    public static  long indexOfMin( io.deephaven.vector.ByteVector values ) {return Numeric.indexOfMin( values );}

    /** @see io.deephaven.function.Numeric#indexOfMin(io.deephaven.vector.DoubleVector) */
    public static  long indexOfMin( io.deephaven.vector.DoubleVector values ) {return Numeric.indexOfMin( values );}

    /** @see io.deephaven.function.Numeric#indexOfMin(io.deephaven.vector.FloatVector) */
    public static  long indexOfMin( io.deephaven.vector.FloatVector values ) {return Numeric.indexOfMin( values );}

    /** @see io.deephaven.function.Numeric#indexOfMin(io.deephaven.vector.IntVector) */
    public static  long indexOfMin( io.deephaven.vector.IntVector values ) {return Numeric.indexOfMin( values );}

    /** @see io.deephaven.function.Numeric#indexOfMin(io.deephaven.vector.LongVector) */
    public static  long indexOfMin( io.deephaven.vector.LongVector values ) {return Numeric.indexOfMin( values );}

    /** @see io.deephaven.function.Numeric#indexOfMin(io.deephaven.vector.ShortVector) */
    public static  long indexOfMin( io.deephaven.vector.ShortVector values ) {return Numeric.indexOfMin( values );}

    /** @see io.deephaven.function.Numeric#indexOfMinObj(java.lang.Comparable[]) */
    public static > long indexOfMinObj( T... values ) {return Numeric.indexOfMinObj( values );}

    /** @see io.deephaven.function.Numeric#indexOfMinObj(io.deephaven.vector.ObjectVector) */
    public static > long indexOfMinObj( io.deephaven.vector.ObjectVector values ) {return Numeric.indexOfMinObj( values );}

    /** @see io.deephaven.function.Numeric#isFinite(byte) */
    public static  boolean isFinite( byte value ) {return Numeric.isFinite( value );}

    /** @see io.deephaven.function.Numeric#isFinite(java.lang.Byte) */
    public static  boolean isFinite( java.lang.Byte value ) {return Numeric.isFinite( value );}

    /** @see io.deephaven.function.Numeric#isFinite(java.lang.Double) */
    public static  boolean isFinite( java.lang.Double value ) {return Numeric.isFinite( value );}

    /** @see io.deephaven.function.Numeric#isFinite(java.lang.Float) */
    public static  boolean isFinite( java.lang.Float value ) {return Numeric.isFinite( value );}

    /** @see io.deephaven.function.Numeric#isFinite(java.lang.Integer) */
    public static  boolean isFinite( java.lang.Integer value ) {return Numeric.isFinite( value );}

    /** @see io.deephaven.function.Numeric#isFinite(java.lang.Long) */
    public static  boolean isFinite( java.lang.Long value ) {return Numeric.isFinite( value );}

    /** @see io.deephaven.function.Numeric#isFinite(java.lang.Short) */
    public static  boolean isFinite( java.lang.Short value ) {return Numeric.isFinite( value );}

    /** @see io.deephaven.function.Numeric#isFinite(double) */
    public static  boolean isFinite( double value ) {return Numeric.isFinite( value );}

    /** @see io.deephaven.function.Numeric#isFinite(float) */
    public static  boolean isFinite( float value ) {return Numeric.isFinite( value );}

    /** @see io.deephaven.function.Numeric#isFinite(int) */
    public static  boolean isFinite( int value ) {return Numeric.isFinite( value );}

    /** @see io.deephaven.function.Numeric#isFinite(long) */
    public static  boolean isFinite( long value ) {return Numeric.isFinite( value );}

    /** @see io.deephaven.function.Numeric#isFinite(short) */
    public static  boolean isFinite( short value ) {return Numeric.isFinite( value );}

    /** @see io.deephaven.function.Numeric#isInf(byte) */
    public static  boolean isInf( byte value ) {return Numeric.isInf( value );}

    /** @see io.deephaven.function.Numeric#isInf(java.lang.Byte) */
    public static  boolean isInf( java.lang.Byte value ) {return Numeric.isInf( value );}

    /** @see io.deephaven.function.Numeric#isInf(java.lang.Double) */
    public static  boolean isInf( java.lang.Double value ) {return Numeric.isInf( value );}

    /** @see io.deephaven.function.Numeric#isInf(java.lang.Float) */
    public static  boolean isInf( java.lang.Float value ) {return Numeric.isInf( value );}

    /** @see io.deephaven.function.Numeric#isInf(java.lang.Integer) */
    public static  boolean isInf( java.lang.Integer value ) {return Numeric.isInf( value );}

    /** @see io.deephaven.function.Numeric#isInf(java.lang.Long) */
    public static  boolean isInf( java.lang.Long value ) {return Numeric.isInf( value );}

    /** @see io.deephaven.function.Numeric#isInf(java.lang.Short) */
    public static  boolean isInf( java.lang.Short value ) {return Numeric.isInf( value );}

    /** @see io.deephaven.function.Numeric#isInf(double) */
    public static  boolean isInf( double value ) {return Numeric.isInf( value );}

    /** @see io.deephaven.function.Numeric#isInf(float) */
    public static  boolean isInf( float value ) {return Numeric.isInf( value );}

    /** @see io.deephaven.function.Numeric#isInf(int) */
    public static  boolean isInf( int value ) {return Numeric.isInf( value );}

    /** @see io.deephaven.function.Numeric#isInf(long) */
    public static  boolean isInf( long value ) {return Numeric.isInf( value );}

    /** @see io.deephaven.function.Numeric#isInf(short) */
    public static  boolean isInf( short value ) {return Numeric.isInf( value );}

    /** @see io.deephaven.function.Numeric#isNaN(byte) */
    public static  boolean isNaN( byte value ) {return Numeric.isNaN( value );}

    /** @see io.deephaven.function.Numeric#isNaN(java.lang.Byte) */
    public static  boolean isNaN( java.lang.Byte value ) {return Numeric.isNaN( value );}

    /** @see io.deephaven.function.Numeric#isNaN(java.lang.Double) */
    public static  boolean isNaN( java.lang.Double value ) {return Numeric.isNaN( value );}

    /** @see io.deephaven.function.Numeric#isNaN(java.lang.Float) */
    public static  boolean isNaN( java.lang.Float value ) {return Numeric.isNaN( value );}

    /** @see io.deephaven.function.Numeric#isNaN(java.lang.Integer) */
    public static  boolean isNaN( java.lang.Integer value ) {return Numeric.isNaN( value );}

    /** @see io.deephaven.function.Numeric#isNaN(java.lang.Long) */
    public static  boolean isNaN( java.lang.Long value ) {return Numeric.isNaN( value );}

    /** @see io.deephaven.function.Numeric#isNaN(java.lang.Short) */
    public static  boolean isNaN( java.lang.Short value ) {return Numeric.isNaN( value );}

    /** @see io.deephaven.function.Numeric#isNaN(double) */
    public static  boolean isNaN( double value ) {return Numeric.isNaN( value );}

    /** @see io.deephaven.function.Numeric#isNaN(float) */
    public static  boolean isNaN( float value ) {return Numeric.isNaN( value );}

    /** @see io.deephaven.function.Numeric#isNaN(int) */
    public static  boolean isNaN( int value ) {return Numeric.isNaN( value );}

    /** @see io.deephaven.function.Numeric#isNaN(long) */
    public static  boolean isNaN( long value ) {return Numeric.isNaN( value );}

    /** @see io.deephaven.function.Numeric#isNaN(short) */
    public static  boolean isNaN( short value ) {return Numeric.isNaN( value );}

    /** @see io.deephaven.function.Basic#isNull(java.lang.Object) */
    public static  boolean isNull( T value ) {return Basic.isNull( value );}

    /** @see io.deephaven.function.Basic#isNull(byte) */
    public static  boolean isNull( byte value ) {return Basic.isNull( value );}

    /** @see io.deephaven.function.Basic#isNull(char) */
    public static  boolean isNull( char value ) {return Basic.isNull( value );}

    /** @see io.deephaven.function.Basic#isNull(double) */
    public static  boolean isNull( double value ) {return Basic.isNull( value );}

    /** @see io.deephaven.function.Basic#isNull(float) */
    public static  boolean isNull( float value ) {return Basic.isNull( value );}

    /** @see io.deephaven.function.Basic#isNull(int) */
    public static  boolean isNull( int value ) {return Basic.isNull( value );}

    /** @see io.deephaven.function.Basic#isNull(long) */
    public static  boolean isNull( long value ) {return Basic.isNull( value );}

    /** @see io.deephaven.function.Basic#isNull(short) */
    public static  boolean isNull( short value ) {return Basic.isNull( value );}

    /** @see io.deephaven.function.Basic#last(byte[]) */
    public static  byte last( byte... values ) {return Basic.last( values );}

    /** @see io.deephaven.function.Basic#last(char[]) */
    public static  char last( char... values ) {return Basic.last( values );}

    /** @see io.deephaven.function.Basic#last(double[]) */
    public static  double last( double... values ) {return Basic.last( values );}

    /** @see io.deephaven.function.Basic#last(float[]) */
    public static  float last( float... values ) {return Basic.last( values );}

    /** @see io.deephaven.function.Basic#last(int[]) */
    public static  int last( int... values ) {return Basic.last( values );}

    /** @see io.deephaven.function.Basic#last(long[]) */
    public static  long last( long... values ) {return Basic.last( values );}

    /** @see io.deephaven.function.Basic#last(short[]) */
    public static  short last( short... values ) {return Basic.last( values );}

    /** @see io.deephaven.function.Basic#last(io.deephaven.vector.ByteVector) */
    public static  byte last( io.deephaven.vector.ByteVector values ) {return Basic.last( values );}

    /** @see io.deephaven.function.Basic#last(io.deephaven.vector.CharVector) */
    public static  char last( io.deephaven.vector.CharVector values ) {return Basic.last( values );}

    /** @see io.deephaven.function.Basic#last(io.deephaven.vector.DoubleVector) */
    public static  double last( io.deephaven.vector.DoubleVector values ) {return Basic.last( values );}

    /** @see io.deephaven.function.Basic#last(io.deephaven.vector.FloatVector) */
    public static  float last( io.deephaven.vector.FloatVector values ) {return Basic.last( values );}

    /** @see io.deephaven.function.Basic#last(io.deephaven.vector.IntVector) */
    public static  int last( io.deephaven.vector.IntVector values ) {return Basic.last( values );}

    /** @see io.deephaven.function.Basic#last(io.deephaven.vector.LongVector) */
    public static  long last( io.deephaven.vector.LongVector values ) {return Basic.last( values );}

    /** @see io.deephaven.function.Basic#last(io.deephaven.vector.ShortVector) */
    public static  short last( io.deephaven.vector.ShortVector values ) {return Basic.last( values );}

    /** @see io.deephaven.function.Basic#lastObj(java.lang.Object[]) */
    public static  T lastObj( T... values ) {return Basic.lastObj( values );}

    /** @see io.deephaven.function.Basic#lastObj(io.deephaven.vector.ObjectVector) */
    public static  T lastObj( io.deephaven.vector.ObjectVector values ) {return Basic.lastObj( values );}

    /** @see io.deephaven.function.Basic#len(java.lang.Object[]) */
    public static  long len( T[] values ) {return Basic.len( values );}

    /** @see io.deephaven.function.Basic#len(byte[]) */
    public static  long len( byte[] values ) {return Basic.len( values );}

    /** @see io.deephaven.function.Basic#len(char[]) */
    public static  long len( char[] values ) {return Basic.len( values );}

    /** @see io.deephaven.function.Basic#len(double[]) */
    public static  long len( double[] values ) {return Basic.len( values );}

    /** @see io.deephaven.function.Basic#len(float[]) */
    public static  long len( float[] values ) {return Basic.len( values );}

    /** @see io.deephaven.function.Basic#len(int[]) */
    public static  long len( int[] values ) {return Basic.len( values );}

    /** @see io.deephaven.function.Basic#len(long[]) */
    public static  long len( long[] values ) {return Basic.len( values );}

    /** @see io.deephaven.function.Basic#len(short[]) */
    public static  long len( short[] values ) {return Basic.len( values );}

    /** @see io.deephaven.function.Basic#len(io.deephaven.util.datastructures.LongSizedDataStructure) */
    public static  long len( io.deephaven.util.datastructures.LongSizedDataStructure values ) {return Basic.len( values );}

    /** @see io.deephaven.function.Numeric#log(byte) */
    public static  double log( byte value ) {return Numeric.log( value );}

    /** @see io.deephaven.function.Numeric#log(double) */
    public static  double log( double value ) {return Numeric.log( value );}

    /** @see io.deephaven.function.Numeric#log(float) */
    public static  double log( float value ) {return Numeric.log( value );}

    /** @see io.deephaven.function.Numeric#log(int) */
    public static  double log( int value ) {return Numeric.log( value );}

    /** @see io.deephaven.function.Numeric#log(long) */
    public static  double log( long value ) {return Numeric.log( value );}

    /** @see io.deephaven.function.Numeric#log(short) */
    public static  double log( short value ) {return Numeric.log( value );}

    /** @see io.deephaven.function.Numeric#lowerBin(byte,byte) */
    public static  byte lowerBin( byte value, byte interval ) {return Numeric.lowerBin( value, interval );}

    /** @see io.deephaven.function.Numeric#lowerBin(double,double) */
    public static  double lowerBin( double value, double interval ) {return Numeric.lowerBin( value, interval );}

    /** @see io.deephaven.function.Numeric#lowerBin(float,float) */
    public static  float lowerBin( float value, float interval ) {return Numeric.lowerBin( value, interval );}

    /** @see io.deephaven.function.Numeric#lowerBin(int,int) */
    public static  int lowerBin( int value, int interval ) {return Numeric.lowerBin( value, interval );}

    /** @see io.deephaven.function.Numeric#lowerBin(long,long) */
    public static  long lowerBin( long value, long interval ) {return Numeric.lowerBin( value, interval );}

    /** @see io.deephaven.function.Numeric#lowerBin(short,short) */
    public static  short lowerBin( short value, short interval ) {return Numeric.lowerBin( value, interval );}

    /** @see io.deephaven.function.Numeric#lowerBin(byte,byte,byte) */
    public static  byte lowerBin( byte value, byte interval, byte offset ) {return Numeric.lowerBin( value, interval, offset );}

    /** @see io.deephaven.function.Numeric#lowerBin(double,double,double) */
    public static  double lowerBin( double value, double interval, double offset ) {return Numeric.lowerBin( value, interval, offset );}

    /** @see io.deephaven.function.Numeric#lowerBin(float,float,float) */
    public static  float lowerBin( float value, float interval, float offset ) {return Numeric.lowerBin( value, interval, offset );}

    /** @see io.deephaven.function.Numeric#lowerBin(int,int,int) */
    public static  int lowerBin( int value, int interval, int offset ) {return Numeric.lowerBin( value, interval, offset );}

    /** @see io.deephaven.function.Numeric#lowerBin(long,long,long) */
    public static  long lowerBin( long value, long interval, long offset ) {return Numeric.lowerBin( value, interval, offset );}

    /** @see io.deephaven.function.Numeric#lowerBin(short,short,short) */
    public static  short lowerBin( short value, short interval, short offset ) {return Numeric.lowerBin( value, interval, offset );}

    /** @see io.deephaven.function.Numeric#max(byte[]) */
    public static  byte max( byte... values ) {return Numeric.max( values );}

    /** @see io.deephaven.function.Numeric#max(double[]) */
    public static  double max( double... values ) {return Numeric.max( values );}

    /** @see io.deephaven.function.Numeric#max(float[]) */
    public static  float max( float... values ) {return Numeric.max( values );}

    /** @see io.deephaven.function.Numeric#max(int[]) */
    public static  int max( int... values ) {return Numeric.max( values );}

    /** @see io.deephaven.function.Numeric#max(long[]) */
    public static  long max( long... values ) {return Numeric.max( values );}

    /** @see io.deephaven.function.Numeric#max(java.lang.Byte[]) */
    public static  byte max( java.lang.Byte[] values ) {return Numeric.max( values );}

    /** @see io.deephaven.function.Numeric#max(java.lang.Double[]) */
    public static  double max( java.lang.Double[] values ) {return Numeric.max( values );}

    /** @see io.deephaven.function.Numeric#max(java.lang.Float[]) */
    public static  float max( java.lang.Float[] values ) {return Numeric.max( values );}

    /** @see io.deephaven.function.Numeric#max(java.lang.Integer[]) */
    public static  int max( java.lang.Integer[] values ) {return Numeric.max( values );}

    /** @see io.deephaven.function.Numeric#max(java.lang.Long[]) */
    public static  long max( java.lang.Long[] values ) {return Numeric.max( values );}

    /** @see io.deephaven.function.Numeric#max(java.lang.Short[]) */
    public static  short max( java.lang.Short[] values ) {return Numeric.max( values );}

    /** @see io.deephaven.function.Numeric#max(short[]) */
    public static  short max( short... values ) {return Numeric.max( values );}

    /** @see io.deephaven.function.Numeric#max(io.deephaven.vector.ByteVector) */
    public static  byte max( io.deephaven.vector.ByteVector values ) {return Numeric.max( values );}

    /** @see io.deephaven.function.Numeric#max(io.deephaven.vector.DoubleVector) */
    public static  double max( io.deephaven.vector.DoubleVector values ) {return Numeric.max( values );}

    /** @see io.deephaven.function.Numeric#max(io.deephaven.vector.FloatVector) */
    public static  float max( io.deephaven.vector.FloatVector values ) {return Numeric.max( values );}

    /** @see io.deephaven.function.Numeric#max(io.deephaven.vector.IntVector) */
    public static  int max( io.deephaven.vector.IntVector values ) {return Numeric.max( values );}

    /** @see io.deephaven.function.Numeric#max(io.deephaven.vector.LongVector) */
    public static  long max( io.deephaven.vector.LongVector values ) {return Numeric.max( values );}

    /** @see io.deephaven.function.Numeric#max(io.deephaven.vector.ShortVector) */
    public static  short max( io.deephaven.vector.ShortVector values ) {return Numeric.max( values );}

    /** @see io.deephaven.function.Numeric#maxObj(java.lang.Comparable[]) */
    public static > T maxObj( T... values ) {return Numeric.maxObj( values );}

    /** @see io.deephaven.function.Numeric#maxObj(io.deephaven.vector.ObjectVector) */
    public static > T maxObj( io.deephaven.vector.ObjectVector values ) {return Numeric.maxObj( values );}

    /** @see io.deephaven.function.Numeric#median(byte[]) */
    public static  double median( byte... values ) {return Numeric.median( values );}

    /** @see io.deephaven.function.Numeric#median(double[]) */
    public static  double median( double... values ) {return Numeric.median( values );}

    /** @see io.deephaven.function.Numeric#median(float[]) */
    public static  double median( float... values ) {return Numeric.median( values );}

    /** @see io.deephaven.function.Numeric#median(int[]) */
    public static  double median( int... values ) {return Numeric.median( values );}

    /** @see io.deephaven.function.Numeric#median(long[]) */
    public static  double median( long... values ) {return Numeric.median( values );}

    /** @see io.deephaven.function.Numeric#median(java.lang.Byte[]) */
    public static  double median( java.lang.Byte[] values ) {return Numeric.median( values );}

    /** @see io.deephaven.function.Numeric#median(java.lang.Double[]) */
    public static  double median( java.lang.Double[] values ) {return Numeric.median( values );}

    /** @see io.deephaven.function.Numeric#median(java.lang.Float[]) */
    public static  double median( java.lang.Float[] values ) {return Numeric.median( values );}

    /** @see io.deephaven.function.Numeric#median(java.lang.Integer[]) */
    public static  double median( java.lang.Integer[] values ) {return Numeric.median( values );}

    /** @see io.deephaven.function.Numeric#median(java.lang.Long[]) */
    public static  double median( java.lang.Long[] values ) {return Numeric.median( values );}

    /** @see io.deephaven.function.Numeric#median(java.lang.Short[]) */
    public static  double median( java.lang.Short[] values ) {return Numeric.median( values );}

    /** @see io.deephaven.function.Numeric#median(short[]) */
    public static  double median( short... values ) {return Numeric.median( values );}

    /** @see io.deephaven.function.Numeric#median(io.deephaven.vector.ByteVector) */
    public static  double median( io.deephaven.vector.ByteVector values ) {return Numeric.median( values );}

    /** @see io.deephaven.function.Numeric#median(io.deephaven.vector.DoubleVector) */
    public static  double median( io.deephaven.vector.DoubleVector values ) {return Numeric.median( values );}

    /** @see io.deephaven.function.Numeric#median(io.deephaven.vector.FloatVector) */
    public static  double median( io.deephaven.vector.FloatVector values ) {return Numeric.median( values );}

    /** @see io.deephaven.function.Numeric#median(io.deephaven.vector.IntVector) */
    public static  double median( io.deephaven.vector.IntVector values ) {return Numeric.median( values );}

    /** @see io.deephaven.function.Numeric#median(io.deephaven.vector.LongVector) */
    public static  double median( io.deephaven.vector.LongVector values ) {return Numeric.median( values );}

    /** @see io.deephaven.function.Numeric#median(io.deephaven.vector.ShortVector) */
    public static  double median( io.deephaven.vector.ShortVector values ) {return Numeric.median( values );}

    /** @see io.deephaven.function.Numeric#min(byte[]) */
    public static  byte min( byte... values ) {return Numeric.min( values );}

    /** @see io.deephaven.function.Numeric#min(double[]) */
    public static  double min( double... values ) {return Numeric.min( values );}

    /** @see io.deephaven.function.Numeric#min(float[]) */
    public static  float min( float... values ) {return Numeric.min( values );}

    /** @see io.deephaven.function.Numeric#min(int[]) */
    public static  int min( int... values ) {return Numeric.min( values );}

    /** @see io.deephaven.function.Numeric#min(long[]) */
    public static  long min( long... values ) {return Numeric.min( values );}

    /** @see io.deephaven.function.Numeric#min(java.lang.Byte[]) */
    public static  byte min( java.lang.Byte[] values ) {return Numeric.min( values );}

    /** @see io.deephaven.function.Numeric#min(java.lang.Double[]) */
    public static  double min( java.lang.Double[] values ) {return Numeric.min( values );}

    /** @see io.deephaven.function.Numeric#min(java.lang.Float[]) */
    public static  float min( java.lang.Float[] values ) {return Numeric.min( values );}

    /** @see io.deephaven.function.Numeric#min(java.lang.Integer[]) */
    public static  int min( java.lang.Integer[] values ) {return Numeric.min( values );}

    /** @see io.deephaven.function.Numeric#min(java.lang.Long[]) */
    public static  long min( java.lang.Long[] values ) {return Numeric.min( values );}

    /** @see io.deephaven.function.Numeric#min(java.lang.Short[]) */
    public static  short min( java.lang.Short[] values ) {return Numeric.min( values );}

    /** @see io.deephaven.function.Numeric#min(short[]) */
    public static  short min( short... values ) {return Numeric.min( values );}

    /** @see io.deephaven.function.Numeric#min(io.deephaven.vector.ByteVector) */
    public static  byte min( io.deephaven.vector.ByteVector values ) {return Numeric.min( values );}

    /** @see io.deephaven.function.Numeric#min(io.deephaven.vector.DoubleVector) */
    public static  double min( io.deephaven.vector.DoubleVector values ) {return Numeric.min( values );}

    /** @see io.deephaven.function.Numeric#min(io.deephaven.vector.FloatVector) */
    public static  float min( io.deephaven.vector.FloatVector values ) {return Numeric.min( values );}

    /** @see io.deephaven.function.Numeric#min(io.deephaven.vector.IntVector) */
    public static  int min( io.deephaven.vector.IntVector values ) {return Numeric.min( values );}

    /** @see io.deephaven.function.Numeric#min(io.deephaven.vector.LongVector) */
    public static  long min( io.deephaven.vector.LongVector values ) {return Numeric.min( values );}

    /** @see io.deephaven.function.Numeric#min(io.deephaven.vector.ShortVector) */
    public static  short min( io.deephaven.vector.ShortVector values ) {return Numeric.min( values );}

    /** @see io.deephaven.function.Numeric#minObj(java.lang.Comparable[]) */
    public static > T minObj( T... values ) {return Numeric.minObj( values );}

    /** @see io.deephaven.function.Numeric#minObj(io.deephaven.vector.ObjectVector) */
    public static > T minObj( io.deephaven.vector.ObjectVector values ) {return Numeric.minObj( values );}

    /** @see io.deephaven.function.Logic#not(java.lang.Boolean[]) */
    public static  java.lang.Boolean[] not( java.lang.Boolean... values ) {return Logic.not( values );}

    /** @see io.deephaven.function.Logic#not(boolean[]) */
    public static  java.lang.Boolean[] not( boolean... values ) {return Logic.not( values );}

    /** @see io.deephaven.function.Basic#nth(long,byte[]) */
    public static  byte nth( long index, byte... values ) {return Basic.nth( index, values );}

    /** @see io.deephaven.function.Basic#nth(long,char[]) */
    public static  char nth( long index, char... values ) {return Basic.nth( index, values );}

    /** @see io.deephaven.function.Basic#nth(long,double[]) */
    public static  double nth( long index, double... values ) {return Basic.nth( index, values );}

    /** @see io.deephaven.function.Basic#nth(long,float[]) */
    public static  float nth( long index, float... values ) {return Basic.nth( index, values );}

    /** @see io.deephaven.function.Basic#nth(long,int[]) */
    public static  int nth( long index, int... values ) {return Basic.nth( index, values );}

    /** @see io.deephaven.function.Basic#nth(long,long[]) */
    public static  long nth( long index, long... values ) {return Basic.nth( index, values );}

    /** @see io.deephaven.function.Basic#nth(long,short[]) */
    public static  short nth( long index, short... values ) {return Basic.nth( index, values );}

    /** @see io.deephaven.function.Basic#nth(long,io.deephaven.vector.ByteVector) */
    public static  byte nth( long index, io.deephaven.vector.ByteVector values ) {return Basic.nth( index, values );}

    /** @see io.deephaven.function.Basic#nth(long,io.deephaven.vector.CharVector) */
    public static  char nth( long index, io.deephaven.vector.CharVector values ) {return Basic.nth( index, values );}

    /** @see io.deephaven.function.Basic#nth(long,io.deephaven.vector.DoubleVector) */
    public static  double nth( long index, io.deephaven.vector.DoubleVector values ) {return Basic.nth( index, values );}

    /** @see io.deephaven.function.Basic#nth(long,io.deephaven.vector.FloatVector) */
    public static  float nth( long index, io.deephaven.vector.FloatVector values ) {return Basic.nth( index, values );}

    /** @see io.deephaven.function.Basic#nth(long,io.deephaven.vector.IntVector) */
    public static  int nth( long index, io.deephaven.vector.IntVector values ) {return Basic.nth( index, values );}

    /** @see io.deephaven.function.Basic#nth(long,io.deephaven.vector.LongVector) */
    public static  long nth( long index, io.deephaven.vector.LongVector values ) {return Basic.nth( index, values );}

    /** @see io.deephaven.function.Basic#nth(long,io.deephaven.vector.ShortVector) */
    public static  short nth( long index, io.deephaven.vector.ShortVector values ) {return Basic.nth( index, values );}

    /** @see io.deephaven.function.Basic#nthObj(long,java.lang.Object[]) */
    public static  T nthObj( long index, T... values ) {return Basic.nthObj( index, values );}

    /** @see io.deephaven.function.Basic#nthObj(long,io.deephaven.vector.ObjectVector) */
    public static  T nthObj( long index, io.deephaven.vector.ObjectVector values ) {return Basic.nthObj( index, values );}

    /** @see io.deephaven.function.Basic#nullValueFor(java.lang.Class) */
    public static  T nullValueFor( java.lang.Class clazz ) {return Basic.nullValueFor( clazz );}

    /** @see io.deephaven.function.Logic#or(java.lang.Boolean[]) */
    public static  java.lang.Boolean or( java.lang.Boolean... values ) {return Logic.or( values );}

    /** @see io.deephaven.function.Logic#or(boolean[]) */
    public static  java.lang.Boolean or( boolean... values ) {return Logic.or( values );}

    /** @see io.deephaven.function.Logic#or(java.lang.Boolean[],java.lang.Boolean) */
    public static  java.lang.Boolean or( java.lang.Boolean[] values, java.lang.Boolean nullValue ) {return Logic.or( values, nullValue );}

    /** @see io.deephaven.function.Parse#parseBoolean(java.lang.String) */
    public static  java.lang.Boolean parseBoolean( java.lang.String s ) {return Parse.parseBoolean( s );}

    /** @see io.deephaven.function.Parse#parseByte(java.lang.String) */
    public static  byte parseByte( java.lang.String s ) {return Parse.parseByte( s );}

    /** @see io.deephaven.function.Parse#parseByte(java.lang.String,int) */
    public static  byte parseByte( java.lang.String s, int radix ) {return Parse.parseByte( s, radix );}

    /** @see io.deephaven.function.Parse#parseDouble(java.lang.String) */
    public static  double parseDouble( java.lang.String s ) {return Parse.parseDouble( s );}

    /** @see io.deephaven.function.Parse#parseFloat(java.lang.String) */
    public static  float parseFloat( java.lang.String s ) {return Parse.parseFloat( s );}

    /** @see io.deephaven.function.Parse#parseInt(java.lang.String) */
    public static  int parseInt( java.lang.String s ) {return Parse.parseInt( s );}

    /** @see io.deephaven.function.Parse#parseInt(java.lang.String,int) */
    public static  int parseInt( java.lang.String s, int radix ) {return Parse.parseInt( s, radix );}

    /** @see io.deephaven.function.Parse#parseLong(java.lang.String) */
    public static  long parseLong( java.lang.String s ) {return Parse.parseLong( s );}

    /** @see io.deephaven.function.Parse#parseLong(java.lang.String,int) */
    public static  long parseLong( java.lang.String s, int radix ) {return Parse.parseLong( s, radix );}

    /** @see io.deephaven.function.Parse#parseShort(java.lang.String) */
    public static  short parseShort( java.lang.String s ) {return Parse.parseShort( s );}

    /** @see io.deephaven.function.Parse#parseShort(java.lang.String,int) */
    public static  short parseShort( java.lang.String s, int radix ) {return Parse.parseShort( s, radix );}

    /** @see io.deephaven.function.Parse#parseUnsignedInt(java.lang.String) */
    public static  int parseUnsignedInt( java.lang.String s ) {return Parse.parseUnsignedInt( s );}

    /** @see io.deephaven.function.Parse#parseUnsignedInt(java.lang.String,int) */
    public static  int parseUnsignedInt( java.lang.String s, int radix ) {return Parse.parseUnsignedInt( s, radix );}

    /** @see io.deephaven.function.Parse#parseUnsignedLong(java.lang.String) */
    public static  long parseUnsignedLong( java.lang.String s ) {return Parse.parseUnsignedLong( s );}

    /** @see io.deephaven.function.Parse#parseUnsignedLong(java.lang.String,int) */
    public static  long parseUnsignedLong( java.lang.String s, int radix ) {return Parse.parseUnsignedLong( s, radix );}

    /** @see io.deephaven.function.Numeric#percentile(double,byte[]) */
    public static  double percentile( double percentile, byte... values ) {return Numeric.percentile( percentile, values );}

    /** @see io.deephaven.function.Numeric#percentile(double,double[]) */
    public static  double percentile( double percentile, double... values ) {return Numeric.percentile( percentile, values );}

    /** @see io.deephaven.function.Numeric#percentile(double,float[]) */
    public static  double percentile( double percentile, float... values ) {return Numeric.percentile( percentile, values );}

    /** @see io.deephaven.function.Numeric#percentile(double,int[]) */
    public static  double percentile( double percentile, int... values ) {return Numeric.percentile( percentile, values );}

    /** @see io.deephaven.function.Numeric#percentile(double,long[]) */
    public static  double percentile( double percentile, long... values ) {return Numeric.percentile( percentile, values );}

    /** @see io.deephaven.function.Numeric#percentile(double,short[]) */
    public static  double percentile( double percentile, short... values ) {return Numeric.percentile( percentile, values );}

    /** @see io.deephaven.function.Numeric#percentile(double,io.deephaven.vector.ByteVector) */
    public static  double percentile( double percentile, io.deephaven.vector.ByteVector values ) {return Numeric.percentile( percentile, values );}

    /** @see io.deephaven.function.Numeric#percentile(double,io.deephaven.vector.DoubleVector) */
    public static  double percentile( double percentile, io.deephaven.vector.DoubleVector values ) {return Numeric.percentile( percentile, values );}

    /** @see io.deephaven.function.Numeric#percentile(double,io.deephaven.vector.FloatVector) */
    public static  double percentile( double percentile, io.deephaven.vector.FloatVector values ) {return Numeric.percentile( percentile, values );}

    /** @see io.deephaven.function.Numeric#percentile(double,io.deephaven.vector.IntVector) */
    public static  double percentile( double percentile, io.deephaven.vector.IntVector values ) {return Numeric.percentile( percentile, values );}

    /** @see io.deephaven.function.Numeric#percentile(double,io.deephaven.vector.LongVector) */
    public static  double percentile( double percentile, io.deephaven.vector.LongVector values ) {return Numeric.percentile( percentile, values );}

    /** @see io.deephaven.function.Numeric#percentile(double,io.deephaven.vector.ShortVector) */
    public static  double percentile( double percentile, io.deephaven.vector.ShortVector values ) {return Numeric.percentile( percentile, values );}

    /** @see io.deephaven.function.Numeric#pow(byte,byte) */
    public static  double pow( byte a, byte b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(byte,double) */
    public static  double pow( byte a, double b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(byte,float) */
    public static  double pow( byte a, float b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(byte,int) */
    public static  double pow( byte a, int b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(byte,long) */
    public static  double pow( byte a, long b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(byte,short) */
    public static  double pow( byte a, short b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(double,byte) */
    public static  double pow( double a, byte b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(double,double) */
    public static  double pow( double a, double b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(double,float) */
    public static  double pow( double a, float b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(double,int) */
    public static  double pow( double a, int b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(double,long) */
    public static  double pow( double a, long b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(double,short) */
    public static  double pow( double a, short b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(float,byte) */
    public static  double pow( float a, byte b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(float,double) */
    public static  double pow( float a, double b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(float,float) */
    public static  double pow( float a, float b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(float,int) */
    public static  double pow( float a, int b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(float,long) */
    public static  double pow( float a, long b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(float,short) */
    public static  double pow( float a, short b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(int,byte) */
    public static  double pow( int a, byte b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(int,double) */
    public static  double pow( int a, double b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(int,float) */
    public static  double pow( int a, float b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(int,int) */
    public static  double pow( int a, int b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(int,long) */
    public static  double pow( int a, long b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(int,short) */
    public static  double pow( int a, short b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(long,byte) */
    public static  double pow( long a, byte b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(long,double) */
    public static  double pow( long a, double b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(long,float) */
    public static  double pow( long a, float b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(long,int) */
    public static  double pow( long a, int b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(long,long) */
    public static  double pow( long a, long b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(long,short) */
    public static  double pow( long a, short b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(short,byte) */
    public static  double pow( short a, byte b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(short,double) */
    public static  double pow( short a, double b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(short,float) */
    public static  double pow( short a, float b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(short,int) */
    public static  double pow( short a, int b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(short,long) */
    public static  double pow( short a, long b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#pow(short,short) */
    public static  double pow( short a, short b ) {return Numeric.pow( a, b );}

    /** @see io.deephaven.function.Numeric#product(byte[]) */
    public static  byte product( byte... values ) {return Numeric.product( values );}

    /** @see io.deephaven.function.Numeric#product(double[]) */
    public static  double product( double... values ) {return Numeric.product( values );}

    /** @see io.deephaven.function.Numeric#product(float[]) */
    public static  float product( float... values ) {return Numeric.product( values );}

    /** @see io.deephaven.function.Numeric#product(int[]) */
    public static  int product( int... values ) {return Numeric.product( values );}

    /** @see io.deephaven.function.Numeric#product(long[]) */
    public static  long product( long... values ) {return Numeric.product( values );}

    /** @see io.deephaven.function.Numeric#product(short[]) */
    public static  short product( short... values ) {return Numeric.product( values );}

    /** @see io.deephaven.function.Numeric#product(io.deephaven.vector.ByteVector) */
    public static  byte product( io.deephaven.vector.ByteVector values ) {return Numeric.product( values );}

    /** @see io.deephaven.function.Numeric#product(io.deephaven.vector.DoubleVector) */
    public static  double product( io.deephaven.vector.DoubleVector values ) {return Numeric.product( values );}

    /** @see io.deephaven.function.Numeric#product(io.deephaven.vector.FloatVector) */
    public static  float product( io.deephaven.vector.FloatVector values ) {return Numeric.product( values );}

    /** @see io.deephaven.function.Numeric#product(io.deephaven.vector.IntVector) */
    public static  int product( io.deephaven.vector.IntVector values ) {return Numeric.product( values );}

    /** @see io.deephaven.function.Numeric#product(io.deephaven.vector.LongVector) */
    public static  long product( io.deephaven.vector.LongVector values ) {return Numeric.product( values );}

    /** @see io.deephaven.function.Numeric#product(io.deephaven.vector.ShortVector) */
    public static  short product( io.deephaven.vector.ShortVector values ) {return Numeric.product( values );}

    /** @see io.deephaven.function.Random#random() */
    public static  double random( ) {return Random.random( );}

    /** @see io.deephaven.function.Random#randomBool() */
    public static  boolean randomBool( ) {return Random.randomBool( );}

    /** @see io.deephaven.function.Random#randomBool(int) */
    public static  boolean[] randomBool( int size ) {return Random.randomBool( size );}

    /** @see io.deephaven.function.Random#randomDouble(double,double) */
    public static  double randomDouble( double min, double max ) {return Random.randomDouble( min, max );}

    /** @see io.deephaven.function.Random#randomDouble(double,double,int) */
    public static  double[] randomDouble( double min, double max, int size ) {return Random.randomDouble( min, max, size );}

    /** @see io.deephaven.function.Random#randomFloat(float,float) */
    public static  float randomFloat( float min, float max ) {return Random.randomFloat( min, max );}

    /** @see io.deephaven.function.Random#randomFloat(float,float,int) */
    public static  float[] randomFloat( float min, float max, int size ) {return Random.randomFloat( min, max, size );}

    /** @see io.deephaven.function.Random#randomGaussian(double,double) */
    public static  double randomGaussian( double mean, double std ) {return Random.randomGaussian( mean, std );}

    /** @see io.deephaven.function.Random#randomGaussian(double,double,int) */
    public static  double[] randomGaussian( double mean, double std, int size ) {return Random.randomGaussian( mean, std, size );}

    /** @see io.deephaven.function.Random#randomInt(int,int) */
    public static  int randomInt( int min, int max ) {return Random.randomInt( min, max );}

    /** @see io.deephaven.function.Random#randomInt(int,int,int) */
    public static  int[] randomInt( int min, int max, int size ) {return Random.randomInt( min, max, size );}

    /** @see io.deephaven.function.Random#randomLong(long,long) */
    public static  long randomLong( long min, long max ) {return Random.randomLong( min, max );}

    /** @see io.deephaven.function.Random#randomLong(long,long,int) */
    public static  long[] randomLong( long min, long max, int size ) {return Random.randomLong( min, max, size );}

    /** @see io.deephaven.function.BinSearch#rawBinSearchIndex(java.lang.Comparable[],java.lang.Comparable,io.deephaven.function.BinSearchAlgo) */
    public static > int rawBinSearchIndex( T[] values, T key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.rawBinSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#rawBinSearchIndex(byte[],byte,io.deephaven.function.BinSearchAlgo) */
    public static  int rawBinSearchIndex( byte[] values, byte key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.rawBinSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#rawBinSearchIndex(char[],char,io.deephaven.function.BinSearchAlgo) */
    public static  int rawBinSearchIndex( char[] values, char key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.rawBinSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#rawBinSearchIndex(double[],double,io.deephaven.function.BinSearchAlgo) */
    public static  int rawBinSearchIndex( double[] values, double key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.rawBinSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#rawBinSearchIndex(float[],float,io.deephaven.function.BinSearchAlgo) */
    public static  int rawBinSearchIndex( float[] values, float key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.rawBinSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#rawBinSearchIndex(int[],int,io.deephaven.function.BinSearchAlgo) */
    public static  int rawBinSearchIndex( int[] values, int key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.rawBinSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#rawBinSearchIndex(long[],long,io.deephaven.function.BinSearchAlgo) */
    public static  int rawBinSearchIndex( long[] values, long key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.rawBinSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#rawBinSearchIndex(short[],short,io.deephaven.function.BinSearchAlgo) */
    public static  int rawBinSearchIndex( short[] values, short key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.rawBinSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#rawBinSearchIndex(io.deephaven.vector.ByteVector,byte,io.deephaven.function.BinSearchAlgo) */
    public static  int rawBinSearchIndex( io.deephaven.vector.ByteVector values, byte key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.rawBinSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#rawBinSearchIndex(io.deephaven.vector.CharVector,char,io.deephaven.function.BinSearchAlgo) */
    public static  int rawBinSearchIndex( io.deephaven.vector.CharVector values, char key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.rawBinSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#rawBinSearchIndex(io.deephaven.vector.DoubleVector,double,io.deephaven.function.BinSearchAlgo) */
    public static  int rawBinSearchIndex( io.deephaven.vector.DoubleVector values, double key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.rawBinSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#rawBinSearchIndex(io.deephaven.vector.FloatVector,float,io.deephaven.function.BinSearchAlgo) */
    public static  int rawBinSearchIndex( io.deephaven.vector.FloatVector values, float key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.rawBinSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#rawBinSearchIndex(io.deephaven.vector.IntVector,int,io.deephaven.function.BinSearchAlgo) */
    public static  int rawBinSearchIndex( io.deephaven.vector.IntVector values, int key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.rawBinSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#rawBinSearchIndex(io.deephaven.vector.LongVector,long,io.deephaven.function.BinSearchAlgo) */
    public static  int rawBinSearchIndex( io.deephaven.vector.LongVector values, long key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.rawBinSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#rawBinSearchIndex(io.deephaven.vector.ShortVector,short,io.deephaven.function.BinSearchAlgo) */
    public static  int rawBinSearchIndex( io.deephaven.vector.ShortVector values, short key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.rawBinSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.BinSearch#rawBinSearchIndex(io.deephaven.vector.ObjectVector,java.lang.Comparable,io.deephaven.function.BinSearchAlgo) */
    public static > int rawBinSearchIndex( io.deephaven.vector.ObjectVector values, T key, io.deephaven.function.BinSearchAlgo choiceWhenEquals ) {return BinSearch.rawBinSearchIndex( values, key, choiceWhenEquals );}

    /** @see io.deephaven.function.Basic#repeat(java.lang.Object,int) */
    public static  T[] repeat( T value, int size ) {return Basic.repeat( value, size );}

    /** @see io.deephaven.function.Basic#repeat(byte,int) */
    public static  byte[] repeat( byte value, int size ) {return Basic.repeat( value, size );}

    /** @see io.deephaven.function.Basic#repeat(char,int) */
    public static  char[] repeat( char value, int size ) {return Basic.repeat( value, size );}

    /** @see io.deephaven.function.Basic#repeat(double,int) */
    public static  double[] repeat( double value, int size ) {return Basic.repeat( value, size );}

    /** @see io.deephaven.function.Basic#repeat(float,int) */
    public static  float[] repeat( float value, int size ) {return Basic.repeat( value, size );}

    /** @see io.deephaven.function.Basic#repeat(int,int) */
    public static  int[] repeat( int value, int size ) {return Basic.repeat( value, size );}

    /** @see io.deephaven.function.Basic#repeat(long,int) */
    public static  long[] repeat( long value, int size ) {return Basic.repeat( value, size );}

    /** @see io.deephaven.function.Basic#repeat(short,int) */
    public static  short[] repeat( short value, int size ) {return Basic.repeat( value, size );}

    /** @see io.deephaven.function.Numeric#replaceIfNaN(double[],double) */
    public static  double[] replaceIfNaN( double[] values, double replacement ) {return Numeric.replaceIfNaN( values, replacement );}

    /** @see io.deephaven.function.Numeric#replaceIfNaN(float[],float) */
    public static  float[] replaceIfNaN( float[] values, float replacement ) {return Numeric.replaceIfNaN( values, replacement );}

    /** @see io.deephaven.function.Numeric#replaceIfNaN(double,double) */
    public static  double replaceIfNaN( double value, double replacement ) {return Numeric.replaceIfNaN( value, replacement );}

    /** @see io.deephaven.function.Numeric#replaceIfNaN(float,float) */
    public static  float replaceIfNaN( float value, float replacement ) {return Numeric.replaceIfNaN( value, replacement );}

    /** @see io.deephaven.function.Numeric#replaceIfNaN(io.deephaven.vector.DoubleVector,double) */
    public static  double[] replaceIfNaN( io.deephaven.vector.DoubleVector values, double replacement ) {return Numeric.replaceIfNaN( values, replacement );}

    /** @see io.deephaven.function.Numeric#replaceIfNaN(io.deephaven.vector.FloatVector,float) */
    public static  float[] replaceIfNaN( io.deephaven.vector.FloatVector values, float replacement ) {return Numeric.replaceIfNaN( values, replacement );}

    /** @see io.deephaven.function.Numeric#replaceIfNonFinite(double[],double) */
    public static  double[] replaceIfNonFinite( double[] values, double replacement ) {return Numeric.replaceIfNonFinite( values, replacement );}

    /** @see io.deephaven.function.Numeric#replaceIfNonFinite(float[],float) */
    public static  float[] replaceIfNonFinite( float[] values, float replacement ) {return Numeric.replaceIfNonFinite( values, replacement );}

    /** @see io.deephaven.function.Numeric#replaceIfNonFinite(double,double) */
    public static  double replaceIfNonFinite( double value, double replacement ) {return Numeric.replaceIfNonFinite( value, replacement );}

    /** @see io.deephaven.function.Numeric#replaceIfNonFinite(float,float) */
    public static  float replaceIfNonFinite( float value, float replacement ) {return Numeric.replaceIfNonFinite( value, replacement );}

    /** @see io.deephaven.function.Numeric#replaceIfNonFinite(io.deephaven.vector.DoubleVector,double) */
    public static  double[] replaceIfNonFinite( io.deephaven.vector.DoubleVector values, double replacement ) {return Numeric.replaceIfNonFinite( values, replacement );}

    /** @see io.deephaven.function.Numeric#replaceIfNonFinite(io.deephaven.vector.FloatVector,float) */
    public static  float[] replaceIfNonFinite( io.deephaven.vector.FloatVector values, float replacement ) {return Numeric.replaceIfNonFinite( values, replacement );}

    /** @see io.deephaven.function.Basic#replaceIfNull(java.lang.Object,java.lang.Object) */
    public static  T replaceIfNull( T value, T replacement ) {return Basic.replaceIfNull( value, replacement );}

    /** @see io.deephaven.function.Basic#replaceIfNull(java.lang.Object[],java.lang.Object) */
    public static  T[] replaceIfNull( T[] values, T replacement ) {return Basic.replaceIfNull( values, replacement );}

    /** @see io.deephaven.function.Basic#replaceIfNull(byte,byte) */
    public static  byte replaceIfNull( byte value, byte replacement ) {return Basic.replaceIfNull( value, replacement );}

    /** @see io.deephaven.function.Basic#replaceIfNull(char,char) */
    public static  char replaceIfNull( char value, char replacement ) {return Basic.replaceIfNull( value, replacement );}

    /** @see io.deephaven.function.Basic#replaceIfNull(byte[],byte) */
    public static  byte[] replaceIfNull( byte[] values, byte replacement ) {return Basic.replaceIfNull( values, replacement );}

    /** @see io.deephaven.function.Basic#replaceIfNull(char[],char) */
    public static  char[] replaceIfNull( char[] values, char replacement ) {return Basic.replaceIfNull( values, replacement );}

    /** @see io.deephaven.function.Basic#replaceIfNull(double[],double) */
    public static  double[] replaceIfNull( double[] values, double replacement ) {return Basic.replaceIfNull( values, replacement );}

    /** @see io.deephaven.function.Basic#replaceIfNull(float[],float) */
    public static  float[] replaceIfNull( float[] values, float replacement ) {return Basic.replaceIfNull( values, replacement );}

    /** @see io.deephaven.function.Basic#replaceIfNull(int[],int) */
    public static  int[] replaceIfNull( int[] values, int replacement ) {return Basic.replaceIfNull( values, replacement );}

    /** @see io.deephaven.function.Basic#replaceIfNull(long[],long) */
    public static  long[] replaceIfNull( long[] values, long replacement ) {return Basic.replaceIfNull( values, replacement );}

    /** @see io.deephaven.function.Basic#replaceIfNull(short[],short) */
    public static  short[] replaceIfNull( short[] values, short replacement ) {return Basic.replaceIfNull( values, replacement );}

    /** @see io.deephaven.function.Basic#replaceIfNull(double,double) */
    public static  double replaceIfNull( double value, double replacement ) {return Basic.replaceIfNull( value, replacement );}

    /** @see io.deephaven.function.Basic#replaceIfNull(float,float) */
    public static  float replaceIfNull( float value, float replacement ) {return Basic.replaceIfNull( value, replacement );}

    /** @see io.deephaven.function.Basic#replaceIfNull(int,int) */
    public static  int replaceIfNull( int value, int replacement ) {return Basic.replaceIfNull( value, replacement );}

    /** @see io.deephaven.function.Basic#replaceIfNull(io.deephaven.vector.ByteVector,byte) */
    public static  byte[] replaceIfNull( io.deephaven.vector.ByteVector values, byte replacement ) {return Basic.replaceIfNull( values, replacement );}

    /** @see io.deephaven.function.Basic#replaceIfNull(io.deephaven.vector.CharVector,char) */
    public static  char[] replaceIfNull( io.deephaven.vector.CharVector values, char replacement ) {return Basic.replaceIfNull( values, replacement );}

    /** @see io.deephaven.function.Basic#replaceIfNull(io.deephaven.vector.DoubleVector,double) */
    public static  double[] replaceIfNull( io.deephaven.vector.DoubleVector values, double replacement ) {return Basic.replaceIfNull( values, replacement );}

    /** @see io.deephaven.function.Basic#replaceIfNull(io.deephaven.vector.FloatVector,float) */
    public static  float[] replaceIfNull( io.deephaven.vector.FloatVector values, float replacement ) {return Basic.replaceIfNull( values, replacement );}

    /** @see io.deephaven.function.Basic#replaceIfNull(io.deephaven.vector.IntVector,int) */
    public static  int[] replaceIfNull( io.deephaven.vector.IntVector values, int replacement ) {return Basic.replaceIfNull( values, replacement );}

    /** @see io.deephaven.function.Basic#replaceIfNull(io.deephaven.vector.LongVector,long) */
    public static  long[] replaceIfNull( io.deephaven.vector.LongVector values, long replacement ) {return Basic.replaceIfNull( values, replacement );}

    /** @see io.deephaven.function.Basic#replaceIfNull(io.deephaven.vector.ShortVector,short) */
    public static  short[] replaceIfNull( io.deephaven.vector.ShortVector values, short replacement ) {return Basic.replaceIfNull( values, replacement );}

    /** @see io.deephaven.function.Basic#replaceIfNull(io.deephaven.vector.ObjectVector,java.lang.Object) */
    public static  T[] replaceIfNull( io.deephaven.vector.ObjectVector values, T replacement ) {return Basic.replaceIfNull( values, replacement );}

    /** @see io.deephaven.function.Basic#replaceIfNull(long,long) */
    public static  long replaceIfNull( long value, long replacement ) {return Basic.replaceIfNull( value, replacement );}

    /** @see io.deephaven.function.Basic#replaceIfNull(short,short) */
    public static  short replaceIfNull( short value, short replacement ) {return Basic.replaceIfNull( value, replacement );}

    /** @see io.deephaven.function.Numeric#replaceIfNullNaN(double[],double) */
    public static  double[] replaceIfNullNaN( double[] values, double replacement ) {return Numeric.replaceIfNullNaN( values, replacement );}

    /** @see io.deephaven.function.Numeric#replaceIfNullNaN(float[],float) */
    public static  float[] replaceIfNullNaN( float[] values, float replacement ) {return Numeric.replaceIfNullNaN( values, replacement );}

    /** @see io.deephaven.function.Numeric#replaceIfNullNaN(double,double) */
    public static  double replaceIfNullNaN( double value, double replacement ) {return Numeric.replaceIfNullNaN( value, replacement );}

    /** @see io.deephaven.function.Numeric#replaceIfNullNaN(float,float) */
    public static  float replaceIfNullNaN( float value, float replacement ) {return Numeric.replaceIfNullNaN( value, replacement );}

    /** @see io.deephaven.function.Numeric#replaceIfNullNaN(io.deephaven.vector.DoubleVector,double) */
    public static  double[] replaceIfNullNaN( io.deephaven.vector.DoubleVector values, double replacement ) {return Numeric.replaceIfNullNaN( values, replacement );}

    /** @see io.deephaven.function.Numeric#replaceIfNullNaN(io.deephaven.vector.FloatVector,float) */
    public static  float[] replaceIfNullNaN( io.deephaven.vector.FloatVector values, float replacement ) {return Numeric.replaceIfNullNaN( values, replacement );}

    /** @see io.deephaven.function.Basic#reverse(byte[]) */
    public static  byte[] reverse( byte... values ) {return Basic.reverse( values );}

    /** @see io.deephaven.function.Basic#reverse(char[]) */
    public static  char[] reverse( char... values ) {return Basic.reverse( values );}

    /** @see io.deephaven.function.Basic#reverse(double[]) */
    public static  double[] reverse( double... values ) {return Basic.reverse( values );}

    /** @see io.deephaven.function.Basic#reverse(float[]) */
    public static  float[] reverse( float... values ) {return Basic.reverse( values );}

    /** @see io.deephaven.function.Basic#reverse(int[]) */
    public static  int[] reverse( int... values ) {return Basic.reverse( values );}

    /** @see io.deephaven.function.Basic#reverse(long[]) */
    public static  long[] reverse( long... values ) {return Basic.reverse( values );}

    /** @see io.deephaven.function.Basic#reverse(short[]) */
    public static  short[] reverse( short... values ) {return Basic.reverse( values );}

    /** @see io.deephaven.function.Basic#reverse(io.deephaven.vector.ByteVector) */
    public static  byte[] reverse( io.deephaven.vector.ByteVector values ) {return Basic.reverse( values );}

    /** @see io.deephaven.function.Basic#reverse(io.deephaven.vector.CharVector) */
    public static  char[] reverse( io.deephaven.vector.CharVector values ) {return Basic.reverse( values );}

    /** @see io.deephaven.function.Basic#reverse(io.deephaven.vector.DoubleVector) */
    public static  double[] reverse( io.deephaven.vector.DoubleVector values ) {return Basic.reverse( values );}

    /** @see io.deephaven.function.Basic#reverse(io.deephaven.vector.FloatVector) */
    public static  float[] reverse( io.deephaven.vector.FloatVector values ) {return Basic.reverse( values );}

    /** @see io.deephaven.function.Basic#reverse(io.deephaven.vector.IntVector) */
    public static  int[] reverse( io.deephaven.vector.IntVector values ) {return Basic.reverse( values );}

    /** @see io.deephaven.function.Basic#reverse(io.deephaven.vector.LongVector) */
    public static  long[] reverse( io.deephaven.vector.LongVector values ) {return Basic.reverse( values );}

    /** @see io.deephaven.function.Basic#reverse(io.deephaven.vector.ShortVector) */
    public static  short[] reverse( io.deephaven.vector.ShortVector values ) {return Basic.reverse( values );}

    /** @see io.deephaven.function.Basic#reverseObj(java.lang.Object[]) */
    public static  T[] reverseObj( T... values ) {return Basic.reverseObj( values );}

    /** @see io.deephaven.function.Basic#reverseObj(io.deephaven.vector.ObjectVector) */
    public static  T[] reverseObj( io.deephaven.vector.ObjectVector values ) {return Basic.reverseObj( values );}

    /** @see io.deephaven.function.Numeric#rint(byte) */
    public static  double rint( byte value ) {return Numeric.rint( value );}

    /** @see io.deephaven.function.Numeric#rint(double) */
    public static  double rint( double value ) {return Numeric.rint( value );}

    /** @see io.deephaven.function.Numeric#rint(float) */
    public static  double rint( float value ) {return Numeric.rint( value );}

    /** @see io.deephaven.function.Numeric#rint(int) */
    public static  double rint( int value ) {return Numeric.rint( value );}

    /** @see io.deephaven.function.Numeric#rint(long) */
    public static  double rint( long value ) {return Numeric.rint( value );}

    /** @see io.deephaven.function.Numeric#rint(short) */
    public static  double rint( short value ) {return Numeric.rint( value );}

    /** @see io.deephaven.function.Numeric#round(byte) */
    public static  long round( byte value ) {return Numeric.round( value );}

    /** @see io.deephaven.function.Numeric#round(double) */
    public static  long round( double value ) {return Numeric.round( value );}

    /** @see io.deephaven.function.Numeric#round(float) */
    public static  long round( float value ) {return Numeric.round( value );}

    /** @see io.deephaven.function.Numeric#round(int) */
    public static  long round( int value ) {return Numeric.round( value );}

    /** @see io.deephaven.function.Numeric#round(long) */
    public static  long round( long value ) {return Numeric.round( value );}

    /** @see io.deephaven.function.Numeric#round(short) */
    public static  long round( short value ) {return Numeric.round( value );}

    /** @see io.deephaven.function.Numeric#sequence(byte,byte,byte) */
    public static  byte[] sequence( byte start, byte end, byte step ) {return Numeric.sequence( start, end, step );}

    /** @see io.deephaven.function.Numeric#sequence(double,double,double) */
    public static  double[] sequence( double start, double end, double step ) {return Numeric.sequence( start, end, step );}

    /** @see io.deephaven.function.Numeric#sequence(float,float,float) */
    public static  float[] sequence( float start, float end, float step ) {return Numeric.sequence( start, end, step );}

    /** @see io.deephaven.function.Numeric#sequence(int,int,int) */
    public static  int[] sequence( int start, int end, int step ) {return Numeric.sequence( start, end, step );}

    /** @see io.deephaven.function.Numeric#sequence(long,long,long) */
    public static  long[] sequence( long start, long end, long step ) {return Numeric.sequence( start, end, step );}

    /** @see io.deephaven.function.Numeric#sequence(short,short,short) */
    public static  short[] sequence( short start, short end, short step ) {return Numeric.sequence( start, end, step );}

    /** @see io.deephaven.function.Numeric#signum(byte) */
    public static  int signum( byte value ) {return Numeric.signum( value );}

    /** @see io.deephaven.function.Numeric#signum(double) */
    public static  int signum( double value ) {return Numeric.signum( value );}

    /** @see io.deephaven.function.Numeric#signum(float) */
    public static  int signum( float value ) {return Numeric.signum( value );}

    /** @see io.deephaven.function.Numeric#signum(int) */
    public static  int signum( int value ) {return Numeric.signum( value );}

    /** @see io.deephaven.function.Numeric#signum(long) */
    public static  int signum( long value ) {return Numeric.signum( value );}

    /** @see io.deephaven.function.Numeric#signum(short) */
    public static  int signum( short value ) {return Numeric.signum( value );}

    /** @see io.deephaven.function.Numeric#sin(byte) */
    public static  double sin( byte value ) {return Numeric.sin( value );}

    /** @see io.deephaven.function.Numeric#sin(double) */
    public static  double sin( double value ) {return Numeric.sin( value );}

    /** @see io.deephaven.function.Numeric#sin(float) */
    public static  double sin( float value ) {return Numeric.sin( value );}

    /** @see io.deephaven.function.Numeric#sin(int) */
    public static  double sin( int value ) {return Numeric.sin( value );}

    /** @see io.deephaven.function.Numeric#sin(long) */
    public static  double sin( long value ) {return Numeric.sin( value );}

    /** @see io.deephaven.function.Numeric#sin(short) */
    public static  double sin( short value ) {return Numeric.sin( value );}

    /** @see io.deephaven.function.Sort#sort(byte[]) */
    public static  byte[] sort( byte... values ) {return Sort.sort( values );}

    /** @see io.deephaven.function.Sort#sort(double[]) */
    public static  double[] sort( double... values ) {return Sort.sort( values );}

    /** @see io.deephaven.function.Sort#sort(float[]) */
    public static  float[] sort( float... values ) {return Sort.sort( values );}

    /** @see io.deephaven.function.Sort#sort(int[]) */
    public static  int[] sort( int... values ) {return Sort.sort( values );}

    /** @see io.deephaven.function.Sort#sort(long[]) */
    public static  long[] sort( long... values ) {return Sort.sort( values );}

    /** @see io.deephaven.function.Sort#sort(java.lang.Byte[]) */
    public static  byte[] sort( java.lang.Byte[] values ) {return Sort.sort( values );}

    /** @see io.deephaven.function.Sort#sort(java.lang.Double[]) */
    public static  double[] sort( java.lang.Double[] values ) {return Sort.sort( values );}

    /** @see io.deephaven.function.Sort#sort(java.lang.Float[]) */
    public static  float[] sort( java.lang.Float[] values ) {return Sort.sort( values );}

    /** @see io.deephaven.function.Sort#sort(java.lang.Integer[]) */
    public static  int[] sort( java.lang.Integer[] values ) {return Sort.sort( values );}

    /** @see io.deephaven.function.Sort#sort(java.lang.Long[]) */
    public static  long[] sort( java.lang.Long[] values ) {return Sort.sort( values );}

    /** @see io.deephaven.function.Sort#sort(java.lang.Short[]) */
    public static  short[] sort( java.lang.Short[] values ) {return Sort.sort( values );}

    /** @see io.deephaven.function.Sort#sort(short[]) */
    public static  short[] sort( short... values ) {return Sort.sort( values );}

    /** @see io.deephaven.function.Sort#sort(io.deephaven.vector.ByteVector) */
    public static  byte[] sort( io.deephaven.vector.ByteVector values ) {return Sort.sort( values );}

    /** @see io.deephaven.function.Sort#sort(io.deephaven.vector.DoubleVector) */
    public static  double[] sort( io.deephaven.vector.DoubleVector values ) {return Sort.sort( values );}

    /** @see io.deephaven.function.Sort#sort(io.deephaven.vector.FloatVector) */
    public static  float[] sort( io.deephaven.vector.FloatVector values ) {return Sort.sort( values );}

    /** @see io.deephaven.function.Sort#sort(io.deephaven.vector.IntVector) */
    public static  int[] sort( io.deephaven.vector.IntVector values ) {return Sort.sort( values );}

    /** @see io.deephaven.function.Sort#sort(io.deephaven.vector.LongVector) */
    public static  long[] sort( io.deephaven.vector.LongVector values ) {return Sort.sort( values );}

    /** @see io.deephaven.function.Sort#sort(io.deephaven.vector.ShortVector) */
    public static  short[] sort( io.deephaven.vector.ShortVector values ) {return Sort.sort( values );}

    /** @see io.deephaven.function.Sort#sortDescending(byte[]) */
    public static  byte[] sortDescending( byte... values ) {return Sort.sortDescending( values );}

    /** @see io.deephaven.function.Sort#sortDescending(double[]) */
    public static  double[] sortDescending( double... values ) {return Sort.sortDescending( values );}

    /** @see io.deephaven.function.Sort#sortDescending(float[]) */
    public static  float[] sortDescending( float... values ) {return Sort.sortDescending( values );}

    /** @see io.deephaven.function.Sort#sortDescending(int[]) */
    public static  int[] sortDescending( int... values ) {return Sort.sortDescending( values );}

    /** @see io.deephaven.function.Sort#sortDescending(long[]) */
    public static  long[] sortDescending( long... values ) {return Sort.sortDescending( values );}

    /** @see io.deephaven.function.Sort#sortDescending(java.lang.Byte[]) */
    public static  byte[] sortDescending( java.lang.Byte[] values ) {return Sort.sortDescending( values );}

    /** @see io.deephaven.function.Sort#sortDescending(java.lang.Double[]) */
    public static  double[] sortDescending( java.lang.Double[] values ) {return Sort.sortDescending( values );}

    /** @see io.deephaven.function.Sort#sortDescending(java.lang.Float[]) */
    public static  float[] sortDescending( java.lang.Float[] values ) {return Sort.sortDescending( values );}

    /** @see io.deephaven.function.Sort#sortDescending(java.lang.Integer[]) */
    public static  int[] sortDescending( java.lang.Integer[] values ) {return Sort.sortDescending( values );}

    /** @see io.deephaven.function.Sort#sortDescending(java.lang.Long[]) */
    public static  long[] sortDescending( java.lang.Long[] values ) {return Sort.sortDescending( values );}

    /** @see io.deephaven.function.Sort#sortDescending(java.lang.Short[]) */
    public static  short[] sortDescending( java.lang.Short[] values ) {return Sort.sortDescending( values );}

    /** @see io.deephaven.function.Sort#sortDescending(short[]) */
    public static  short[] sortDescending( short... values ) {return Sort.sortDescending( values );}

    /** @see io.deephaven.function.Sort#sortDescending(io.deephaven.vector.ByteVector) */
    public static  byte[] sortDescending( io.deephaven.vector.ByteVector values ) {return Sort.sortDescending( values );}

    /** @see io.deephaven.function.Sort#sortDescending(io.deephaven.vector.DoubleVector) */
    public static  double[] sortDescending( io.deephaven.vector.DoubleVector values ) {return Sort.sortDescending( values );}

    /** @see io.deephaven.function.Sort#sortDescending(io.deephaven.vector.FloatVector) */
    public static  float[] sortDescending( io.deephaven.vector.FloatVector values ) {return Sort.sortDescending( values );}

    /** @see io.deephaven.function.Sort#sortDescending(io.deephaven.vector.IntVector) */
    public static  int[] sortDescending( io.deephaven.vector.IntVector values ) {return Sort.sortDescending( values );}

    /** @see io.deephaven.function.Sort#sortDescending(io.deephaven.vector.LongVector) */
    public static  long[] sortDescending( io.deephaven.vector.LongVector values ) {return Sort.sortDescending( values );}

    /** @see io.deephaven.function.Sort#sortDescending(io.deephaven.vector.ShortVector) */
    public static  short[] sortDescending( io.deephaven.vector.ShortVector values ) {return Sort.sortDescending( values );}

    /** @see io.deephaven.function.Sort#sortDescendingObj(java.lang.Comparable[]) */
    public static > T[] sortDescendingObj( T... values ) {return Sort.sortDescendingObj( values );}

    /** @see io.deephaven.function.Sort#sortDescendingObj(io.deephaven.vector.ObjectVector) */
    public static > T[] sortDescendingObj( io.deephaven.vector.ObjectVector values ) {return Sort.sortDescendingObj( values );}

    /** @see io.deephaven.function.Sort#sortDescendingObj(java.lang.Comparable[],java.util.Comparator) */
    public static > T[] sortDescendingObj( T[] values, java.util.Comparator comparator ) {return Sort.sortDescendingObj( values, comparator );}

    /** @see io.deephaven.function.Sort#sortDescendingObj(io.deephaven.vector.ObjectVector,java.util.Comparator) */
    public static > T[] sortDescendingObj( io.deephaven.vector.ObjectVector values, java.util.Comparator comparator ) {return Sort.sortDescendingObj( values, comparator );}

    /** @see io.deephaven.function.Sort#sortObj(java.lang.Comparable[]) */
    public static > T[] sortObj( T... values ) {return Sort.sortObj( values );}

    /** @see io.deephaven.function.Sort#sortObj(io.deephaven.vector.ObjectVector) */
    public static > T[] sortObj( io.deephaven.vector.ObjectVector values ) {return Sort.sortObj( values );}

    /** @see io.deephaven.function.Sort#sortObj(java.lang.Comparable[],java.util.Comparator) */
    public static > T[] sortObj( T[] values, java.util.Comparator comparator ) {return Sort.sortObj( values, comparator );}

    /** @see io.deephaven.function.Sort#sortObj(io.deephaven.vector.ObjectVector,java.util.Comparator) */
    public static > T[] sortObj( io.deephaven.vector.ObjectVector values, java.util.Comparator comparator ) {return Sort.sortObj( values, comparator );}

    /** @see io.deephaven.function.Numeric#sqrt(byte) */
    public static  double sqrt( byte value ) {return Numeric.sqrt( value );}

    /** @see io.deephaven.function.Numeric#sqrt(double) */
    public static  double sqrt( double value ) {return Numeric.sqrt( value );}

    /** @see io.deephaven.function.Numeric#sqrt(float) */
    public static  double sqrt( float value ) {return Numeric.sqrt( value );}

    /** @see io.deephaven.function.Numeric#sqrt(int) */
    public static  double sqrt( int value ) {return Numeric.sqrt( value );}

    /** @see io.deephaven.function.Numeric#sqrt(long) */
    public static  double sqrt( long value ) {return Numeric.sqrt( value );}

    /** @see io.deephaven.function.Numeric#sqrt(short) */
    public static  double sqrt( short value ) {return Numeric.sqrt( value );}

    /** @see io.deephaven.function.Numeric#std(byte[]) */
    public static  double std( byte... values ) {return Numeric.std( values );}

    /** @see io.deephaven.function.Numeric#std(double[]) */
    public static  double std( double... values ) {return Numeric.std( values );}

    /** @see io.deephaven.function.Numeric#std(float[]) */
    public static  double std( float... values ) {return Numeric.std( values );}

    /** @see io.deephaven.function.Numeric#std(int[]) */
    public static  double std( int... values ) {return Numeric.std( values );}

    /** @see io.deephaven.function.Numeric#std(long[]) */
    public static  double std( long... values ) {return Numeric.std( values );}

    /** @see io.deephaven.function.Numeric#std(java.lang.Byte[]) */
    public static  double std( java.lang.Byte[] values ) {return Numeric.std( values );}

    /** @see io.deephaven.function.Numeric#std(java.lang.Double[]) */
    public static  double std( java.lang.Double[] values ) {return Numeric.std( values );}

    /** @see io.deephaven.function.Numeric#std(java.lang.Float[]) */
    public static  double std( java.lang.Float[] values ) {return Numeric.std( values );}

    /** @see io.deephaven.function.Numeric#std(java.lang.Integer[]) */
    public static  double std( java.lang.Integer[] values ) {return Numeric.std( values );}

    /** @see io.deephaven.function.Numeric#std(java.lang.Long[]) */
    public static  double std( java.lang.Long[] values ) {return Numeric.std( values );}

    /** @see io.deephaven.function.Numeric#std(java.lang.Short[]) */
    public static  double std( java.lang.Short[] values ) {return Numeric.std( values );}

    /** @see io.deephaven.function.Numeric#std(short[]) */
    public static  double std( short... values ) {return Numeric.std( values );}

    /** @see io.deephaven.function.Numeric#std(io.deephaven.vector.ByteVector) */
    public static  double std( io.deephaven.vector.ByteVector values ) {return Numeric.std( values );}

    /** @see io.deephaven.function.Numeric#std(io.deephaven.vector.DoubleVector) */
    public static  double std( io.deephaven.vector.DoubleVector values ) {return Numeric.std( values );}

    /** @see io.deephaven.function.Numeric#std(io.deephaven.vector.FloatVector) */
    public static  double std( io.deephaven.vector.FloatVector values ) {return Numeric.std( values );}

    /** @see io.deephaven.function.Numeric#std(io.deephaven.vector.IntVector) */
    public static  double std( io.deephaven.vector.IntVector values ) {return Numeric.std( values );}

    /** @see io.deephaven.function.Numeric#std(io.deephaven.vector.LongVector) */
    public static  double std( io.deephaven.vector.LongVector values ) {return Numeric.std( values );}

    /** @see io.deephaven.function.Numeric#std(io.deephaven.vector.ShortVector) */
    public static  double std( io.deephaven.vector.ShortVector values ) {return Numeric.std( values );}

    /** @see io.deephaven.function.Numeric#ste(byte[]) */
    public static  double ste( byte... values ) {return Numeric.ste( values );}

    /** @see io.deephaven.function.Numeric#ste(double[]) */
    public static  double ste( double... values ) {return Numeric.ste( values );}

    /** @see io.deephaven.function.Numeric#ste(float[]) */
    public static  double ste( float... values ) {return Numeric.ste( values );}

    /** @see io.deephaven.function.Numeric#ste(int[]) */
    public static  double ste( int... values ) {return Numeric.ste( values );}

    /** @see io.deephaven.function.Numeric#ste(long[]) */
    public static  double ste( long... values ) {return Numeric.ste( values );}

    /** @see io.deephaven.function.Numeric#ste(java.lang.Byte[]) */
    public static  double ste( java.lang.Byte[] values ) {return Numeric.ste( values );}

    /** @see io.deephaven.function.Numeric#ste(java.lang.Double[]) */
    public static  double ste( java.lang.Double[] values ) {return Numeric.ste( values );}

    /** @see io.deephaven.function.Numeric#ste(java.lang.Float[]) */
    public static  double ste( java.lang.Float[] values ) {return Numeric.ste( values );}

    /** @see io.deephaven.function.Numeric#ste(java.lang.Integer[]) */
    public static  double ste( java.lang.Integer[] values ) {return Numeric.ste( values );}

    /** @see io.deephaven.function.Numeric#ste(java.lang.Long[]) */
    public static  double ste( java.lang.Long[] values ) {return Numeric.ste( values );}

    /** @see io.deephaven.function.Numeric#ste(java.lang.Short[]) */
    public static  double ste( java.lang.Short[] values ) {return Numeric.ste( values );}

    /** @see io.deephaven.function.Numeric#ste(short[]) */
    public static  double ste( short... values ) {return Numeric.ste( values );}

    /** @see io.deephaven.function.Numeric#ste(io.deephaven.vector.ByteVector) */
    public static  double ste( io.deephaven.vector.ByteVector values ) {return Numeric.ste( values );}

    /** @see io.deephaven.function.Numeric#ste(io.deephaven.vector.DoubleVector) */
    public static  double ste( io.deephaven.vector.DoubleVector values ) {return Numeric.ste( values );}

    /** @see io.deephaven.function.Numeric#ste(io.deephaven.vector.FloatVector) */
    public static  double ste( io.deephaven.vector.FloatVector values ) {return Numeric.ste( values );}

    /** @see io.deephaven.function.Numeric#ste(io.deephaven.vector.IntVector) */
    public static  double ste( io.deephaven.vector.IntVector values ) {return Numeric.ste( values );}

    /** @see io.deephaven.function.Numeric#ste(io.deephaven.vector.LongVector) */
    public static  double ste( io.deephaven.vector.LongVector values ) {return Numeric.ste( values );}

    /** @see io.deephaven.function.Numeric#ste(io.deephaven.vector.ShortVector) */
    public static  double ste( io.deephaven.vector.ShortVector values ) {return Numeric.ste( values );}

    /** @see io.deephaven.function.Numeric#sum(byte[]) */
    public static  byte sum( byte... values ) {return Numeric.sum( values );}

    /** @see io.deephaven.function.Numeric#sum(double[]) */
    public static  double sum( double... values ) {return Numeric.sum( values );}

    /** @see io.deephaven.function.Numeric#sum(float[]) */
    public static  float sum( float... values ) {return Numeric.sum( values );}

    /** @see io.deephaven.function.Numeric#sum(int[]) */
    public static  int sum( int... values ) {return Numeric.sum( values );}

    /** @see io.deephaven.function.Numeric#sum(long[]) */
    public static  long sum( long... values ) {return Numeric.sum( values );}

    /** @see io.deephaven.function.Numeric#sum(short[]) */
    public static  short sum( short... values ) {return Numeric.sum( values );}

    /** @see io.deephaven.function.Numeric#sum(io.deephaven.vector.ByteVector) */
    public static  byte sum( io.deephaven.vector.ByteVector values ) {return Numeric.sum( values );}

    /** @see io.deephaven.function.Numeric#sum(io.deephaven.vector.DoubleVector) */
    public static  double sum( io.deephaven.vector.DoubleVector values ) {return Numeric.sum( values );}

    /** @see io.deephaven.function.Numeric#sum(io.deephaven.vector.FloatVector) */
    public static  float sum( io.deephaven.vector.FloatVector values ) {return Numeric.sum( values );}

    /** @see io.deephaven.function.Numeric#sum(io.deephaven.vector.IntVector) */
    public static  int sum( io.deephaven.vector.IntVector values ) {return Numeric.sum( values );}

    /** @see io.deephaven.function.Numeric#sum(io.deephaven.vector.LongVector) */
    public static  long sum( io.deephaven.vector.LongVector values ) {return Numeric.sum( values );}

    /** @see io.deephaven.function.Numeric#sum(io.deephaven.vector.ShortVector) */
    public static  short sum( io.deephaven.vector.ShortVector values ) {return Numeric.sum( values );}

    /** @see io.deephaven.function.Numeric#tan(byte) */
    public static  double tan( byte value ) {return Numeric.tan( value );}

    /** @see io.deephaven.function.Numeric#tan(double) */
    public static  double tan( double value ) {return Numeric.tan( value );}

    /** @see io.deephaven.function.Numeric#tan(float) */
    public static  double tan( float value ) {return Numeric.tan( value );}

    /** @see io.deephaven.function.Numeric#tan(int) */
    public static  double tan( int value ) {return Numeric.tan( value );}

    /** @see io.deephaven.function.Numeric#tan(long) */
    public static  double tan( long value ) {return Numeric.tan( value );}

    /** @see io.deephaven.function.Numeric#tan(short) */
    public static  double tan( short value ) {return Numeric.tan( value );}

    /** @see io.deephaven.function.Numeric#tstat(byte[]) */
    public static  double tstat( byte... values ) {return Numeric.tstat( values );}

    /** @see io.deephaven.function.Numeric#tstat(double[]) */
    public static  double tstat( double... values ) {return Numeric.tstat( values );}

    /** @see io.deephaven.function.Numeric#tstat(float[]) */
    public static  double tstat( float... values ) {return Numeric.tstat( values );}

    /** @see io.deephaven.function.Numeric#tstat(int[]) */
    public static  double tstat( int... values ) {return Numeric.tstat( values );}

    /** @see io.deephaven.function.Numeric#tstat(long[]) */
    public static  double tstat( long... values ) {return Numeric.tstat( values );}

    /** @see io.deephaven.function.Numeric#tstat(java.lang.Byte[]) */
    public static  double tstat( java.lang.Byte[] values ) {return Numeric.tstat( values );}

    /** @see io.deephaven.function.Numeric#tstat(java.lang.Double[]) */
    public static  double tstat( java.lang.Double[] values ) {return Numeric.tstat( values );}

    /** @see io.deephaven.function.Numeric#tstat(java.lang.Float[]) */
    public static  double tstat( java.lang.Float[] values ) {return Numeric.tstat( values );}

    /** @see io.deephaven.function.Numeric#tstat(java.lang.Integer[]) */
    public static  double tstat( java.lang.Integer[] values ) {return Numeric.tstat( values );}

    /** @see io.deephaven.function.Numeric#tstat(java.lang.Long[]) */
    public static  double tstat( java.lang.Long[] values ) {return Numeric.tstat( values );}

    /** @see io.deephaven.function.Numeric#tstat(java.lang.Short[]) */
    public static  double tstat( java.lang.Short[] values ) {return Numeric.tstat( values );}

    /** @see io.deephaven.function.Numeric#tstat(short[]) */
    public static  double tstat( short... values ) {return Numeric.tstat( values );}

    /** @see io.deephaven.function.Numeric#tstat(io.deephaven.vector.ByteVector) */
    public static  double tstat( io.deephaven.vector.ByteVector values ) {return Numeric.tstat( values );}

    /** @see io.deephaven.function.Numeric#tstat(io.deephaven.vector.DoubleVector) */
    public static  double tstat( io.deephaven.vector.DoubleVector values ) {return Numeric.tstat( values );}

    /** @see io.deephaven.function.Numeric#tstat(io.deephaven.vector.FloatVector) */
    public static  double tstat( io.deephaven.vector.FloatVector values ) {return Numeric.tstat( values );}

    /** @see io.deephaven.function.Numeric#tstat(io.deephaven.vector.IntVector) */
    public static  double tstat( io.deephaven.vector.IntVector values ) {return Numeric.tstat( values );}

    /** @see io.deephaven.function.Numeric#tstat(io.deephaven.vector.LongVector) */
    public static  double tstat( io.deephaven.vector.LongVector values ) {return Numeric.tstat( values );}

    /** @see io.deephaven.function.Numeric#tstat(io.deephaven.vector.ShortVector) */
    public static  double tstat( io.deephaven.vector.ShortVector values ) {return Numeric.tstat( values );}

    /** @see io.deephaven.function.Basic#unbox(java.lang.Byte[]) */
    public static  byte[] unbox( java.lang.Byte... values ) {return Basic.unbox( values );}

    /** @see io.deephaven.function.Basic#unbox(java.lang.Character[]) */
    public static  char[] unbox( java.lang.Character... values ) {return Basic.unbox( values );}

    /** @see io.deephaven.function.Basic#unbox(java.lang.Double[]) */
    public static  double[] unbox( java.lang.Double... values ) {return Basic.unbox( values );}

    /** @see io.deephaven.function.Basic#unbox(java.lang.Float[]) */
    public static  float[] unbox( java.lang.Float... values ) {return Basic.unbox( values );}

    /** @see io.deephaven.function.Basic#unbox(java.lang.Integer[]) */
    public static  int[] unbox( java.lang.Integer... values ) {return Basic.unbox( values );}

    /** @see io.deephaven.function.Basic#unbox(java.lang.Long[]) */
    public static  long[] unbox( java.lang.Long... values ) {return Basic.unbox( values );}

    /** @see io.deephaven.function.Basic#unbox(java.lang.Short[]) */
    public static  short[] unbox( java.lang.Short... values ) {return Basic.unbox( values );}

    /** @see io.deephaven.function.Numeric#upperBin(byte,byte) */
    public static  byte upperBin( byte value, byte interval ) {return Numeric.upperBin( value, interval );}

    /** @see io.deephaven.function.Numeric#upperBin(double,double) */
    public static  double upperBin( double value, double interval ) {return Numeric.upperBin( value, interval );}

    /** @see io.deephaven.function.Numeric#upperBin(float,float) */
    public static  float upperBin( float value, float interval ) {return Numeric.upperBin( value, interval );}

    /** @see io.deephaven.function.Numeric#upperBin(int,int) */
    public static  int upperBin( int value, int interval ) {return Numeric.upperBin( value, interval );}

    /** @see io.deephaven.function.Numeric#upperBin(long,long) */
    public static  long upperBin( long value, long interval ) {return Numeric.upperBin( value, interval );}

    /** @see io.deephaven.function.Numeric#upperBin(short,short) */
    public static  short upperBin( short value, short interval ) {return Numeric.upperBin( value, interval );}

    /** @see io.deephaven.function.Numeric#upperBin(byte,byte,byte) */
    public static  byte upperBin( byte value, byte interval, byte offset ) {return Numeric.upperBin( value, interval, offset );}

    /** @see io.deephaven.function.Numeric#upperBin(double,double,double) */
    public static  double upperBin( double value, double interval, double offset ) {return Numeric.upperBin( value, interval, offset );}

    /** @see io.deephaven.function.Numeric#upperBin(float,float,float) */
    public static  float upperBin( float value, float interval, float offset ) {return Numeric.upperBin( value, interval, offset );}

    /** @see io.deephaven.function.Numeric#upperBin(int,int,int) */
    public static  int upperBin( int value, int interval, int offset ) {return Numeric.upperBin( value, interval, offset );}

    /** @see io.deephaven.function.Numeric#upperBin(long,long,long) */
    public static  long upperBin( long value, long interval, long offset ) {return Numeric.upperBin( value, interval, offset );}

    /** @see io.deephaven.function.Numeric#upperBin(short,short,short) */
    public static  short upperBin( short value, short interval, short offset ) {return Numeric.upperBin( value, interval, offset );}

    /** @see io.deephaven.function.Numeric#var(byte[]) */
    public static  double var( byte... values ) {return Numeric.var( values );}

    /** @see io.deephaven.function.Numeric#var(double[]) */
    public static  double var( double... values ) {return Numeric.var( values );}

    /** @see io.deephaven.function.Numeric#var(float[]) */
    public static  double var( float... values ) {return Numeric.var( values );}

    /** @see io.deephaven.function.Numeric#var(int[]) */
    public static  double var( int... values ) {return Numeric.var( values );}

    /** @see io.deephaven.function.Numeric#var(long[]) */
    public static  double var( long... values ) {return Numeric.var( values );}

    /** @see io.deephaven.function.Numeric#var(java.lang.Byte[]) */
    public static  double var( java.lang.Byte[] values ) {return Numeric.var( values );}

    /** @see io.deephaven.function.Numeric#var(java.lang.Double[]) */
    public static  double var( java.lang.Double[] values ) {return Numeric.var( values );}

    /** @see io.deephaven.function.Numeric#var(java.lang.Float[]) */
    public static  double var( java.lang.Float[] values ) {return Numeric.var( values );}

    /** @see io.deephaven.function.Numeric#var(java.lang.Integer[]) */
    public static  double var( java.lang.Integer[] values ) {return Numeric.var( values );}

    /** @see io.deephaven.function.Numeric#var(java.lang.Long[]) */
    public static  double var( java.lang.Long[] values ) {return Numeric.var( values );}

    /** @see io.deephaven.function.Numeric#var(java.lang.Short[]) */
    public static  double var( java.lang.Short[] values ) {return Numeric.var( values );}

    /** @see io.deephaven.function.Numeric#var(short[]) */
    public static  double var( short... values ) {return Numeric.var( values );}

    /** @see io.deephaven.function.Numeric#var(io.deephaven.vector.ByteVector) */
    public static  double var( io.deephaven.vector.ByteVector values ) {return Numeric.var( values );}

    /** @see io.deephaven.function.Numeric#var(io.deephaven.vector.DoubleVector) */
    public static  double var( io.deephaven.vector.DoubleVector values ) {return Numeric.var( values );}

    /** @see io.deephaven.function.Numeric#var(io.deephaven.vector.FloatVector) */
    public static  double var( io.deephaven.vector.FloatVector values ) {return Numeric.var( values );}

    /** @see io.deephaven.function.Numeric#var(io.deephaven.vector.IntVector) */
    public static  double var( io.deephaven.vector.IntVector values ) {return Numeric.var( values );}

    /** @see io.deephaven.function.Numeric#var(io.deephaven.vector.LongVector) */
    public static  double var( io.deephaven.vector.LongVector values ) {return Numeric.var( values );}

    /** @see io.deephaven.function.Numeric#var(io.deephaven.vector.ShortVector) */
    public static  double var( io.deephaven.vector.ShortVector values ) {return Numeric.var( values );}

    /** @see io.deephaven.function.Basic#vec(byte[]) */
    public static  io.deephaven.vector.ByteVector vec( byte... values ) {return Basic.vec( values );}

    /** @see io.deephaven.function.Basic#vec(char[]) */
    public static  io.deephaven.vector.CharVector vec( char... values ) {return Basic.vec( values );}

    /** @see io.deephaven.function.Basic#vec(double[]) */
    public static  io.deephaven.vector.DoubleVector vec( double... values ) {return Basic.vec( values );}

    /** @see io.deephaven.function.Basic#vec(float[]) */
    public static  io.deephaven.vector.FloatVector vec( float... values ) {return Basic.vec( values );}

    /** @see io.deephaven.function.Basic#vec(int[]) */
    public static  io.deephaven.vector.IntVector vec( int... values ) {return Basic.vec( values );}

    /** @see io.deephaven.function.Basic#vec(long[]) */
    public static  io.deephaven.vector.LongVector vec( long... values ) {return Basic.vec( values );}

    /** @see io.deephaven.function.Basic#vec(short[]) */
    public static  io.deephaven.vector.ShortVector vec( short... values ) {return Basic.vec( values );}

    /** @see io.deephaven.function.Basic#vecObj(java.lang.Object[]) */
    public static  io.deephaven.vector.ObjectVector vecObj( T... values ) {return Basic.vecObj( values );}

    /** @see io.deephaven.function.Numeric#wavg(byte[],byte[]) */
    public static  double wavg( byte[] values, byte[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(byte[],double[]) */
    public static  double wavg( byte[] values, double[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(byte[],float[]) */
    public static  double wavg( byte[] values, float[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(byte[],int[]) */
    public static  double wavg( byte[] values, int[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(byte[],long[]) */
    public static  double wavg( byte[] values, long[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(byte[],short[]) */
    public static  double wavg( byte[] values, short[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(byte[],io.deephaven.vector.ByteVector) */
    public static  double wavg( byte[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(byte[],io.deephaven.vector.DoubleVector) */
    public static  double wavg( byte[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(byte[],io.deephaven.vector.FloatVector) */
    public static  double wavg( byte[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(byte[],io.deephaven.vector.IntVector) */
    public static  double wavg( byte[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(byte[],io.deephaven.vector.LongVector) */
    public static  double wavg( byte[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(byte[],io.deephaven.vector.ShortVector) */
    public static  double wavg( byte[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(double[],byte[]) */
    public static  double wavg( double[] values, byte[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(double[],double[]) */
    public static  double wavg( double[] values, double[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(double[],float[]) */
    public static  double wavg( double[] values, float[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(double[],int[]) */
    public static  double wavg( double[] values, int[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(double[],long[]) */
    public static  double wavg( double[] values, long[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(double[],short[]) */
    public static  double wavg( double[] values, short[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(double[],io.deephaven.vector.ByteVector) */
    public static  double wavg( double[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(double[],io.deephaven.vector.DoubleVector) */
    public static  double wavg( double[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(double[],io.deephaven.vector.FloatVector) */
    public static  double wavg( double[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(double[],io.deephaven.vector.IntVector) */
    public static  double wavg( double[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(double[],io.deephaven.vector.LongVector) */
    public static  double wavg( double[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(double[],io.deephaven.vector.ShortVector) */
    public static  double wavg( double[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(float[],byte[]) */
    public static  double wavg( float[] values, byte[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(float[],double[]) */
    public static  double wavg( float[] values, double[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(float[],float[]) */
    public static  double wavg( float[] values, float[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(float[],int[]) */
    public static  double wavg( float[] values, int[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(float[],long[]) */
    public static  double wavg( float[] values, long[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(float[],short[]) */
    public static  double wavg( float[] values, short[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(float[],io.deephaven.vector.ByteVector) */
    public static  double wavg( float[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(float[],io.deephaven.vector.DoubleVector) */
    public static  double wavg( float[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(float[],io.deephaven.vector.FloatVector) */
    public static  double wavg( float[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(float[],io.deephaven.vector.IntVector) */
    public static  double wavg( float[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(float[],io.deephaven.vector.LongVector) */
    public static  double wavg( float[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(float[],io.deephaven.vector.ShortVector) */
    public static  double wavg( float[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(int[],byte[]) */
    public static  double wavg( int[] values, byte[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(int[],double[]) */
    public static  double wavg( int[] values, double[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(int[],float[]) */
    public static  double wavg( int[] values, float[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(int[],int[]) */
    public static  double wavg( int[] values, int[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(int[],long[]) */
    public static  double wavg( int[] values, long[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(int[],short[]) */
    public static  double wavg( int[] values, short[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(int[],io.deephaven.vector.ByteVector) */
    public static  double wavg( int[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(int[],io.deephaven.vector.DoubleVector) */
    public static  double wavg( int[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(int[],io.deephaven.vector.FloatVector) */
    public static  double wavg( int[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(int[],io.deephaven.vector.IntVector) */
    public static  double wavg( int[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(int[],io.deephaven.vector.LongVector) */
    public static  double wavg( int[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(int[],io.deephaven.vector.ShortVector) */
    public static  double wavg( int[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(long[],byte[]) */
    public static  double wavg( long[] values, byte[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(long[],double[]) */
    public static  double wavg( long[] values, double[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(long[],float[]) */
    public static  double wavg( long[] values, float[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(long[],int[]) */
    public static  double wavg( long[] values, int[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(long[],long[]) */
    public static  double wavg( long[] values, long[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(long[],short[]) */
    public static  double wavg( long[] values, short[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(long[],io.deephaven.vector.ByteVector) */
    public static  double wavg( long[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(long[],io.deephaven.vector.DoubleVector) */
    public static  double wavg( long[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(long[],io.deephaven.vector.FloatVector) */
    public static  double wavg( long[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(long[],io.deephaven.vector.IntVector) */
    public static  double wavg( long[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(long[],io.deephaven.vector.LongVector) */
    public static  double wavg( long[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(long[],io.deephaven.vector.ShortVector) */
    public static  double wavg( long[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(short[],byte[]) */
    public static  double wavg( short[] values, byte[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(short[],double[]) */
    public static  double wavg( short[] values, double[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(short[],float[]) */
    public static  double wavg( short[] values, float[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(short[],int[]) */
    public static  double wavg( short[] values, int[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(short[],long[]) */
    public static  double wavg( short[] values, long[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(short[],short[]) */
    public static  double wavg( short[] values, short[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(short[],io.deephaven.vector.ByteVector) */
    public static  double wavg( short[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(short[],io.deephaven.vector.DoubleVector) */
    public static  double wavg( short[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(short[],io.deephaven.vector.FloatVector) */
    public static  double wavg( short[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(short[],io.deephaven.vector.IntVector) */
    public static  double wavg( short[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(short[],io.deephaven.vector.LongVector) */
    public static  double wavg( short[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(short[],io.deephaven.vector.ShortVector) */
    public static  double wavg( short[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.ByteVector,byte[]) */
    public static  double wavg( io.deephaven.vector.ByteVector values, byte[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.ByteVector,double[]) */
    public static  double wavg( io.deephaven.vector.ByteVector values, double[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.ByteVector,float[]) */
    public static  double wavg( io.deephaven.vector.ByteVector values, float[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.ByteVector,int[]) */
    public static  double wavg( io.deephaven.vector.ByteVector values, int[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.ByteVector,long[]) */
    public static  double wavg( io.deephaven.vector.ByteVector values, long[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.ByteVector,short[]) */
    public static  double wavg( io.deephaven.vector.ByteVector values, short[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.ByteVector,io.deephaven.vector.ByteVector) */
    public static  double wavg( io.deephaven.vector.ByteVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.ByteVector,io.deephaven.vector.DoubleVector) */
    public static  double wavg( io.deephaven.vector.ByteVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.ByteVector,io.deephaven.vector.FloatVector) */
    public static  double wavg( io.deephaven.vector.ByteVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.ByteVector,io.deephaven.vector.IntVector) */
    public static  double wavg( io.deephaven.vector.ByteVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.ByteVector,io.deephaven.vector.LongVector) */
    public static  double wavg( io.deephaven.vector.ByteVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.ByteVector,io.deephaven.vector.ShortVector) */
    public static  double wavg( io.deephaven.vector.ByteVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.DoubleVector,byte[]) */
    public static  double wavg( io.deephaven.vector.DoubleVector values, byte[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.DoubleVector,double[]) */
    public static  double wavg( io.deephaven.vector.DoubleVector values, double[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.DoubleVector,float[]) */
    public static  double wavg( io.deephaven.vector.DoubleVector values, float[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.DoubleVector,int[]) */
    public static  double wavg( io.deephaven.vector.DoubleVector values, int[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.DoubleVector,long[]) */
    public static  double wavg( io.deephaven.vector.DoubleVector values, long[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.DoubleVector,short[]) */
    public static  double wavg( io.deephaven.vector.DoubleVector values, short[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.DoubleVector,io.deephaven.vector.ByteVector) */
    public static  double wavg( io.deephaven.vector.DoubleVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.DoubleVector,io.deephaven.vector.DoubleVector) */
    public static  double wavg( io.deephaven.vector.DoubleVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.DoubleVector,io.deephaven.vector.FloatVector) */
    public static  double wavg( io.deephaven.vector.DoubleVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.DoubleVector,io.deephaven.vector.IntVector) */
    public static  double wavg( io.deephaven.vector.DoubleVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.DoubleVector,io.deephaven.vector.LongVector) */
    public static  double wavg( io.deephaven.vector.DoubleVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.DoubleVector,io.deephaven.vector.ShortVector) */
    public static  double wavg( io.deephaven.vector.DoubleVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.FloatVector,byte[]) */
    public static  double wavg( io.deephaven.vector.FloatVector values, byte[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.FloatVector,double[]) */
    public static  double wavg( io.deephaven.vector.FloatVector values, double[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.FloatVector,float[]) */
    public static  double wavg( io.deephaven.vector.FloatVector values, float[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.FloatVector,int[]) */
    public static  double wavg( io.deephaven.vector.FloatVector values, int[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.FloatVector,long[]) */
    public static  double wavg( io.deephaven.vector.FloatVector values, long[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.FloatVector,short[]) */
    public static  double wavg( io.deephaven.vector.FloatVector values, short[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.FloatVector,io.deephaven.vector.ByteVector) */
    public static  double wavg( io.deephaven.vector.FloatVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.FloatVector,io.deephaven.vector.DoubleVector) */
    public static  double wavg( io.deephaven.vector.FloatVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.FloatVector,io.deephaven.vector.FloatVector) */
    public static  double wavg( io.deephaven.vector.FloatVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.FloatVector,io.deephaven.vector.IntVector) */
    public static  double wavg( io.deephaven.vector.FloatVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.FloatVector,io.deephaven.vector.LongVector) */
    public static  double wavg( io.deephaven.vector.FloatVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.FloatVector,io.deephaven.vector.ShortVector) */
    public static  double wavg( io.deephaven.vector.FloatVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.IntVector,byte[]) */
    public static  double wavg( io.deephaven.vector.IntVector values, byte[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.IntVector,double[]) */
    public static  double wavg( io.deephaven.vector.IntVector values, double[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.IntVector,float[]) */
    public static  double wavg( io.deephaven.vector.IntVector values, float[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.IntVector,int[]) */
    public static  double wavg( io.deephaven.vector.IntVector values, int[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.IntVector,long[]) */
    public static  double wavg( io.deephaven.vector.IntVector values, long[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.IntVector,short[]) */
    public static  double wavg( io.deephaven.vector.IntVector values, short[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.IntVector,io.deephaven.vector.ByteVector) */
    public static  double wavg( io.deephaven.vector.IntVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.IntVector,io.deephaven.vector.DoubleVector) */
    public static  double wavg( io.deephaven.vector.IntVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.IntVector,io.deephaven.vector.FloatVector) */
    public static  double wavg( io.deephaven.vector.IntVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.IntVector,io.deephaven.vector.IntVector) */
    public static  double wavg( io.deephaven.vector.IntVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.IntVector,io.deephaven.vector.LongVector) */
    public static  double wavg( io.deephaven.vector.IntVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.IntVector,io.deephaven.vector.ShortVector) */
    public static  double wavg( io.deephaven.vector.IntVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.LongVector,byte[]) */
    public static  double wavg( io.deephaven.vector.LongVector values, byte[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.LongVector,double[]) */
    public static  double wavg( io.deephaven.vector.LongVector values, double[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.LongVector,float[]) */
    public static  double wavg( io.deephaven.vector.LongVector values, float[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.LongVector,int[]) */
    public static  double wavg( io.deephaven.vector.LongVector values, int[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.LongVector,long[]) */
    public static  double wavg( io.deephaven.vector.LongVector values, long[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.LongVector,short[]) */
    public static  double wavg( io.deephaven.vector.LongVector values, short[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.LongVector,io.deephaven.vector.ByteVector) */
    public static  double wavg( io.deephaven.vector.LongVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.LongVector,io.deephaven.vector.DoubleVector) */
    public static  double wavg( io.deephaven.vector.LongVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.LongVector,io.deephaven.vector.FloatVector) */
    public static  double wavg( io.deephaven.vector.LongVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.LongVector,io.deephaven.vector.IntVector) */
    public static  double wavg( io.deephaven.vector.LongVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.LongVector,io.deephaven.vector.LongVector) */
    public static  double wavg( io.deephaven.vector.LongVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.LongVector,io.deephaven.vector.ShortVector) */
    public static  double wavg( io.deephaven.vector.LongVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.ShortVector,byte[]) */
    public static  double wavg( io.deephaven.vector.ShortVector values, byte[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.ShortVector,double[]) */
    public static  double wavg( io.deephaven.vector.ShortVector values, double[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.ShortVector,float[]) */
    public static  double wavg( io.deephaven.vector.ShortVector values, float[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.ShortVector,int[]) */
    public static  double wavg( io.deephaven.vector.ShortVector values, int[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.ShortVector,long[]) */
    public static  double wavg( io.deephaven.vector.ShortVector values, long[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.ShortVector,short[]) */
    public static  double wavg( io.deephaven.vector.ShortVector values, short[] weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.ShortVector,io.deephaven.vector.ByteVector) */
    public static  double wavg( io.deephaven.vector.ShortVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.ShortVector,io.deephaven.vector.DoubleVector) */
    public static  double wavg( io.deephaven.vector.ShortVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.ShortVector,io.deephaven.vector.FloatVector) */
    public static  double wavg( io.deephaven.vector.ShortVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.ShortVector,io.deephaven.vector.IntVector) */
    public static  double wavg( io.deephaven.vector.ShortVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.ShortVector,io.deephaven.vector.LongVector) */
    public static  double wavg( io.deephaven.vector.ShortVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wavg(io.deephaven.vector.ShortVector,io.deephaven.vector.ShortVector) */
    public static  double wavg( io.deephaven.vector.ShortVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wavg( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(byte[],byte[]) */
    public static  double wstd( byte[] values, byte[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(byte[],double[]) */
    public static  double wstd( byte[] values, double[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(byte[],float[]) */
    public static  double wstd( byte[] values, float[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(byte[],int[]) */
    public static  double wstd( byte[] values, int[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(byte[],long[]) */
    public static  double wstd( byte[] values, long[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(byte[],short[]) */
    public static  double wstd( byte[] values, short[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(byte[],io.deephaven.vector.ByteVector) */
    public static  double wstd( byte[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(byte[],io.deephaven.vector.DoubleVector) */
    public static  double wstd( byte[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(byte[],io.deephaven.vector.FloatVector) */
    public static  double wstd( byte[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(byte[],io.deephaven.vector.IntVector) */
    public static  double wstd( byte[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(byte[],io.deephaven.vector.LongVector) */
    public static  double wstd( byte[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(byte[],io.deephaven.vector.ShortVector) */
    public static  double wstd( byte[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(double[],byte[]) */
    public static  double wstd( double[] values, byte[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(double[],double[]) */
    public static  double wstd( double[] values, double[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(double[],float[]) */
    public static  double wstd( double[] values, float[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(double[],int[]) */
    public static  double wstd( double[] values, int[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(double[],long[]) */
    public static  double wstd( double[] values, long[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(double[],short[]) */
    public static  double wstd( double[] values, short[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(double[],io.deephaven.vector.ByteVector) */
    public static  double wstd( double[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(double[],io.deephaven.vector.DoubleVector) */
    public static  double wstd( double[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(double[],io.deephaven.vector.FloatVector) */
    public static  double wstd( double[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(double[],io.deephaven.vector.IntVector) */
    public static  double wstd( double[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(double[],io.deephaven.vector.LongVector) */
    public static  double wstd( double[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(double[],io.deephaven.vector.ShortVector) */
    public static  double wstd( double[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(float[],byte[]) */
    public static  double wstd( float[] values, byte[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(float[],double[]) */
    public static  double wstd( float[] values, double[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(float[],float[]) */
    public static  double wstd( float[] values, float[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(float[],int[]) */
    public static  double wstd( float[] values, int[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(float[],long[]) */
    public static  double wstd( float[] values, long[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(float[],short[]) */
    public static  double wstd( float[] values, short[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(float[],io.deephaven.vector.ByteVector) */
    public static  double wstd( float[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(float[],io.deephaven.vector.DoubleVector) */
    public static  double wstd( float[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(float[],io.deephaven.vector.FloatVector) */
    public static  double wstd( float[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(float[],io.deephaven.vector.IntVector) */
    public static  double wstd( float[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(float[],io.deephaven.vector.LongVector) */
    public static  double wstd( float[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(float[],io.deephaven.vector.ShortVector) */
    public static  double wstd( float[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(int[],byte[]) */
    public static  double wstd( int[] values, byte[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(int[],double[]) */
    public static  double wstd( int[] values, double[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(int[],float[]) */
    public static  double wstd( int[] values, float[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(int[],int[]) */
    public static  double wstd( int[] values, int[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(int[],long[]) */
    public static  double wstd( int[] values, long[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(int[],short[]) */
    public static  double wstd( int[] values, short[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(int[],io.deephaven.vector.ByteVector) */
    public static  double wstd( int[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(int[],io.deephaven.vector.DoubleVector) */
    public static  double wstd( int[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(int[],io.deephaven.vector.FloatVector) */
    public static  double wstd( int[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(int[],io.deephaven.vector.IntVector) */
    public static  double wstd( int[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(int[],io.deephaven.vector.LongVector) */
    public static  double wstd( int[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(int[],io.deephaven.vector.ShortVector) */
    public static  double wstd( int[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(long[],byte[]) */
    public static  double wstd( long[] values, byte[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(long[],double[]) */
    public static  double wstd( long[] values, double[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(long[],float[]) */
    public static  double wstd( long[] values, float[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(long[],int[]) */
    public static  double wstd( long[] values, int[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(long[],long[]) */
    public static  double wstd( long[] values, long[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(long[],short[]) */
    public static  double wstd( long[] values, short[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(long[],io.deephaven.vector.ByteVector) */
    public static  double wstd( long[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(long[],io.deephaven.vector.DoubleVector) */
    public static  double wstd( long[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(long[],io.deephaven.vector.FloatVector) */
    public static  double wstd( long[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(long[],io.deephaven.vector.IntVector) */
    public static  double wstd( long[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(long[],io.deephaven.vector.LongVector) */
    public static  double wstd( long[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(long[],io.deephaven.vector.ShortVector) */
    public static  double wstd( long[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(short[],byte[]) */
    public static  double wstd( short[] values, byte[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(short[],double[]) */
    public static  double wstd( short[] values, double[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(short[],float[]) */
    public static  double wstd( short[] values, float[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(short[],int[]) */
    public static  double wstd( short[] values, int[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(short[],long[]) */
    public static  double wstd( short[] values, long[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(short[],short[]) */
    public static  double wstd( short[] values, short[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(short[],io.deephaven.vector.ByteVector) */
    public static  double wstd( short[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(short[],io.deephaven.vector.DoubleVector) */
    public static  double wstd( short[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(short[],io.deephaven.vector.FloatVector) */
    public static  double wstd( short[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(short[],io.deephaven.vector.IntVector) */
    public static  double wstd( short[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(short[],io.deephaven.vector.LongVector) */
    public static  double wstd( short[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(short[],io.deephaven.vector.ShortVector) */
    public static  double wstd( short[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.ByteVector,byte[]) */
    public static  double wstd( io.deephaven.vector.ByteVector values, byte[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.ByteVector,double[]) */
    public static  double wstd( io.deephaven.vector.ByteVector values, double[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.ByteVector,float[]) */
    public static  double wstd( io.deephaven.vector.ByteVector values, float[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.ByteVector,int[]) */
    public static  double wstd( io.deephaven.vector.ByteVector values, int[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.ByteVector,long[]) */
    public static  double wstd( io.deephaven.vector.ByteVector values, long[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.ByteVector,short[]) */
    public static  double wstd( io.deephaven.vector.ByteVector values, short[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.ByteVector,io.deephaven.vector.ByteVector) */
    public static  double wstd( io.deephaven.vector.ByteVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.ByteVector,io.deephaven.vector.DoubleVector) */
    public static  double wstd( io.deephaven.vector.ByteVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.ByteVector,io.deephaven.vector.FloatVector) */
    public static  double wstd( io.deephaven.vector.ByteVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.ByteVector,io.deephaven.vector.IntVector) */
    public static  double wstd( io.deephaven.vector.ByteVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.ByteVector,io.deephaven.vector.LongVector) */
    public static  double wstd( io.deephaven.vector.ByteVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.ByteVector,io.deephaven.vector.ShortVector) */
    public static  double wstd( io.deephaven.vector.ByteVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.DoubleVector,byte[]) */
    public static  double wstd( io.deephaven.vector.DoubleVector values, byte[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.DoubleVector,double[]) */
    public static  double wstd( io.deephaven.vector.DoubleVector values, double[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.DoubleVector,float[]) */
    public static  double wstd( io.deephaven.vector.DoubleVector values, float[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.DoubleVector,int[]) */
    public static  double wstd( io.deephaven.vector.DoubleVector values, int[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.DoubleVector,long[]) */
    public static  double wstd( io.deephaven.vector.DoubleVector values, long[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.DoubleVector,short[]) */
    public static  double wstd( io.deephaven.vector.DoubleVector values, short[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.DoubleVector,io.deephaven.vector.ByteVector) */
    public static  double wstd( io.deephaven.vector.DoubleVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.DoubleVector,io.deephaven.vector.DoubleVector) */
    public static  double wstd( io.deephaven.vector.DoubleVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.DoubleVector,io.deephaven.vector.FloatVector) */
    public static  double wstd( io.deephaven.vector.DoubleVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.DoubleVector,io.deephaven.vector.IntVector) */
    public static  double wstd( io.deephaven.vector.DoubleVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.DoubleVector,io.deephaven.vector.LongVector) */
    public static  double wstd( io.deephaven.vector.DoubleVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.DoubleVector,io.deephaven.vector.ShortVector) */
    public static  double wstd( io.deephaven.vector.DoubleVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.FloatVector,byte[]) */
    public static  double wstd( io.deephaven.vector.FloatVector values, byte[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.FloatVector,double[]) */
    public static  double wstd( io.deephaven.vector.FloatVector values, double[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.FloatVector,float[]) */
    public static  double wstd( io.deephaven.vector.FloatVector values, float[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.FloatVector,int[]) */
    public static  double wstd( io.deephaven.vector.FloatVector values, int[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.FloatVector,long[]) */
    public static  double wstd( io.deephaven.vector.FloatVector values, long[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.FloatVector,short[]) */
    public static  double wstd( io.deephaven.vector.FloatVector values, short[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.FloatVector,io.deephaven.vector.ByteVector) */
    public static  double wstd( io.deephaven.vector.FloatVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.FloatVector,io.deephaven.vector.DoubleVector) */
    public static  double wstd( io.deephaven.vector.FloatVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.FloatVector,io.deephaven.vector.FloatVector) */
    public static  double wstd( io.deephaven.vector.FloatVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.FloatVector,io.deephaven.vector.IntVector) */
    public static  double wstd( io.deephaven.vector.FloatVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.FloatVector,io.deephaven.vector.LongVector) */
    public static  double wstd( io.deephaven.vector.FloatVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.FloatVector,io.deephaven.vector.ShortVector) */
    public static  double wstd( io.deephaven.vector.FloatVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.IntVector,byte[]) */
    public static  double wstd( io.deephaven.vector.IntVector values, byte[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.IntVector,double[]) */
    public static  double wstd( io.deephaven.vector.IntVector values, double[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.IntVector,float[]) */
    public static  double wstd( io.deephaven.vector.IntVector values, float[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.IntVector,int[]) */
    public static  double wstd( io.deephaven.vector.IntVector values, int[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.IntVector,long[]) */
    public static  double wstd( io.deephaven.vector.IntVector values, long[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.IntVector,short[]) */
    public static  double wstd( io.deephaven.vector.IntVector values, short[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.IntVector,io.deephaven.vector.ByteVector) */
    public static  double wstd( io.deephaven.vector.IntVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.IntVector,io.deephaven.vector.DoubleVector) */
    public static  double wstd( io.deephaven.vector.IntVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.IntVector,io.deephaven.vector.FloatVector) */
    public static  double wstd( io.deephaven.vector.IntVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.IntVector,io.deephaven.vector.IntVector) */
    public static  double wstd( io.deephaven.vector.IntVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.IntVector,io.deephaven.vector.LongVector) */
    public static  double wstd( io.deephaven.vector.IntVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.IntVector,io.deephaven.vector.ShortVector) */
    public static  double wstd( io.deephaven.vector.IntVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.LongVector,byte[]) */
    public static  double wstd( io.deephaven.vector.LongVector values, byte[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.LongVector,double[]) */
    public static  double wstd( io.deephaven.vector.LongVector values, double[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.LongVector,float[]) */
    public static  double wstd( io.deephaven.vector.LongVector values, float[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.LongVector,int[]) */
    public static  double wstd( io.deephaven.vector.LongVector values, int[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.LongVector,long[]) */
    public static  double wstd( io.deephaven.vector.LongVector values, long[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.LongVector,short[]) */
    public static  double wstd( io.deephaven.vector.LongVector values, short[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.LongVector,io.deephaven.vector.ByteVector) */
    public static  double wstd( io.deephaven.vector.LongVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.LongVector,io.deephaven.vector.DoubleVector) */
    public static  double wstd( io.deephaven.vector.LongVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.LongVector,io.deephaven.vector.FloatVector) */
    public static  double wstd( io.deephaven.vector.LongVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.LongVector,io.deephaven.vector.IntVector) */
    public static  double wstd( io.deephaven.vector.LongVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.LongVector,io.deephaven.vector.LongVector) */
    public static  double wstd( io.deephaven.vector.LongVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.LongVector,io.deephaven.vector.ShortVector) */
    public static  double wstd( io.deephaven.vector.LongVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.ShortVector,byte[]) */
    public static  double wstd( io.deephaven.vector.ShortVector values, byte[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.ShortVector,double[]) */
    public static  double wstd( io.deephaven.vector.ShortVector values, double[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.ShortVector,float[]) */
    public static  double wstd( io.deephaven.vector.ShortVector values, float[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.ShortVector,int[]) */
    public static  double wstd( io.deephaven.vector.ShortVector values, int[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.ShortVector,long[]) */
    public static  double wstd( io.deephaven.vector.ShortVector values, long[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.ShortVector,short[]) */
    public static  double wstd( io.deephaven.vector.ShortVector values, short[] weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.ShortVector,io.deephaven.vector.ByteVector) */
    public static  double wstd( io.deephaven.vector.ShortVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.ShortVector,io.deephaven.vector.DoubleVector) */
    public static  double wstd( io.deephaven.vector.ShortVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.ShortVector,io.deephaven.vector.FloatVector) */
    public static  double wstd( io.deephaven.vector.ShortVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.ShortVector,io.deephaven.vector.IntVector) */
    public static  double wstd( io.deephaven.vector.ShortVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.ShortVector,io.deephaven.vector.LongVector) */
    public static  double wstd( io.deephaven.vector.ShortVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wstd(io.deephaven.vector.ShortVector,io.deephaven.vector.ShortVector) */
    public static  double wstd( io.deephaven.vector.ShortVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wstd( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(byte[],byte[]) */
    public static  double wste( byte[] values, byte[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(byte[],double[]) */
    public static  double wste( byte[] values, double[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(byte[],float[]) */
    public static  double wste( byte[] values, float[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(byte[],int[]) */
    public static  double wste( byte[] values, int[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(byte[],long[]) */
    public static  double wste( byte[] values, long[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(byte[],short[]) */
    public static  double wste( byte[] values, short[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(byte[],io.deephaven.vector.ByteVector) */
    public static  double wste( byte[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(byte[],io.deephaven.vector.DoubleVector) */
    public static  double wste( byte[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(byte[],io.deephaven.vector.FloatVector) */
    public static  double wste( byte[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(byte[],io.deephaven.vector.IntVector) */
    public static  double wste( byte[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(byte[],io.deephaven.vector.LongVector) */
    public static  double wste( byte[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(byte[],io.deephaven.vector.ShortVector) */
    public static  double wste( byte[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(double[],byte[]) */
    public static  double wste( double[] values, byte[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(double[],double[]) */
    public static  double wste( double[] values, double[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(double[],float[]) */
    public static  double wste( double[] values, float[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(double[],int[]) */
    public static  double wste( double[] values, int[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(double[],long[]) */
    public static  double wste( double[] values, long[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(double[],short[]) */
    public static  double wste( double[] values, short[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(double[],io.deephaven.vector.ByteVector) */
    public static  double wste( double[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(double[],io.deephaven.vector.DoubleVector) */
    public static  double wste( double[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(double[],io.deephaven.vector.FloatVector) */
    public static  double wste( double[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(double[],io.deephaven.vector.IntVector) */
    public static  double wste( double[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(double[],io.deephaven.vector.LongVector) */
    public static  double wste( double[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(double[],io.deephaven.vector.ShortVector) */
    public static  double wste( double[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(float[],byte[]) */
    public static  double wste( float[] values, byte[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(float[],double[]) */
    public static  double wste( float[] values, double[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(float[],float[]) */
    public static  double wste( float[] values, float[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(float[],int[]) */
    public static  double wste( float[] values, int[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(float[],long[]) */
    public static  double wste( float[] values, long[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(float[],short[]) */
    public static  double wste( float[] values, short[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(float[],io.deephaven.vector.ByteVector) */
    public static  double wste( float[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(float[],io.deephaven.vector.DoubleVector) */
    public static  double wste( float[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(float[],io.deephaven.vector.FloatVector) */
    public static  double wste( float[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(float[],io.deephaven.vector.IntVector) */
    public static  double wste( float[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(float[],io.deephaven.vector.LongVector) */
    public static  double wste( float[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(float[],io.deephaven.vector.ShortVector) */
    public static  double wste( float[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(int[],byte[]) */
    public static  double wste( int[] values, byte[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(int[],double[]) */
    public static  double wste( int[] values, double[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(int[],float[]) */
    public static  double wste( int[] values, float[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(int[],int[]) */
    public static  double wste( int[] values, int[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(int[],long[]) */
    public static  double wste( int[] values, long[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(int[],short[]) */
    public static  double wste( int[] values, short[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(int[],io.deephaven.vector.ByteVector) */
    public static  double wste( int[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(int[],io.deephaven.vector.DoubleVector) */
    public static  double wste( int[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(int[],io.deephaven.vector.FloatVector) */
    public static  double wste( int[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(int[],io.deephaven.vector.IntVector) */
    public static  double wste( int[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(int[],io.deephaven.vector.LongVector) */
    public static  double wste( int[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(int[],io.deephaven.vector.ShortVector) */
    public static  double wste( int[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(long[],byte[]) */
    public static  double wste( long[] values, byte[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(long[],double[]) */
    public static  double wste( long[] values, double[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(long[],float[]) */
    public static  double wste( long[] values, float[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(long[],int[]) */
    public static  double wste( long[] values, int[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(long[],long[]) */
    public static  double wste( long[] values, long[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(long[],short[]) */
    public static  double wste( long[] values, short[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(long[],io.deephaven.vector.ByteVector) */
    public static  double wste( long[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(long[],io.deephaven.vector.DoubleVector) */
    public static  double wste( long[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(long[],io.deephaven.vector.FloatVector) */
    public static  double wste( long[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(long[],io.deephaven.vector.IntVector) */
    public static  double wste( long[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(long[],io.deephaven.vector.LongVector) */
    public static  double wste( long[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(long[],io.deephaven.vector.ShortVector) */
    public static  double wste( long[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(short[],byte[]) */
    public static  double wste( short[] values, byte[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(short[],double[]) */
    public static  double wste( short[] values, double[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(short[],float[]) */
    public static  double wste( short[] values, float[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(short[],int[]) */
    public static  double wste( short[] values, int[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(short[],long[]) */
    public static  double wste( short[] values, long[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(short[],short[]) */
    public static  double wste( short[] values, short[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(short[],io.deephaven.vector.ByteVector) */
    public static  double wste( short[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(short[],io.deephaven.vector.DoubleVector) */
    public static  double wste( short[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(short[],io.deephaven.vector.FloatVector) */
    public static  double wste( short[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(short[],io.deephaven.vector.IntVector) */
    public static  double wste( short[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(short[],io.deephaven.vector.LongVector) */
    public static  double wste( short[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(short[],io.deephaven.vector.ShortVector) */
    public static  double wste( short[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.ByteVector,byte[]) */
    public static  double wste( io.deephaven.vector.ByteVector values, byte[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.ByteVector,double[]) */
    public static  double wste( io.deephaven.vector.ByteVector values, double[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.ByteVector,float[]) */
    public static  double wste( io.deephaven.vector.ByteVector values, float[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.ByteVector,int[]) */
    public static  double wste( io.deephaven.vector.ByteVector values, int[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.ByteVector,long[]) */
    public static  double wste( io.deephaven.vector.ByteVector values, long[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.ByteVector,short[]) */
    public static  double wste( io.deephaven.vector.ByteVector values, short[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.ByteVector,io.deephaven.vector.ByteVector) */
    public static  double wste( io.deephaven.vector.ByteVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.ByteVector,io.deephaven.vector.DoubleVector) */
    public static  double wste( io.deephaven.vector.ByteVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.ByteVector,io.deephaven.vector.FloatVector) */
    public static  double wste( io.deephaven.vector.ByteVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.ByteVector,io.deephaven.vector.IntVector) */
    public static  double wste( io.deephaven.vector.ByteVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.ByteVector,io.deephaven.vector.LongVector) */
    public static  double wste( io.deephaven.vector.ByteVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.ByteVector,io.deephaven.vector.ShortVector) */
    public static  double wste( io.deephaven.vector.ByteVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.DoubleVector,byte[]) */
    public static  double wste( io.deephaven.vector.DoubleVector values, byte[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.DoubleVector,double[]) */
    public static  double wste( io.deephaven.vector.DoubleVector values, double[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.DoubleVector,float[]) */
    public static  double wste( io.deephaven.vector.DoubleVector values, float[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.DoubleVector,int[]) */
    public static  double wste( io.deephaven.vector.DoubleVector values, int[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.DoubleVector,long[]) */
    public static  double wste( io.deephaven.vector.DoubleVector values, long[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.DoubleVector,short[]) */
    public static  double wste( io.deephaven.vector.DoubleVector values, short[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.DoubleVector,io.deephaven.vector.ByteVector) */
    public static  double wste( io.deephaven.vector.DoubleVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.DoubleVector,io.deephaven.vector.DoubleVector) */
    public static  double wste( io.deephaven.vector.DoubleVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.DoubleVector,io.deephaven.vector.FloatVector) */
    public static  double wste( io.deephaven.vector.DoubleVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.DoubleVector,io.deephaven.vector.IntVector) */
    public static  double wste( io.deephaven.vector.DoubleVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.DoubleVector,io.deephaven.vector.LongVector) */
    public static  double wste( io.deephaven.vector.DoubleVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.DoubleVector,io.deephaven.vector.ShortVector) */
    public static  double wste( io.deephaven.vector.DoubleVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.FloatVector,byte[]) */
    public static  double wste( io.deephaven.vector.FloatVector values, byte[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.FloatVector,double[]) */
    public static  double wste( io.deephaven.vector.FloatVector values, double[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.FloatVector,float[]) */
    public static  double wste( io.deephaven.vector.FloatVector values, float[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.FloatVector,int[]) */
    public static  double wste( io.deephaven.vector.FloatVector values, int[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.FloatVector,long[]) */
    public static  double wste( io.deephaven.vector.FloatVector values, long[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.FloatVector,short[]) */
    public static  double wste( io.deephaven.vector.FloatVector values, short[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.FloatVector,io.deephaven.vector.ByteVector) */
    public static  double wste( io.deephaven.vector.FloatVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.FloatVector,io.deephaven.vector.DoubleVector) */
    public static  double wste( io.deephaven.vector.FloatVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.FloatVector,io.deephaven.vector.FloatVector) */
    public static  double wste( io.deephaven.vector.FloatVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.FloatVector,io.deephaven.vector.IntVector) */
    public static  double wste( io.deephaven.vector.FloatVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.FloatVector,io.deephaven.vector.LongVector) */
    public static  double wste( io.deephaven.vector.FloatVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.FloatVector,io.deephaven.vector.ShortVector) */
    public static  double wste( io.deephaven.vector.FloatVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.IntVector,byte[]) */
    public static  double wste( io.deephaven.vector.IntVector values, byte[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.IntVector,double[]) */
    public static  double wste( io.deephaven.vector.IntVector values, double[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.IntVector,float[]) */
    public static  double wste( io.deephaven.vector.IntVector values, float[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.IntVector,int[]) */
    public static  double wste( io.deephaven.vector.IntVector values, int[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.IntVector,long[]) */
    public static  double wste( io.deephaven.vector.IntVector values, long[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.IntVector,short[]) */
    public static  double wste( io.deephaven.vector.IntVector values, short[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.IntVector,io.deephaven.vector.ByteVector) */
    public static  double wste( io.deephaven.vector.IntVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.IntVector,io.deephaven.vector.DoubleVector) */
    public static  double wste( io.deephaven.vector.IntVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.IntVector,io.deephaven.vector.FloatVector) */
    public static  double wste( io.deephaven.vector.IntVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.IntVector,io.deephaven.vector.IntVector) */
    public static  double wste( io.deephaven.vector.IntVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.IntVector,io.deephaven.vector.LongVector) */
    public static  double wste( io.deephaven.vector.IntVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.IntVector,io.deephaven.vector.ShortVector) */
    public static  double wste( io.deephaven.vector.IntVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.LongVector,byte[]) */
    public static  double wste( io.deephaven.vector.LongVector values, byte[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.LongVector,double[]) */
    public static  double wste( io.deephaven.vector.LongVector values, double[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.LongVector,float[]) */
    public static  double wste( io.deephaven.vector.LongVector values, float[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.LongVector,int[]) */
    public static  double wste( io.deephaven.vector.LongVector values, int[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.LongVector,long[]) */
    public static  double wste( io.deephaven.vector.LongVector values, long[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.LongVector,short[]) */
    public static  double wste( io.deephaven.vector.LongVector values, short[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.LongVector,io.deephaven.vector.ByteVector) */
    public static  double wste( io.deephaven.vector.LongVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.LongVector,io.deephaven.vector.DoubleVector) */
    public static  double wste( io.deephaven.vector.LongVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.LongVector,io.deephaven.vector.FloatVector) */
    public static  double wste( io.deephaven.vector.LongVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.LongVector,io.deephaven.vector.IntVector) */
    public static  double wste( io.deephaven.vector.LongVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.LongVector,io.deephaven.vector.LongVector) */
    public static  double wste( io.deephaven.vector.LongVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.LongVector,io.deephaven.vector.ShortVector) */
    public static  double wste( io.deephaven.vector.LongVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.ShortVector,byte[]) */
    public static  double wste( io.deephaven.vector.ShortVector values, byte[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.ShortVector,double[]) */
    public static  double wste( io.deephaven.vector.ShortVector values, double[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.ShortVector,float[]) */
    public static  double wste( io.deephaven.vector.ShortVector values, float[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.ShortVector,int[]) */
    public static  double wste( io.deephaven.vector.ShortVector values, int[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.ShortVector,long[]) */
    public static  double wste( io.deephaven.vector.ShortVector values, long[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.ShortVector,short[]) */
    public static  double wste( io.deephaven.vector.ShortVector values, short[] weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.ShortVector,io.deephaven.vector.ByteVector) */
    public static  double wste( io.deephaven.vector.ShortVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.ShortVector,io.deephaven.vector.DoubleVector) */
    public static  double wste( io.deephaven.vector.ShortVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.ShortVector,io.deephaven.vector.FloatVector) */
    public static  double wste( io.deephaven.vector.ShortVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.ShortVector,io.deephaven.vector.IntVector) */
    public static  double wste( io.deephaven.vector.ShortVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.ShortVector,io.deephaven.vector.LongVector) */
    public static  double wste( io.deephaven.vector.ShortVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wste(io.deephaven.vector.ShortVector,io.deephaven.vector.ShortVector) */
    public static  double wste( io.deephaven.vector.ShortVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wste( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(byte[],byte[]) */
    public static  double wsum( byte[] values, byte[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(byte[],double[]) */
    public static  double wsum( byte[] values, double[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(byte[],float[]) */
    public static  double wsum( byte[] values, float[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(byte[],int[]) */
    public static  double wsum( byte[] values, int[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(byte[],long[]) */
    public static  double wsum( byte[] values, long[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(byte[],short[]) */
    public static  double wsum( byte[] values, short[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(byte[],io.deephaven.vector.ByteVector) */
    public static  double wsum( byte[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(byte[],io.deephaven.vector.DoubleVector) */
    public static  double wsum( byte[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(byte[],io.deephaven.vector.FloatVector) */
    public static  double wsum( byte[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(byte[],io.deephaven.vector.IntVector) */
    public static  double wsum( byte[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(byte[],io.deephaven.vector.LongVector) */
    public static  double wsum( byte[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(byte[],io.deephaven.vector.ShortVector) */
    public static  double wsum( byte[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(double[],byte[]) */
    public static  double wsum( double[] values, byte[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(double[],double[]) */
    public static  double wsum( double[] values, double[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(double[],float[]) */
    public static  double wsum( double[] values, float[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(double[],int[]) */
    public static  double wsum( double[] values, int[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(double[],long[]) */
    public static  double wsum( double[] values, long[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(double[],short[]) */
    public static  double wsum( double[] values, short[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(double[],io.deephaven.vector.ByteVector) */
    public static  double wsum( double[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(double[],io.deephaven.vector.DoubleVector) */
    public static  double wsum( double[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(double[],io.deephaven.vector.FloatVector) */
    public static  double wsum( double[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(double[],io.deephaven.vector.IntVector) */
    public static  double wsum( double[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(double[],io.deephaven.vector.LongVector) */
    public static  double wsum( double[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(double[],io.deephaven.vector.ShortVector) */
    public static  double wsum( double[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(float[],byte[]) */
    public static  double wsum( float[] values, byte[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(float[],double[]) */
    public static  double wsum( float[] values, double[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(float[],float[]) */
    public static  double wsum( float[] values, float[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(float[],int[]) */
    public static  double wsum( float[] values, int[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(float[],long[]) */
    public static  double wsum( float[] values, long[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(float[],short[]) */
    public static  double wsum( float[] values, short[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(float[],io.deephaven.vector.ByteVector) */
    public static  double wsum( float[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(float[],io.deephaven.vector.DoubleVector) */
    public static  double wsum( float[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(float[],io.deephaven.vector.FloatVector) */
    public static  double wsum( float[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(float[],io.deephaven.vector.IntVector) */
    public static  double wsum( float[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(float[],io.deephaven.vector.LongVector) */
    public static  double wsum( float[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(float[],io.deephaven.vector.ShortVector) */
    public static  double wsum( float[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(int[],byte[]) */
    public static  double wsum( int[] values, byte[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(int[],double[]) */
    public static  double wsum( int[] values, double[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(int[],float[]) */
    public static  double wsum( int[] values, float[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(int[],int[]) */
    public static  double wsum( int[] values, int[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(int[],long[]) */
    public static  double wsum( int[] values, long[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(int[],short[]) */
    public static  double wsum( int[] values, short[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(int[],io.deephaven.vector.ByteVector) */
    public static  double wsum( int[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(int[],io.deephaven.vector.DoubleVector) */
    public static  double wsum( int[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(int[],io.deephaven.vector.FloatVector) */
    public static  double wsum( int[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(int[],io.deephaven.vector.IntVector) */
    public static  double wsum( int[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(int[],io.deephaven.vector.LongVector) */
    public static  double wsum( int[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(int[],io.deephaven.vector.ShortVector) */
    public static  double wsum( int[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(long[],byte[]) */
    public static  double wsum( long[] values, byte[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(long[],double[]) */
    public static  double wsum( long[] values, double[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(long[],float[]) */
    public static  double wsum( long[] values, float[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(long[],int[]) */
    public static  double wsum( long[] values, int[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(long[],long[]) */
    public static  double wsum( long[] values, long[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(long[],short[]) */
    public static  double wsum( long[] values, short[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(long[],io.deephaven.vector.ByteVector) */
    public static  double wsum( long[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(long[],io.deephaven.vector.DoubleVector) */
    public static  double wsum( long[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(long[],io.deephaven.vector.FloatVector) */
    public static  double wsum( long[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(long[],io.deephaven.vector.IntVector) */
    public static  double wsum( long[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(long[],io.deephaven.vector.LongVector) */
    public static  double wsum( long[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(long[],io.deephaven.vector.ShortVector) */
    public static  double wsum( long[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(short[],byte[]) */
    public static  double wsum( short[] values, byte[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(short[],double[]) */
    public static  double wsum( short[] values, double[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(short[],float[]) */
    public static  double wsum( short[] values, float[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(short[],int[]) */
    public static  double wsum( short[] values, int[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(short[],long[]) */
    public static  double wsum( short[] values, long[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(short[],short[]) */
    public static  double wsum( short[] values, short[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(short[],io.deephaven.vector.ByteVector) */
    public static  double wsum( short[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(short[],io.deephaven.vector.DoubleVector) */
    public static  double wsum( short[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(short[],io.deephaven.vector.FloatVector) */
    public static  double wsum( short[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(short[],io.deephaven.vector.IntVector) */
    public static  double wsum( short[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(short[],io.deephaven.vector.LongVector) */
    public static  double wsum( short[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(short[],io.deephaven.vector.ShortVector) */
    public static  double wsum( short[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.ByteVector,byte[]) */
    public static  double wsum( io.deephaven.vector.ByteVector values, byte[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.ByteVector,double[]) */
    public static  double wsum( io.deephaven.vector.ByteVector values, double[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.ByteVector,float[]) */
    public static  double wsum( io.deephaven.vector.ByteVector values, float[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.ByteVector,int[]) */
    public static  double wsum( io.deephaven.vector.ByteVector values, int[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.ByteVector,long[]) */
    public static  double wsum( io.deephaven.vector.ByteVector values, long[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.ByteVector,short[]) */
    public static  double wsum( io.deephaven.vector.ByteVector values, short[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.ByteVector,io.deephaven.vector.ByteVector) */
    public static  double wsum( io.deephaven.vector.ByteVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.ByteVector,io.deephaven.vector.DoubleVector) */
    public static  double wsum( io.deephaven.vector.ByteVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.ByteVector,io.deephaven.vector.FloatVector) */
    public static  double wsum( io.deephaven.vector.ByteVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.ByteVector,io.deephaven.vector.IntVector) */
    public static  double wsum( io.deephaven.vector.ByteVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.ByteVector,io.deephaven.vector.LongVector) */
    public static  double wsum( io.deephaven.vector.ByteVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.ByteVector,io.deephaven.vector.ShortVector) */
    public static  double wsum( io.deephaven.vector.ByteVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.DoubleVector,byte[]) */
    public static  double wsum( io.deephaven.vector.DoubleVector values, byte[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.DoubleVector,double[]) */
    public static  double wsum( io.deephaven.vector.DoubleVector values, double[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.DoubleVector,float[]) */
    public static  double wsum( io.deephaven.vector.DoubleVector values, float[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.DoubleVector,int[]) */
    public static  double wsum( io.deephaven.vector.DoubleVector values, int[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.DoubleVector,long[]) */
    public static  double wsum( io.deephaven.vector.DoubleVector values, long[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.DoubleVector,short[]) */
    public static  double wsum( io.deephaven.vector.DoubleVector values, short[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.DoubleVector,io.deephaven.vector.ByteVector) */
    public static  double wsum( io.deephaven.vector.DoubleVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.DoubleVector,io.deephaven.vector.DoubleVector) */
    public static  double wsum( io.deephaven.vector.DoubleVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.DoubleVector,io.deephaven.vector.FloatVector) */
    public static  double wsum( io.deephaven.vector.DoubleVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.DoubleVector,io.deephaven.vector.IntVector) */
    public static  double wsum( io.deephaven.vector.DoubleVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.DoubleVector,io.deephaven.vector.LongVector) */
    public static  double wsum( io.deephaven.vector.DoubleVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.DoubleVector,io.deephaven.vector.ShortVector) */
    public static  double wsum( io.deephaven.vector.DoubleVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.FloatVector,byte[]) */
    public static  double wsum( io.deephaven.vector.FloatVector values, byte[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.FloatVector,double[]) */
    public static  double wsum( io.deephaven.vector.FloatVector values, double[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.FloatVector,float[]) */
    public static  double wsum( io.deephaven.vector.FloatVector values, float[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.FloatVector,int[]) */
    public static  double wsum( io.deephaven.vector.FloatVector values, int[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.FloatVector,long[]) */
    public static  double wsum( io.deephaven.vector.FloatVector values, long[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.FloatVector,short[]) */
    public static  double wsum( io.deephaven.vector.FloatVector values, short[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.FloatVector,io.deephaven.vector.ByteVector) */
    public static  double wsum( io.deephaven.vector.FloatVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.FloatVector,io.deephaven.vector.DoubleVector) */
    public static  double wsum( io.deephaven.vector.FloatVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.FloatVector,io.deephaven.vector.FloatVector) */
    public static  double wsum( io.deephaven.vector.FloatVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.FloatVector,io.deephaven.vector.IntVector) */
    public static  double wsum( io.deephaven.vector.FloatVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.FloatVector,io.deephaven.vector.LongVector) */
    public static  double wsum( io.deephaven.vector.FloatVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.FloatVector,io.deephaven.vector.ShortVector) */
    public static  double wsum( io.deephaven.vector.FloatVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.IntVector,byte[]) */
    public static  double wsum( io.deephaven.vector.IntVector values, byte[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.IntVector,double[]) */
    public static  double wsum( io.deephaven.vector.IntVector values, double[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.IntVector,float[]) */
    public static  double wsum( io.deephaven.vector.IntVector values, float[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.IntVector,int[]) */
    public static  double wsum( io.deephaven.vector.IntVector values, int[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.IntVector,long[]) */
    public static  double wsum( io.deephaven.vector.IntVector values, long[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.IntVector,short[]) */
    public static  double wsum( io.deephaven.vector.IntVector values, short[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.IntVector,io.deephaven.vector.ByteVector) */
    public static  double wsum( io.deephaven.vector.IntVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.IntVector,io.deephaven.vector.DoubleVector) */
    public static  double wsum( io.deephaven.vector.IntVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.IntVector,io.deephaven.vector.FloatVector) */
    public static  double wsum( io.deephaven.vector.IntVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.IntVector,io.deephaven.vector.IntVector) */
    public static  double wsum( io.deephaven.vector.IntVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.IntVector,io.deephaven.vector.LongVector) */
    public static  double wsum( io.deephaven.vector.IntVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.IntVector,io.deephaven.vector.ShortVector) */
    public static  double wsum( io.deephaven.vector.IntVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.LongVector,byte[]) */
    public static  double wsum( io.deephaven.vector.LongVector values, byte[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.LongVector,double[]) */
    public static  double wsum( io.deephaven.vector.LongVector values, double[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.LongVector,float[]) */
    public static  double wsum( io.deephaven.vector.LongVector values, float[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.LongVector,int[]) */
    public static  double wsum( io.deephaven.vector.LongVector values, int[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.LongVector,long[]) */
    public static  double wsum( io.deephaven.vector.LongVector values, long[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.LongVector,short[]) */
    public static  double wsum( io.deephaven.vector.LongVector values, short[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.LongVector,io.deephaven.vector.ByteVector) */
    public static  double wsum( io.deephaven.vector.LongVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.LongVector,io.deephaven.vector.DoubleVector) */
    public static  double wsum( io.deephaven.vector.LongVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.LongVector,io.deephaven.vector.FloatVector) */
    public static  double wsum( io.deephaven.vector.LongVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.LongVector,io.deephaven.vector.IntVector) */
    public static  double wsum( io.deephaven.vector.LongVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.LongVector,io.deephaven.vector.LongVector) */
    public static  double wsum( io.deephaven.vector.LongVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.LongVector,io.deephaven.vector.ShortVector) */
    public static  double wsum( io.deephaven.vector.LongVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.ShortVector,byte[]) */
    public static  double wsum( io.deephaven.vector.ShortVector values, byte[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.ShortVector,double[]) */
    public static  double wsum( io.deephaven.vector.ShortVector values, double[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.ShortVector,float[]) */
    public static  double wsum( io.deephaven.vector.ShortVector values, float[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.ShortVector,int[]) */
    public static  double wsum( io.deephaven.vector.ShortVector values, int[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.ShortVector,long[]) */
    public static  double wsum( io.deephaven.vector.ShortVector values, long[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.ShortVector,short[]) */
    public static  double wsum( io.deephaven.vector.ShortVector values, short[] weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.ShortVector,io.deephaven.vector.ByteVector) */
    public static  double wsum( io.deephaven.vector.ShortVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.ShortVector,io.deephaven.vector.DoubleVector) */
    public static  double wsum( io.deephaven.vector.ShortVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.ShortVector,io.deephaven.vector.FloatVector) */
    public static  double wsum( io.deephaven.vector.ShortVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.ShortVector,io.deephaven.vector.IntVector) */
    public static  double wsum( io.deephaven.vector.ShortVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.ShortVector,io.deephaven.vector.LongVector) */
    public static  double wsum( io.deephaven.vector.ShortVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wsum(io.deephaven.vector.ShortVector,io.deephaven.vector.ShortVector) */
    public static  double wsum( io.deephaven.vector.ShortVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wsum( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(byte[],byte[]) */
    public static  double wtstat( byte[] values, byte[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(byte[],double[]) */
    public static  double wtstat( byte[] values, double[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(byte[],float[]) */
    public static  double wtstat( byte[] values, float[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(byte[],int[]) */
    public static  double wtstat( byte[] values, int[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(byte[],long[]) */
    public static  double wtstat( byte[] values, long[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(byte[],short[]) */
    public static  double wtstat( byte[] values, short[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(byte[],io.deephaven.vector.ByteVector) */
    public static  double wtstat( byte[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(byte[],io.deephaven.vector.DoubleVector) */
    public static  double wtstat( byte[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(byte[],io.deephaven.vector.FloatVector) */
    public static  double wtstat( byte[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(byte[],io.deephaven.vector.IntVector) */
    public static  double wtstat( byte[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(byte[],io.deephaven.vector.LongVector) */
    public static  double wtstat( byte[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(byte[],io.deephaven.vector.ShortVector) */
    public static  double wtstat( byte[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(double[],byte[]) */
    public static  double wtstat( double[] values, byte[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(double[],double[]) */
    public static  double wtstat( double[] values, double[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(double[],float[]) */
    public static  double wtstat( double[] values, float[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(double[],int[]) */
    public static  double wtstat( double[] values, int[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(double[],long[]) */
    public static  double wtstat( double[] values, long[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(double[],short[]) */
    public static  double wtstat( double[] values, short[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(double[],io.deephaven.vector.ByteVector) */
    public static  double wtstat( double[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(double[],io.deephaven.vector.DoubleVector) */
    public static  double wtstat( double[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(double[],io.deephaven.vector.FloatVector) */
    public static  double wtstat( double[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(double[],io.deephaven.vector.IntVector) */
    public static  double wtstat( double[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(double[],io.deephaven.vector.LongVector) */
    public static  double wtstat( double[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(double[],io.deephaven.vector.ShortVector) */
    public static  double wtstat( double[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(float[],byte[]) */
    public static  double wtstat( float[] values, byte[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(float[],double[]) */
    public static  double wtstat( float[] values, double[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(float[],float[]) */
    public static  double wtstat( float[] values, float[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(float[],int[]) */
    public static  double wtstat( float[] values, int[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(float[],long[]) */
    public static  double wtstat( float[] values, long[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(float[],short[]) */
    public static  double wtstat( float[] values, short[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(float[],io.deephaven.vector.ByteVector) */
    public static  double wtstat( float[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(float[],io.deephaven.vector.DoubleVector) */
    public static  double wtstat( float[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(float[],io.deephaven.vector.FloatVector) */
    public static  double wtstat( float[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(float[],io.deephaven.vector.IntVector) */
    public static  double wtstat( float[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(float[],io.deephaven.vector.LongVector) */
    public static  double wtstat( float[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(float[],io.deephaven.vector.ShortVector) */
    public static  double wtstat( float[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(int[],byte[]) */
    public static  double wtstat( int[] values, byte[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(int[],double[]) */
    public static  double wtstat( int[] values, double[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(int[],float[]) */
    public static  double wtstat( int[] values, float[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(int[],int[]) */
    public static  double wtstat( int[] values, int[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(int[],long[]) */
    public static  double wtstat( int[] values, long[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(int[],short[]) */
    public static  double wtstat( int[] values, short[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(int[],io.deephaven.vector.ByteVector) */
    public static  double wtstat( int[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(int[],io.deephaven.vector.DoubleVector) */
    public static  double wtstat( int[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(int[],io.deephaven.vector.FloatVector) */
    public static  double wtstat( int[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(int[],io.deephaven.vector.IntVector) */
    public static  double wtstat( int[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(int[],io.deephaven.vector.LongVector) */
    public static  double wtstat( int[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(int[],io.deephaven.vector.ShortVector) */
    public static  double wtstat( int[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(long[],byte[]) */
    public static  double wtstat( long[] values, byte[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(long[],double[]) */
    public static  double wtstat( long[] values, double[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(long[],float[]) */
    public static  double wtstat( long[] values, float[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(long[],int[]) */
    public static  double wtstat( long[] values, int[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(long[],long[]) */
    public static  double wtstat( long[] values, long[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(long[],short[]) */
    public static  double wtstat( long[] values, short[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(long[],io.deephaven.vector.ByteVector) */
    public static  double wtstat( long[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(long[],io.deephaven.vector.DoubleVector) */
    public static  double wtstat( long[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(long[],io.deephaven.vector.FloatVector) */
    public static  double wtstat( long[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(long[],io.deephaven.vector.IntVector) */
    public static  double wtstat( long[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(long[],io.deephaven.vector.LongVector) */
    public static  double wtstat( long[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(long[],io.deephaven.vector.ShortVector) */
    public static  double wtstat( long[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(short[],byte[]) */
    public static  double wtstat( short[] values, byte[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(short[],double[]) */
    public static  double wtstat( short[] values, double[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(short[],float[]) */
    public static  double wtstat( short[] values, float[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(short[],int[]) */
    public static  double wtstat( short[] values, int[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(short[],long[]) */
    public static  double wtstat( short[] values, long[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(short[],short[]) */
    public static  double wtstat( short[] values, short[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(short[],io.deephaven.vector.ByteVector) */
    public static  double wtstat( short[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(short[],io.deephaven.vector.DoubleVector) */
    public static  double wtstat( short[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(short[],io.deephaven.vector.FloatVector) */
    public static  double wtstat( short[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(short[],io.deephaven.vector.IntVector) */
    public static  double wtstat( short[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(short[],io.deephaven.vector.LongVector) */
    public static  double wtstat( short[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(short[],io.deephaven.vector.ShortVector) */
    public static  double wtstat( short[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.ByteVector,byte[]) */
    public static  double wtstat( io.deephaven.vector.ByteVector values, byte[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.ByteVector,double[]) */
    public static  double wtstat( io.deephaven.vector.ByteVector values, double[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.ByteVector,float[]) */
    public static  double wtstat( io.deephaven.vector.ByteVector values, float[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.ByteVector,int[]) */
    public static  double wtstat( io.deephaven.vector.ByteVector values, int[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.ByteVector,long[]) */
    public static  double wtstat( io.deephaven.vector.ByteVector values, long[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.ByteVector,short[]) */
    public static  double wtstat( io.deephaven.vector.ByteVector values, short[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.ByteVector,io.deephaven.vector.ByteVector) */
    public static  double wtstat( io.deephaven.vector.ByteVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.ByteVector,io.deephaven.vector.DoubleVector) */
    public static  double wtstat( io.deephaven.vector.ByteVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.ByteVector,io.deephaven.vector.FloatVector) */
    public static  double wtstat( io.deephaven.vector.ByteVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.ByteVector,io.deephaven.vector.IntVector) */
    public static  double wtstat( io.deephaven.vector.ByteVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.ByteVector,io.deephaven.vector.LongVector) */
    public static  double wtstat( io.deephaven.vector.ByteVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.ByteVector,io.deephaven.vector.ShortVector) */
    public static  double wtstat( io.deephaven.vector.ByteVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.DoubleVector,byte[]) */
    public static  double wtstat( io.deephaven.vector.DoubleVector values, byte[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.DoubleVector,double[]) */
    public static  double wtstat( io.deephaven.vector.DoubleVector values, double[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.DoubleVector,float[]) */
    public static  double wtstat( io.deephaven.vector.DoubleVector values, float[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.DoubleVector,int[]) */
    public static  double wtstat( io.deephaven.vector.DoubleVector values, int[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.DoubleVector,long[]) */
    public static  double wtstat( io.deephaven.vector.DoubleVector values, long[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.DoubleVector,short[]) */
    public static  double wtstat( io.deephaven.vector.DoubleVector values, short[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.DoubleVector,io.deephaven.vector.ByteVector) */
    public static  double wtstat( io.deephaven.vector.DoubleVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.DoubleVector,io.deephaven.vector.DoubleVector) */
    public static  double wtstat( io.deephaven.vector.DoubleVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.DoubleVector,io.deephaven.vector.FloatVector) */
    public static  double wtstat( io.deephaven.vector.DoubleVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.DoubleVector,io.deephaven.vector.IntVector) */
    public static  double wtstat( io.deephaven.vector.DoubleVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.DoubleVector,io.deephaven.vector.LongVector) */
    public static  double wtstat( io.deephaven.vector.DoubleVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.DoubleVector,io.deephaven.vector.ShortVector) */
    public static  double wtstat( io.deephaven.vector.DoubleVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.FloatVector,byte[]) */
    public static  double wtstat( io.deephaven.vector.FloatVector values, byte[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.FloatVector,double[]) */
    public static  double wtstat( io.deephaven.vector.FloatVector values, double[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.FloatVector,float[]) */
    public static  double wtstat( io.deephaven.vector.FloatVector values, float[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.FloatVector,int[]) */
    public static  double wtstat( io.deephaven.vector.FloatVector values, int[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.FloatVector,long[]) */
    public static  double wtstat( io.deephaven.vector.FloatVector values, long[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.FloatVector,short[]) */
    public static  double wtstat( io.deephaven.vector.FloatVector values, short[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.FloatVector,io.deephaven.vector.ByteVector) */
    public static  double wtstat( io.deephaven.vector.FloatVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.FloatVector,io.deephaven.vector.DoubleVector) */
    public static  double wtstat( io.deephaven.vector.FloatVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.FloatVector,io.deephaven.vector.FloatVector) */
    public static  double wtstat( io.deephaven.vector.FloatVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.FloatVector,io.deephaven.vector.IntVector) */
    public static  double wtstat( io.deephaven.vector.FloatVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.FloatVector,io.deephaven.vector.LongVector) */
    public static  double wtstat( io.deephaven.vector.FloatVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.FloatVector,io.deephaven.vector.ShortVector) */
    public static  double wtstat( io.deephaven.vector.FloatVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.IntVector,byte[]) */
    public static  double wtstat( io.deephaven.vector.IntVector values, byte[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.IntVector,double[]) */
    public static  double wtstat( io.deephaven.vector.IntVector values, double[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.IntVector,float[]) */
    public static  double wtstat( io.deephaven.vector.IntVector values, float[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.IntVector,int[]) */
    public static  double wtstat( io.deephaven.vector.IntVector values, int[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.IntVector,long[]) */
    public static  double wtstat( io.deephaven.vector.IntVector values, long[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.IntVector,short[]) */
    public static  double wtstat( io.deephaven.vector.IntVector values, short[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.IntVector,io.deephaven.vector.ByteVector) */
    public static  double wtstat( io.deephaven.vector.IntVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.IntVector,io.deephaven.vector.DoubleVector) */
    public static  double wtstat( io.deephaven.vector.IntVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.IntVector,io.deephaven.vector.FloatVector) */
    public static  double wtstat( io.deephaven.vector.IntVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.IntVector,io.deephaven.vector.IntVector) */
    public static  double wtstat( io.deephaven.vector.IntVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.IntVector,io.deephaven.vector.LongVector) */
    public static  double wtstat( io.deephaven.vector.IntVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.IntVector,io.deephaven.vector.ShortVector) */
    public static  double wtstat( io.deephaven.vector.IntVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.LongVector,byte[]) */
    public static  double wtstat( io.deephaven.vector.LongVector values, byte[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.LongVector,double[]) */
    public static  double wtstat( io.deephaven.vector.LongVector values, double[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.LongVector,float[]) */
    public static  double wtstat( io.deephaven.vector.LongVector values, float[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.LongVector,int[]) */
    public static  double wtstat( io.deephaven.vector.LongVector values, int[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.LongVector,long[]) */
    public static  double wtstat( io.deephaven.vector.LongVector values, long[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.LongVector,short[]) */
    public static  double wtstat( io.deephaven.vector.LongVector values, short[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.LongVector,io.deephaven.vector.ByteVector) */
    public static  double wtstat( io.deephaven.vector.LongVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.LongVector,io.deephaven.vector.DoubleVector) */
    public static  double wtstat( io.deephaven.vector.LongVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.LongVector,io.deephaven.vector.FloatVector) */
    public static  double wtstat( io.deephaven.vector.LongVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.LongVector,io.deephaven.vector.IntVector) */
    public static  double wtstat( io.deephaven.vector.LongVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.LongVector,io.deephaven.vector.LongVector) */
    public static  double wtstat( io.deephaven.vector.LongVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.LongVector,io.deephaven.vector.ShortVector) */
    public static  double wtstat( io.deephaven.vector.LongVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.ShortVector,byte[]) */
    public static  double wtstat( io.deephaven.vector.ShortVector values, byte[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.ShortVector,double[]) */
    public static  double wtstat( io.deephaven.vector.ShortVector values, double[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.ShortVector,float[]) */
    public static  double wtstat( io.deephaven.vector.ShortVector values, float[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.ShortVector,int[]) */
    public static  double wtstat( io.deephaven.vector.ShortVector values, int[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.ShortVector,long[]) */
    public static  double wtstat( io.deephaven.vector.ShortVector values, long[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.ShortVector,short[]) */
    public static  double wtstat( io.deephaven.vector.ShortVector values, short[] weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.ShortVector,io.deephaven.vector.ByteVector) */
    public static  double wtstat( io.deephaven.vector.ShortVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.ShortVector,io.deephaven.vector.DoubleVector) */
    public static  double wtstat( io.deephaven.vector.ShortVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.ShortVector,io.deephaven.vector.FloatVector) */
    public static  double wtstat( io.deephaven.vector.ShortVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.ShortVector,io.deephaven.vector.IntVector) */
    public static  double wtstat( io.deephaven.vector.ShortVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.ShortVector,io.deephaven.vector.LongVector) */
    public static  double wtstat( io.deephaven.vector.ShortVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wtstat(io.deephaven.vector.ShortVector,io.deephaven.vector.ShortVector) */
    public static  double wtstat( io.deephaven.vector.ShortVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wtstat( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(byte[],byte[]) */
    public static  double wvar( byte[] values, byte[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(byte[],double[]) */
    public static  double wvar( byte[] values, double[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(byte[],float[]) */
    public static  double wvar( byte[] values, float[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(byte[],int[]) */
    public static  double wvar( byte[] values, int[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(byte[],long[]) */
    public static  double wvar( byte[] values, long[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(byte[],short[]) */
    public static  double wvar( byte[] values, short[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(byte[],io.deephaven.vector.ByteVector) */
    public static  double wvar( byte[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(byte[],io.deephaven.vector.DoubleVector) */
    public static  double wvar( byte[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(byte[],io.deephaven.vector.FloatVector) */
    public static  double wvar( byte[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(byte[],io.deephaven.vector.IntVector) */
    public static  double wvar( byte[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(byte[],io.deephaven.vector.LongVector) */
    public static  double wvar( byte[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(byte[],io.deephaven.vector.ShortVector) */
    public static  double wvar( byte[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(double[],byte[]) */
    public static  double wvar( double[] values, byte[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(double[],double[]) */
    public static  double wvar( double[] values, double[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(double[],float[]) */
    public static  double wvar( double[] values, float[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(double[],int[]) */
    public static  double wvar( double[] values, int[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(double[],long[]) */
    public static  double wvar( double[] values, long[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(double[],short[]) */
    public static  double wvar( double[] values, short[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(double[],io.deephaven.vector.ByteVector) */
    public static  double wvar( double[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(double[],io.deephaven.vector.DoubleVector) */
    public static  double wvar( double[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(double[],io.deephaven.vector.FloatVector) */
    public static  double wvar( double[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(double[],io.deephaven.vector.IntVector) */
    public static  double wvar( double[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(double[],io.deephaven.vector.LongVector) */
    public static  double wvar( double[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(double[],io.deephaven.vector.ShortVector) */
    public static  double wvar( double[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(float[],byte[]) */
    public static  double wvar( float[] values, byte[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(float[],double[]) */
    public static  double wvar( float[] values, double[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(float[],float[]) */
    public static  double wvar( float[] values, float[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(float[],int[]) */
    public static  double wvar( float[] values, int[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(float[],long[]) */
    public static  double wvar( float[] values, long[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(float[],short[]) */
    public static  double wvar( float[] values, short[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(float[],io.deephaven.vector.ByteVector) */
    public static  double wvar( float[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(float[],io.deephaven.vector.DoubleVector) */
    public static  double wvar( float[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(float[],io.deephaven.vector.FloatVector) */
    public static  double wvar( float[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(float[],io.deephaven.vector.IntVector) */
    public static  double wvar( float[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(float[],io.deephaven.vector.LongVector) */
    public static  double wvar( float[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(float[],io.deephaven.vector.ShortVector) */
    public static  double wvar( float[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(int[],byte[]) */
    public static  double wvar( int[] values, byte[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(int[],double[]) */
    public static  double wvar( int[] values, double[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(int[],float[]) */
    public static  double wvar( int[] values, float[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(int[],int[]) */
    public static  double wvar( int[] values, int[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(int[],long[]) */
    public static  double wvar( int[] values, long[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(int[],short[]) */
    public static  double wvar( int[] values, short[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(int[],io.deephaven.vector.ByteVector) */
    public static  double wvar( int[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(int[],io.deephaven.vector.DoubleVector) */
    public static  double wvar( int[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(int[],io.deephaven.vector.FloatVector) */
    public static  double wvar( int[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(int[],io.deephaven.vector.IntVector) */
    public static  double wvar( int[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(int[],io.deephaven.vector.LongVector) */
    public static  double wvar( int[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(int[],io.deephaven.vector.ShortVector) */
    public static  double wvar( int[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(long[],byte[]) */
    public static  double wvar( long[] values, byte[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(long[],double[]) */
    public static  double wvar( long[] values, double[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(long[],float[]) */
    public static  double wvar( long[] values, float[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(long[],int[]) */
    public static  double wvar( long[] values, int[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(long[],long[]) */
    public static  double wvar( long[] values, long[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(long[],short[]) */
    public static  double wvar( long[] values, short[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(long[],io.deephaven.vector.ByteVector) */
    public static  double wvar( long[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(long[],io.deephaven.vector.DoubleVector) */
    public static  double wvar( long[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(long[],io.deephaven.vector.FloatVector) */
    public static  double wvar( long[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(long[],io.deephaven.vector.IntVector) */
    public static  double wvar( long[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(long[],io.deephaven.vector.LongVector) */
    public static  double wvar( long[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(long[],io.deephaven.vector.ShortVector) */
    public static  double wvar( long[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(short[],byte[]) */
    public static  double wvar( short[] values, byte[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(short[],double[]) */
    public static  double wvar( short[] values, double[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(short[],float[]) */
    public static  double wvar( short[] values, float[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(short[],int[]) */
    public static  double wvar( short[] values, int[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(short[],long[]) */
    public static  double wvar( short[] values, long[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(short[],short[]) */
    public static  double wvar( short[] values, short[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(short[],io.deephaven.vector.ByteVector) */
    public static  double wvar( short[] values, io.deephaven.vector.ByteVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(short[],io.deephaven.vector.DoubleVector) */
    public static  double wvar( short[] values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(short[],io.deephaven.vector.FloatVector) */
    public static  double wvar( short[] values, io.deephaven.vector.FloatVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(short[],io.deephaven.vector.IntVector) */
    public static  double wvar( short[] values, io.deephaven.vector.IntVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(short[],io.deephaven.vector.LongVector) */
    public static  double wvar( short[] values, io.deephaven.vector.LongVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(short[],io.deephaven.vector.ShortVector) */
    public static  double wvar( short[] values, io.deephaven.vector.ShortVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.ByteVector,byte[]) */
    public static  double wvar( io.deephaven.vector.ByteVector values, byte[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.ByteVector,double[]) */
    public static  double wvar( io.deephaven.vector.ByteVector values, double[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.ByteVector,float[]) */
    public static  double wvar( io.deephaven.vector.ByteVector values, float[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.ByteVector,int[]) */
    public static  double wvar( io.deephaven.vector.ByteVector values, int[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.ByteVector,long[]) */
    public static  double wvar( io.deephaven.vector.ByteVector values, long[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.ByteVector,short[]) */
    public static  double wvar( io.deephaven.vector.ByteVector values, short[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.ByteVector,io.deephaven.vector.ByteVector) */
    public static  double wvar( io.deephaven.vector.ByteVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.ByteVector,io.deephaven.vector.DoubleVector) */
    public static  double wvar( io.deephaven.vector.ByteVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.ByteVector,io.deephaven.vector.FloatVector) */
    public static  double wvar( io.deephaven.vector.ByteVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.ByteVector,io.deephaven.vector.IntVector) */
    public static  double wvar( io.deephaven.vector.ByteVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.ByteVector,io.deephaven.vector.LongVector) */
    public static  double wvar( io.deephaven.vector.ByteVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.ByteVector,io.deephaven.vector.ShortVector) */
    public static  double wvar( io.deephaven.vector.ByteVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.DoubleVector,byte[]) */
    public static  double wvar( io.deephaven.vector.DoubleVector values, byte[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.DoubleVector,double[]) */
    public static  double wvar( io.deephaven.vector.DoubleVector values, double[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.DoubleVector,float[]) */
    public static  double wvar( io.deephaven.vector.DoubleVector values, float[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.DoubleVector,int[]) */
    public static  double wvar( io.deephaven.vector.DoubleVector values, int[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.DoubleVector,long[]) */
    public static  double wvar( io.deephaven.vector.DoubleVector values, long[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.DoubleVector,short[]) */
    public static  double wvar( io.deephaven.vector.DoubleVector values, short[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.DoubleVector,io.deephaven.vector.ByteVector) */
    public static  double wvar( io.deephaven.vector.DoubleVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.DoubleVector,io.deephaven.vector.DoubleVector) */
    public static  double wvar( io.deephaven.vector.DoubleVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.DoubleVector,io.deephaven.vector.FloatVector) */
    public static  double wvar( io.deephaven.vector.DoubleVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.DoubleVector,io.deephaven.vector.IntVector) */
    public static  double wvar( io.deephaven.vector.DoubleVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.DoubleVector,io.deephaven.vector.LongVector) */
    public static  double wvar( io.deephaven.vector.DoubleVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.DoubleVector,io.deephaven.vector.ShortVector) */
    public static  double wvar( io.deephaven.vector.DoubleVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.FloatVector,byte[]) */
    public static  double wvar( io.deephaven.vector.FloatVector values, byte[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.FloatVector,double[]) */
    public static  double wvar( io.deephaven.vector.FloatVector values, double[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.FloatVector,float[]) */
    public static  double wvar( io.deephaven.vector.FloatVector values, float[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.FloatVector,int[]) */
    public static  double wvar( io.deephaven.vector.FloatVector values, int[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.FloatVector,long[]) */
    public static  double wvar( io.deephaven.vector.FloatVector values, long[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.FloatVector,short[]) */
    public static  double wvar( io.deephaven.vector.FloatVector values, short[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.FloatVector,io.deephaven.vector.ByteVector) */
    public static  double wvar( io.deephaven.vector.FloatVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.FloatVector,io.deephaven.vector.DoubleVector) */
    public static  double wvar( io.deephaven.vector.FloatVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.FloatVector,io.deephaven.vector.FloatVector) */
    public static  double wvar( io.deephaven.vector.FloatVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.FloatVector,io.deephaven.vector.IntVector) */
    public static  double wvar( io.deephaven.vector.FloatVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.FloatVector,io.deephaven.vector.LongVector) */
    public static  double wvar( io.deephaven.vector.FloatVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.FloatVector,io.deephaven.vector.ShortVector) */
    public static  double wvar( io.deephaven.vector.FloatVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.IntVector,byte[]) */
    public static  double wvar( io.deephaven.vector.IntVector values, byte[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.IntVector,double[]) */
    public static  double wvar( io.deephaven.vector.IntVector values, double[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.IntVector,float[]) */
    public static  double wvar( io.deephaven.vector.IntVector values, float[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.IntVector,int[]) */
    public static  double wvar( io.deephaven.vector.IntVector values, int[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.IntVector,long[]) */
    public static  double wvar( io.deephaven.vector.IntVector values, long[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.IntVector,short[]) */
    public static  double wvar( io.deephaven.vector.IntVector values, short[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.IntVector,io.deephaven.vector.ByteVector) */
    public static  double wvar( io.deephaven.vector.IntVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.IntVector,io.deephaven.vector.DoubleVector) */
    public static  double wvar( io.deephaven.vector.IntVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.IntVector,io.deephaven.vector.FloatVector) */
    public static  double wvar( io.deephaven.vector.IntVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.IntVector,io.deephaven.vector.IntVector) */
    public static  double wvar( io.deephaven.vector.IntVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.IntVector,io.deephaven.vector.LongVector) */
    public static  double wvar( io.deephaven.vector.IntVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.IntVector,io.deephaven.vector.ShortVector) */
    public static  double wvar( io.deephaven.vector.IntVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.LongVector,byte[]) */
    public static  double wvar( io.deephaven.vector.LongVector values, byte[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.LongVector,double[]) */
    public static  double wvar( io.deephaven.vector.LongVector values, double[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.LongVector,float[]) */
    public static  double wvar( io.deephaven.vector.LongVector values, float[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.LongVector,int[]) */
    public static  double wvar( io.deephaven.vector.LongVector values, int[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.LongVector,long[]) */
    public static  double wvar( io.deephaven.vector.LongVector values, long[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.LongVector,short[]) */
    public static  double wvar( io.deephaven.vector.LongVector values, short[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.LongVector,io.deephaven.vector.ByteVector) */
    public static  double wvar( io.deephaven.vector.LongVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.LongVector,io.deephaven.vector.DoubleVector) */
    public static  double wvar( io.deephaven.vector.LongVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.LongVector,io.deephaven.vector.FloatVector) */
    public static  double wvar( io.deephaven.vector.LongVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.LongVector,io.deephaven.vector.IntVector) */
    public static  double wvar( io.deephaven.vector.LongVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.LongVector,io.deephaven.vector.LongVector) */
    public static  double wvar( io.deephaven.vector.LongVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.LongVector,io.deephaven.vector.ShortVector) */
    public static  double wvar( io.deephaven.vector.LongVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.ShortVector,byte[]) */
    public static  double wvar( io.deephaven.vector.ShortVector values, byte[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.ShortVector,double[]) */
    public static  double wvar( io.deephaven.vector.ShortVector values, double[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.ShortVector,float[]) */
    public static  double wvar( io.deephaven.vector.ShortVector values, float[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.ShortVector,int[]) */
    public static  double wvar( io.deephaven.vector.ShortVector values, int[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.ShortVector,long[]) */
    public static  double wvar( io.deephaven.vector.ShortVector values, long[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.ShortVector,short[]) */
    public static  double wvar( io.deephaven.vector.ShortVector values, short[] weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.ShortVector,io.deephaven.vector.ByteVector) */
    public static  double wvar( io.deephaven.vector.ShortVector values, io.deephaven.vector.ByteVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.ShortVector,io.deephaven.vector.DoubleVector) */
    public static  double wvar( io.deephaven.vector.ShortVector values, io.deephaven.vector.DoubleVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.ShortVector,io.deephaven.vector.FloatVector) */
    public static  double wvar( io.deephaven.vector.ShortVector values, io.deephaven.vector.FloatVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.ShortVector,io.deephaven.vector.IntVector) */
    public static  double wvar( io.deephaven.vector.ShortVector values, io.deephaven.vector.IntVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.ShortVector,io.deephaven.vector.LongVector) */
    public static  double wvar( io.deephaven.vector.ShortVector values, io.deephaven.vector.LongVector weights ) {return Numeric.wvar( values, weights );}

    /** @see io.deephaven.function.Numeric#wvar(io.deephaven.vector.ShortVector,io.deephaven.vector.ShortVector) */
    public static  double wvar( io.deephaven.vector.ShortVector values, io.deephaven.vector.ShortVector weights ) {return Numeric.wvar( values, weights );}

}