in arrow/compute/internal/kernels/base_arithmetic.go [378:640]
func getGoArithmeticOpFloating[InT, OutT constraints.Float](op ArithmeticOp) exec.ArrayKernelExec {
switch op {
case OpAdd, OpAddChecked:
return ScalarBinary(getGoArithmeticBinary(func(a, b InT, _ *error) OutT { return OutT(a + b) }))
case OpSub, OpSubChecked:
return ScalarBinary(getGoArithmeticBinary(func(a, b InT, _ *error) OutT { return OutT(a - b) }))
case OpMul, OpMulChecked:
return ScalarBinary(getGoArithmeticBinary(func(a, b InT, _ *error) OutT { return OutT(a * b) }))
case OpDiv:
return ScalarBinaryNotNull(func(_ *exec.KernelCtx, a, b InT, e *error) (out OutT) {
return OutT(a / b)
})
case OpDivChecked:
return ScalarBinaryNotNull(func(_ *exec.KernelCtx, a, b InT, e *error) (out OutT) {
if b == 0 {
*e = errDivByZero
return
}
return OutT(a / b)
})
case OpAbsoluteValue, OpAbsoluteValueChecked:
return ScalarUnary(func(_ *exec.KernelCtx, arg []InT, out []OutT) error {
for i, v := range arg {
out[i] = OutT(math.Abs(float64(v)))
}
return nil
})
case OpNegate, OpNegateChecked:
return ScalarUnary(func(_ *exec.KernelCtx, arg []InT, out []OutT) error {
for i, v := range arg {
out[i] = OutT(-v)
}
return nil
})
case OpSqrt:
return ScalarUnary(func(_ *exec.KernelCtx, arg []InT, out []OutT) error {
for i, v := range arg {
out[i] = OutT(math.Sqrt(float64(v)))
}
return nil
})
case OpSqrtChecked:
return ScalarUnaryNotNull(func(_ *exec.KernelCtx, arg InT, e *error) OutT {
if arg < 0 {
*e = errNegativeSqrt
return OutT(math.NaN())
}
return OutT(math.Sqrt(float64(arg)))
})
case OpSign:
return ScalarUnary(func(_ *exec.KernelCtx, arg []InT, out []OutT) error {
for i, v := range arg {
switch {
case math.IsNaN(float64(v)):
out[i] = OutT(v)
case v == 0:
out[i] = 0
case math.Signbit(float64(v)):
out[i] = -1
default:
out[i] = 1
}
}
return nil
})
case OpPower, OpPowerChecked:
return ScalarBinary(getGoArithmeticBinary(func(a, b InT, _ *error) OutT {
return OutT(math.Pow(float64(a), float64(b)))
}))
case OpSin:
return ScalarUnary(func(_ *exec.KernelCtx, vals []InT, out []OutT) error {
for i, v := range vals {
out[i] = OutT(math.Sin(float64(v)))
}
return nil
})
case OpSinChecked:
return ScalarUnaryNotNull(func(_ *exec.KernelCtx, arg InT, e *error) OutT {
if math.IsInf(float64(arg), 0) {
*e = errDomainErr
return OutT(arg)
}
return OutT(math.Sin(float64(arg)))
})
case OpCos:
return ScalarUnary(func(_ *exec.KernelCtx, vals []InT, out []OutT) error {
for i, v := range vals {
out[i] = OutT(math.Cos(float64(v)))
}
return nil
})
case OpCosChecked:
return ScalarUnaryNotNull(func(_ *exec.KernelCtx, arg InT, e *error) OutT {
if math.IsInf(float64(arg), 0) {
*e = errDomainErr
return OutT(arg)
}
return OutT(math.Cos(float64(arg)))
})
case OpTan:
return ScalarUnary(func(_ *exec.KernelCtx, vals []InT, out []OutT) error {
for i, v := range vals {
out[i] = OutT(math.Tan(float64(v)))
}
return nil
})
case OpTanChecked:
return ScalarUnaryNotNull(func(_ *exec.KernelCtx, arg InT, e *error) OutT {
if math.IsInf(float64(arg), 0) {
*e = errDomainErr
return OutT(arg)
}
return OutT(math.Tan(float64(arg)))
})
case OpAsin:
return ScalarUnary(func(_ *exec.KernelCtx, vals []InT, out []OutT) error {
for i, v := range vals {
out[i] = OutT(math.Asin(float64(v)))
}
return nil
})
case OpAsinChecked:
return ScalarUnaryNotNull(func(_ *exec.KernelCtx, arg InT, e *error) OutT {
if arg < -1 || arg > 1 {
*e = errDomainErr
return OutT(arg)
}
return OutT(math.Asin(float64(arg)))
})
case OpAcos:
return ScalarUnary(func(_ *exec.KernelCtx, vals []InT, out []OutT) error {
for i, v := range vals {
out[i] = OutT(math.Acos(float64(v)))
}
return nil
})
case OpAcosChecked:
return ScalarUnaryNotNull(func(_ *exec.KernelCtx, arg InT, e *error) OutT {
if arg < -1 || arg > 1 {
*e = errDomainErr
return OutT(arg)
}
return OutT(math.Acos(float64(arg)))
})
case OpAtan:
return ScalarUnary(func(_ *exec.KernelCtx, vals []InT, out []OutT) error {
for i, v := range vals {
out[i] = OutT(math.Atan(float64(v)))
}
return nil
})
case OpAtan2:
return ScalarBinary(getGoArithmeticBinary(func(a, b InT, _ *error) OutT {
return OutT(math.Atan2(float64(a), float64(b)))
}))
case OpLn:
return ScalarUnary(func(_ *exec.KernelCtx, vals []InT, out []OutT) error {
for i, v := range vals {
out[i] = OutT(math.Log(float64(v)))
}
return nil
})
case OpLnChecked:
return ScalarUnaryNotNull(func(_ *exec.KernelCtx, arg InT, e *error) OutT {
switch {
case arg == 0:
*e = errLogZero
return OutT(arg)
case arg < 0:
*e = errLogNeg
return OutT(arg)
}
return OutT(math.Log(float64(arg)))
})
case OpLog10:
return ScalarUnary(func(_ *exec.KernelCtx, vals []InT, out []OutT) error {
for i, v := range vals {
out[i] = OutT(math.Log10(float64(v)))
}
return nil
})
case OpLog10Checked:
return ScalarUnaryNotNull(func(_ *exec.KernelCtx, arg InT, e *error) OutT {
switch {
case arg == 0:
*e = errLogZero
return OutT(arg)
case arg < 0:
*e = errLogNeg
return OutT(arg)
}
return OutT(math.Log10(float64(arg)))
})
case OpLog2:
return ScalarUnary(func(_ *exec.KernelCtx, vals []InT, out []OutT) error {
for i, v := range vals {
out[i] = OutT(math.Log2(float64(v)))
}
return nil
})
case OpLog2Checked:
return ScalarUnaryNotNull(func(_ *exec.KernelCtx, arg InT, e *error) OutT {
switch {
case arg == 0:
*e = errLogZero
return OutT(arg)
case arg < 0:
*e = errLogNeg
return OutT(arg)
}
return OutT(math.Log2(float64(arg)))
})
case OpLog1p:
return ScalarUnary(func(_ *exec.KernelCtx, vals []InT, out []OutT) error {
for i, v := range vals {
out[i] = OutT(math.Log1p(float64(v)))
}
return nil
})
case OpLog1pChecked:
return ScalarUnaryNotNull(func(_ *exec.KernelCtx, arg InT, e *error) OutT {
switch {
case arg == -1:
*e = errLogZero
return OutT(arg)
case arg < -1:
*e = errLogNeg
return OutT(arg)
}
return OutT(math.Log1p(float64(arg)))
})
case OpLogb:
return ScalarBinary(getGoArithmeticBinary(func(x, base InT, _ *error) OutT {
if x == 0 {
if base == 0 || base < 0 {
return OutT(math.NaN())
} else {
return OutT(math.Inf(-1))
}
} else if x < 0 {
return OutT(math.NaN())
}
return OutT(math.Log(float64(x)) / math.Log(float64(base)))
}))
case OpLogbChecked:
return ScalarBinaryNotNull((func(_ *exec.KernelCtx, x, base InT, e *error) OutT {
if x == 0 || base == 0 {
*e = errLogZero
return OutT(x)
} else if x < 0 || base < 0 {
*e = errLogNeg
return OutT(x)
}
return OutT(math.Log(float64(x)) / math.Log(float64(base)))
}))
}
debug.Assert(false, "invalid arithmetic op")
return nil
}