Package org.apache.druid.math.expr.vector

Class VectorMathProcessors

java.lang.Object

org.apache.druid.math.expr.vector.VectorMathProcessors

public class VectorMathProcessors
extends Object

Method Summary

Modifier and Type	Method	Description
static <T> ExprVectorProcessor<T>	abs(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	acos(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	asin(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	atan(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	atan2(Expr.VectorInputBindingInspector inspector, Expr left, Expr right)
static <T> ExprVectorProcessor<T>	bitwiseAnd(Expr.VectorInputBindingInspector inspector, Expr left, Expr right)
static <T> ExprVectorProcessor<T>	bitwiseComplement(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	bitwiseConvertDoubleToLongBits(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	bitwiseConvertLongBitsToDouble(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	bitwiseOr(Expr.VectorInputBindingInspector inspector, Expr left, Expr right)
static <T> ExprVectorProcessor<T>	bitwiseShiftLeft(Expr.VectorInputBindingInspector inspector, Expr left, Expr right)
static <T> ExprVectorProcessor<T>	bitwiseShiftRight(Expr.VectorInputBindingInspector inspector, Expr left, Expr right)
static <T> ExprVectorProcessor<T>	bitwiseXor(Expr.VectorInputBindingInspector inspector, Expr left, Expr right)
static <T> ExprVectorProcessor<T>	cbrt(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	ceil(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	copySign(Expr.VectorInputBindingInspector inspector, Expr left, Expr right)
static <T> ExprVectorProcessor<T>	cos(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	cosh(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	cot(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	divide(Expr.VectorInputBindingInspector inspector, Expr left, Expr right)
static <T> ExprVectorProcessor<T>	doublePower(Expr.VectorInputBindingInspector inspector, Expr left, Expr right)
static <T> ExprVectorProcessor<T>	exp(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	expm1(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	floor(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	getExponent(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	hypot(Expr.VectorInputBindingInspector inspector, Expr left, Expr right)
static <T> ExprVectorProcessor<T>	log(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	log10(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	log1p(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	longDivide(Expr.VectorInputBindingInspector inspector, Expr left, Expr right)
static <T> ExprVectorProcessor<T>	makeDoubleMathProcessor(Expr.VectorInputBindingInspector inspector, Expr arg, Supplier<DoubleOutLongInFunctionVectorValueProcessor> doubleOutLongInSupplier, Supplier<DoubleOutDoubleInFunctionVectorValueProcessor> doubleOutDoubleInSupplier)	Make a 1 argument math processor with the following type rules long -> double double -> double
static <T> ExprVectorProcessor<T>	makeDoubleMathProcessor(Expr.VectorInputBindingInspector inspector, Expr left, Expr right, Supplier<DoubleOutLongsInFunctionVectorValueProcessor> doubleOutLongsInProcessor, Supplier<DoubleOutLongDoubleInFunctionVectorValueProcessor> doubleOutLongDoubleInProcessor, Supplier<DoubleOutDoubleLongInFunctionVectorValueProcessor> doubleOutDoubleLongInProcessor, Supplier<DoubleOutDoublesInFunctionVectorValueProcessor> doubleOutDoublesInProcessor)	Make a 2 argument, math processor with the following type rules long, long -> double long, double -> double double, long -> double double, double -> double
static <T> ExprVectorProcessor<T>	makeLongMathProcessor(Expr.VectorInputBindingInspector inspector, Expr arg, Supplier<LongOutLongInFunctionVectorValueProcessor> longOutLongInSupplier, Supplier<LongOutDoubleInFunctionVectorValueProcessor> longOutDoubleInSupplier)	Make a 1 argument math processor with the following type rules long -> long double -> long
static <T> ExprVectorProcessor<T>	makeLongMathProcessor(Expr.VectorInputBindingInspector inspector, Expr left, Expr right, Supplier<LongOutLongsInFunctionVectorValueProcessor> longOutLongsInProcessor, Supplier<LongOutLongDoubleInFunctionVectorValueProcessor> longOutLongDoubleInProcessor, Supplier<LongOutDoubleLongInFunctionVectorValueProcessor> longOutDoubleLongInProcessor, Supplier<LongOutDoublesInFunctionVectorValueProcessor> longOutDoublesInProcessor)	Make a 2 argument, math processor with the following type rules long, long -> long long, double -> long double, long -> long double, double -> long
static <T> ExprVectorProcessor<T>	makeMathProcessor(Expr.VectorInputBindingInspector inspector, Expr arg, Supplier<LongOutLongInFunctionVectorValueProcessor> longOutLongInSupplier, Supplier<DoubleOutDoubleInFunctionVectorValueProcessor> doubleOutDoubleInSupplier)	Make a 1 argument math processor with the following type rules long -> long double -> double
static <T> ExprVectorProcessor<T>	makeMathProcessor(Expr.VectorInputBindingInspector inspector, Expr left, Expr right, Supplier<LongOutLongsInFunctionVectorValueProcessor> longOutLongsInProcessor, Supplier<DoubleOutLongDoubleInFunctionVectorValueProcessor> doubleOutLongDoubleInProcessor, Supplier<DoubleOutDoubleLongInFunctionVectorValueProcessor> doubleOutDoubleLongInProcessor, Supplier<DoubleOutDoublesInFunctionVectorValueProcessor> doubleOutDoublesInProcessor)	Make a 2 argument, math processor with the following type rules long, long -> long long, double -> double double, long -> double double, double -> double
static <T> ExprVectorProcessor<T>	max(Expr.VectorInputBindingInspector inspector, Expr left, Expr right)
static <T> ExprVectorProcessor<T>	min(Expr.VectorInputBindingInspector inspector, Expr left, Expr right)
static <T> ExprVectorProcessor<T>	minus(Expr.VectorInputBindingInspector inspector, Expr left, Expr right)
static <T> ExprVectorProcessor<T>	modulo(Expr.VectorInputBindingInspector inspector, Expr left, Expr right)
static <T> ExprVectorProcessor<T>	multiply(Expr.VectorInputBindingInspector inspector, Expr left, Expr right)
static <T> ExprVectorProcessor<T>	negate(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	nextAfter(Expr.VectorInputBindingInspector inspector, Expr left, Expr right)
static <T> ExprVectorProcessor<T>	nextUp(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	plus(Expr.VectorInputBindingInspector inspector, Expr left, Expr right)
static <T> ExprVectorProcessor<T>	power(Expr.VectorInputBindingInspector inspector, Expr left, Expr right)
static <T> ExprVectorProcessor<T>	remainder(Expr.VectorInputBindingInspector inspector, Expr left, Expr right)
static <T> ExprVectorProcessor<T>	rint(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	scalb(Expr.VectorInputBindingInspector inspector, Expr left, Expr right)
static <T> ExprVectorProcessor<T>	signum(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	sin(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	sinh(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	sqrt(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	tan(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	tanh(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	toDegrees(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	toRadians(Expr.VectorInputBindingInspector inspector, Expr arg)
static <T> ExprVectorProcessor<T>	ulp(Expr.VectorInputBindingInspector inspector, Expr arg)

Methods inherited from class java.lang.Object

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

Method Detail

makeMathProcessor

public static <T> ExprVectorProcessor<T> makeMathProcessor(Expr.VectorInputBindingInspector inspector,
                                                           Expr arg,
                                                           Supplier<LongOutLongInFunctionVectorValueProcessor> longOutLongInSupplier,
                                                           Supplier<DoubleOutDoubleInFunctionVectorValueProcessor> doubleOutDoubleInSupplier)

Make a 1 argument math processor with the following type rules long -> long double -> double

makeDoubleMathProcessor

public static <T> ExprVectorProcessor<T> makeDoubleMathProcessor(Expr.VectorInputBindingInspector inspector,
                                                                 Expr arg,
                                                                 Supplier<DoubleOutLongInFunctionVectorValueProcessor> doubleOutLongInSupplier,
                                                                 Supplier<DoubleOutDoubleInFunctionVectorValueProcessor> doubleOutDoubleInSupplier)

Make a 1 argument math processor with the following type rules long -> double double -> double

makeLongMathProcessor

public static <T> ExprVectorProcessor<T> makeLongMathProcessor(Expr.VectorInputBindingInspector inspector,
                                                               Expr arg,
                                                               Supplier<LongOutLongInFunctionVectorValueProcessor> longOutLongInSupplier,
                                                               Supplier<LongOutDoubleInFunctionVectorValueProcessor> longOutDoubleInSupplier)

Make a 1 argument math processor with the following type rules long -> long double -> long

makeMathProcessor

public static <T> ExprVectorProcessor<T> makeMathProcessor(Expr.VectorInputBindingInspector inspector,
                                                           Expr left,
                                                           Expr right,
                                                           Supplier<LongOutLongsInFunctionVectorValueProcessor> longOutLongsInProcessor,
                                                           Supplier<DoubleOutLongDoubleInFunctionVectorValueProcessor> doubleOutLongDoubleInProcessor,
                                                           Supplier<DoubleOutDoubleLongInFunctionVectorValueProcessor> doubleOutDoubleLongInProcessor,
                                                           Supplier<DoubleOutDoublesInFunctionVectorValueProcessor> doubleOutDoublesInProcessor)

Make a 2 argument, math processor with the following type rules long, long -> long long, double -> double double, long -> double double, double -> double

makeDoubleMathProcessor

public static <T> ExprVectorProcessor<T> makeDoubleMathProcessor(Expr.VectorInputBindingInspector inspector,
                                                                 Expr left,
                                                                 Expr right,
                                                                 Supplier<DoubleOutLongsInFunctionVectorValueProcessor> doubleOutLongsInProcessor,
                                                                 Supplier<DoubleOutLongDoubleInFunctionVectorValueProcessor> doubleOutLongDoubleInProcessor,
                                                                 Supplier<DoubleOutDoubleLongInFunctionVectorValueProcessor> doubleOutDoubleLongInProcessor,
                                                                 Supplier<DoubleOutDoublesInFunctionVectorValueProcessor> doubleOutDoublesInProcessor)

Make a 2 argument, math processor with the following type rules long, long -> double long, double -> double double, long -> double double, double -> double

makeLongMathProcessor

public static <T> ExprVectorProcessor<T> makeLongMathProcessor(Expr.VectorInputBindingInspector inspector,
                                                               Expr left,
                                                               Expr right,
                                                               Supplier<LongOutLongsInFunctionVectorValueProcessor> longOutLongsInProcessor,
                                                               Supplier<LongOutLongDoubleInFunctionVectorValueProcessor> longOutLongDoubleInProcessor,
                                                               Supplier<LongOutDoubleLongInFunctionVectorValueProcessor> longOutDoubleLongInProcessor,
                                                               Supplier<LongOutDoublesInFunctionVectorValueProcessor> longOutDoublesInProcessor)

Make a 2 argument, math processor with the following type rules long, long -> long long, double -> long double, long -> long double, double -> long

plus

public static <T> ExprVectorProcessor<T> plus(Expr.VectorInputBindingInspector inspector,
                                              Expr left,
                                              Expr right)

minus

public static <T> ExprVectorProcessor<T> minus(Expr.VectorInputBindingInspector inspector,
                                               Expr left,
                                               Expr right)

multiply

public static <T> ExprVectorProcessor<T> multiply(Expr.VectorInputBindingInspector inspector,
                                                  Expr left,
                                                  Expr right)

divide

public static <T> ExprVectorProcessor<T> divide(Expr.VectorInputBindingInspector inspector,
                                                Expr left,
                                                Expr right)

longDivide

public static <T> ExprVectorProcessor<T> longDivide(Expr.VectorInputBindingInspector inspector,
                                                    Expr left,
                                                    Expr right)

modulo

public static <T> ExprVectorProcessor<T> modulo(Expr.VectorInputBindingInspector inspector,
                                                Expr left,
                                                Expr right)

negate

public static <T> ExprVectorProcessor<T> negate(Expr.VectorInputBindingInspector inspector,
                                                Expr arg)

power

public static <T> ExprVectorProcessor<T> power(Expr.VectorInputBindingInspector inspector,
                                               Expr left,
                                               Expr right)

doublePower

public static <T> ExprVectorProcessor<T> doublePower(Expr.VectorInputBindingInspector inspector,
                                                     Expr left,
                                                     Expr right)

max

public static <T> ExprVectorProcessor<T> max(Expr.VectorInputBindingInspector inspector,
                                             Expr left,
                                             Expr right)

min

public static <T> ExprVectorProcessor<T> min(Expr.VectorInputBindingInspector inspector,
                                             Expr left,
                                             Expr right)

atan2

public static <T> ExprVectorProcessor<T> atan2(Expr.VectorInputBindingInspector inspector,
                                               Expr left,
                                               Expr right)

copySign

public static <T> ExprVectorProcessor<T> copySign(Expr.VectorInputBindingInspector inspector,
                                                  Expr left,
                                                  Expr right)

hypot

public static <T> ExprVectorProcessor<T> hypot(Expr.VectorInputBindingInspector inspector,
                                               Expr left,
                                               Expr right)

remainder

public static <T> ExprVectorProcessor<T> remainder(Expr.VectorInputBindingInspector inspector,
                                                   Expr left,
                                                   Expr right)

nextAfter

public static <T> ExprVectorProcessor<T> nextAfter(Expr.VectorInputBindingInspector inspector,
                                                   Expr left,
                                                   Expr right)

scalb

public static <T> ExprVectorProcessor<T> scalb(Expr.VectorInputBindingInspector inspector,
                                               Expr left,
                                               Expr right)

acos

public static <T> ExprVectorProcessor<T> acos(Expr.VectorInputBindingInspector inspector,
                                              Expr arg)

asin

public static <T> ExprVectorProcessor<T> asin(Expr.VectorInputBindingInspector inspector,
                                              Expr arg)

atan

public static <T> ExprVectorProcessor<T> atan(Expr.VectorInputBindingInspector inspector,
                                              Expr arg)

cos

public static <T> ExprVectorProcessor<T> cos(Expr.VectorInputBindingInspector inspector,
                                             Expr arg)

cosh

public static <T> ExprVectorProcessor<T> cosh(Expr.VectorInputBindingInspector inspector,
                                              Expr arg)

cot

public static <T> ExprVectorProcessor<T> cot(Expr.VectorInputBindingInspector inspector,
                                             Expr arg)

sin

public static <T> ExprVectorProcessor<T> sin(Expr.VectorInputBindingInspector inspector,
                                             Expr arg)

sinh

public static <T> ExprVectorProcessor<T> sinh(Expr.VectorInputBindingInspector inspector,
                                              Expr arg)

tan

public static <T> ExprVectorProcessor<T> tan(Expr.VectorInputBindingInspector inspector,
                                             Expr arg)

tanh

public static <T> ExprVectorProcessor<T> tanh(Expr.VectorInputBindingInspector inspector,
                                              Expr arg)

abs

public static <T> ExprVectorProcessor<T> abs(Expr.VectorInputBindingInspector inspector,
                                             Expr arg)

cbrt

public static <T> ExprVectorProcessor<T> cbrt(Expr.VectorInputBindingInspector inspector,
                                              Expr arg)

ceil

public static <T> ExprVectorProcessor<T> ceil(Expr.VectorInputBindingInspector inspector,
                                              Expr arg)

floor

public static <T> ExprVectorProcessor<T> floor(Expr.VectorInputBindingInspector inspector,
                                               Expr arg)

exp

public static <T> ExprVectorProcessor<T> exp(Expr.VectorInputBindingInspector inspector,
                                             Expr arg)

expm1

public static <T> ExprVectorProcessor<T> expm1(Expr.VectorInputBindingInspector inspector,
                                               Expr arg)

getExponent

public static <T> ExprVectorProcessor<T> getExponent(Expr.VectorInputBindingInspector inspector,
                                                     Expr arg)

log

public static <T> ExprVectorProcessor<T> log(Expr.VectorInputBindingInspector inspector,
                                             Expr arg)

log10

public static <T> ExprVectorProcessor<T> log10(Expr.VectorInputBindingInspector inspector,
                                               Expr arg)

log1p

public static <T> ExprVectorProcessor<T> log1p(Expr.VectorInputBindingInspector inspector,
                                               Expr arg)

nextUp

public static <T> ExprVectorProcessor<T> nextUp(Expr.VectorInputBindingInspector inspector,
                                                Expr arg)

rint

public static <T> ExprVectorProcessor<T> rint(Expr.VectorInputBindingInspector inspector,
                                              Expr arg)

signum

public static <T> ExprVectorProcessor<T> signum(Expr.VectorInputBindingInspector inspector,
                                                Expr arg)

sqrt

public static <T> ExprVectorProcessor<T> sqrt(Expr.VectorInputBindingInspector inspector,
                                              Expr arg)

toDegrees

public static <T> ExprVectorProcessor<T> toDegrees(Expr.VectorInputBindingInspector inspector,
                                                   Expr arg)

toRadians

public static <T> ExprVectorProcessor<T> toRadians(Expr.VectorInputBindingInspector inspector,
                                                   Expr arg)

ulp

public static <T> ExprVectorProcessor<T> ulp(Expr.VectorInputBindingInspector inspector,
                                             Expr arg)

bitwiseComplement

public static <T> ExprVectorProcessor<T> bitwiseComplement(Expr.VectorInputBindingInspector inspector,
                                                           Expr arg)

bitwiseConvertDoubleToLongBits

public static <T> ExprVectorProcessor<T> bitwiseConvertDoubleToLongBits(Expr.VectorInputBindingInspector inspector,
                                                                        Expr arg)

bitwiseConvertLongBitsToDouble

public static <T> ExprVectorProcessor<T> bitwiseConvertLongBitsToDouble(Expr.VectorInputBindingInspector inspector,
                                                                        Expr arg)

bitwiseAnd

public static <T> ExprVectorProcessor<T> bitwiseAnd(Expr.VectorInputBindingInspector inspector,
                                                    Expr left,
                                                    Expr right)

bitwiseOr

public static <T> ExprVectorProcessor<T> bitwiseOr(Expr.VectorInputBindingInspector inspector,
                                                   Expr left,
                                                   Expr right)

bitwiseXor

public static <T> ExprVectorProcessor<T> bitwiseXor(Expr.VectorInputBindingInspector inspector,
                                                    Expr left,
                                                    Expr right)

bitwiseShiftLeft

public static <T> ExprVectorProcessor<T> bitwiseShiftLeft(Expr.VectorInputBindingInspector inspector,
                                                          Expr left,
                                                          Expr right)

bitwiseShiftRight

public static <T> ExprVectorProcessor<T> bitwiseShiftRight(Expr.VectorInputBindingInspector inspector,
                                                           Expr left,
                                                           Expr right)