mirror of
https://gitee.com/rulego/streamsql.git
synced 2025-07-09 17:21:32 +00:00
717 lines
16 KiB
Go
717 lines
16 KiB
Go
package functions
|
|
|
|
import (
|
|
"fmt"
|
|
"github.com/rulego/streamsql/utils/cast"
|
|
"math"
|
|
"math/rand"
|
|
"time"
|
|
)
|
|
|
|
// AbsFunction 绝对值函数
|
|
type AbsFunction struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewAbsFunction() *AbsFunction {
|
|
return &AbsFunction{
|
|
BaseFunction: NewBaseFunction("abs", TypeMath, "数学函数", "计算绝对值", 1, 1),
|
|
}
|
|
}
|
|
|
|
func (f *AbsFunction) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *AbsFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
val, err := cast.ToFloat64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return math.Abs(val), nil
|
|
}
|
|
|
|
// SqrtFunction 平方根函数
|
|
type SqrtFunction struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewSqrtFunction() *SqrtFunction {
|
|
return &SqrtFunction{
|
|
BaseFunction: NewBaseFunction("sqrt", TypeMath, "数学函数", "计算平方根", 1, 1),
|
|
}
|
|
}
|
|
|
|
func (f *SqrtFunction) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *SqrtFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
val, err := cast.ToFloat64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if val < 0 {
|
|
return nil, fmt.Errorf("sqrt of negative number")
|
|
}
|
|
return math.Sqrt(val), nil
|
|
}
|
|
|
|
// AcosFunction 反余弦函数
|
|
type AcosFunction struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewAcosFunction() *AcosFunction {
|
|
return &AcosFunction{
|
|
BaseFunction: NewBaseFunction("acos", TypeMath, "数学函数", "计算反余弦值", 1, 1),
|
|
}
|
|
}
|
|
|
|
func (f *AcosFunction) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *AcosFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
val, err := cast.ToFloat64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if val < -1 || val > 1 {
|
|
return nil, fmt.Errorf("acos: value out of range [-1,1]")
|
|
}
|
|
return math.Acos(val), nil
|
|
}
|
|
|
|
// AsinFunction 反正弦函数
|
|
type AsinFunction struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewAsinFunction() *AsinFunction {
|
|
return &AsinFunction{
|
|
BaseFunction: NewBaseFunction("asin", TypeMath, "数学函数", "计算反正弦值", 1, 1),
|
|
}
|
|
}
|
|
|
|
func (f *AsinFunction) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *AsinFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
val, err := cast.ToFloat64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if val < -1 || val > 1 {
|
|
return nil, fmt.Errorf("asin: value out of range [-1,1]")
|
|
}
|
|
return math.Asin(val), nil
|
|
}
|
|
|
|
// AtanFunction 反正切函数
|
|
type AtanFunction struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewAtanFunction() *AtanFunction {
|
|
return &AtanFunction{
|
|
BaseFunction: NewBaseFunction("atan", TypeMath, "数学函数", "计算反正切值", 1, 1),
|
|
}
|
|
}
|
|
|
|
func (f *AtanFunction) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *AtanFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
val, err := cast.ToFloat64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return math.Atan(val), nil
|
|
}
|
|
|
|
// Atan2Function 两个参数的反正切函数
|
|
type Atan2Function struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewAtan2Function() *Atan2Function {
|
|
return &Atan2Function{
|
|
BaseFunction: NewBaseFunction("atan2", TypeMath, "数学函数", "计算两个参数的反正切值", 2, 2),
|
|
}
|
|
}
|
|
|
|
func (f *Atan2Function) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *Atan2Function) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
y, err := cast.ToFloat64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
x, err := cast.ToFloat64E(args[1])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return math.Atan2(y, x), nil
|
|
}
|
|
|
|
// BitAndFunction 按位与函数
|
|
type BitAndFunction struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewBitAndFunction() *BitAndFunction {
|
|
return &BitAndFunction{
|
|
BaseFunction: NewBaseFunction("bitand", TypeMath, "数学函数", "计算两个整数的按位与", 2, 2),
|
|
}
|
|
}
|
|
|
|
func (f *BitAndFunction) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *BitAndFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
a, err := cast.ToInt64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
b, err := cast.ToInt64E(args[1])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return a & b, nil
|
|
}
|
|
|
|
// BitOrFunction 按位或函数
|
|
type BitOrFunction struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewBitOrFunction() *BitOrFunction {
|
|
return &BitOrFunction{
|
|
BaseFunction: NewBaseFunction("bitor", TypeMath, "数学函数", "计算两个整数的按位或", 2, 2),
|
|
}
|
|
}
|
|
|
|
func (f *BitOrFunction) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *BitOrFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
a, err := cast.ToInt64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
b, err := cast.ToInt64E(args[1])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return a | b, nil
|
|
}
|
|
|
|
// BitXorFunction 按位异或函数
|
|
type BitXorFunction struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewBitXorFunction() *BitXorFunction {
|
|
return &BitXorFunction{
|
|
BaseFunction: NewBaseFunction("bitxor", TypeMath, "数学函数", "计算两个整数的按位异或", 2, 2),
|
|
}
|
|
}
|
|
|
|
func (f *BitXorFunction) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *BitXorFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
a, err := cast.ToInt64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
b, err := cast.ToInt64E(args[1])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return a ^ b, nil
|
|
}
|
|
|
|
// BitNotFunction 按位非函数
|
|
type BitNotFunction struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewBitNotFunction() *BitNotFunction {
|
|
return &BitNotFunction{
|
|
BaseFunction: NewBaseFunction("bitnot", TypeMath, "数学函数", "计算整数的按位非", 1, 1),
|
|
}
|
|
}
|
|
|
|
func (f *BitNotFunction) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *BitNotFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
a, err := cast.ToInt64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return ^a, nil
|
|
}
|
|
|
|
// CeilingFunction 向上取整函数
|
|
type CeilingFunction struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewCeilingFunction() *CeilingFunction {
|
|
return &CeilingFunction{
|
|
BaseFunction: NewBaseFunction("ceiling", TypeMath, "数学函数", "向上取整", 1, 1),
|
|
}
|
|
}
|
|
|
|
func (f *CeilingFunction) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *CeilingFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
val, err := cast.ToFloat64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return math.Ceil(val), nil
|
|
}
|
|
|
|
// CosFunction 余弦函数
|
|
type CosFunction struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewCosFunction() *CosFunction {
|
|
return &CosFunction{
|
|
BaseFunction: NewBaseFunction("cos", TypeMath, "数学函数", "计算余弦值", 1, 1),
|
|
}
|
|
}
|
|
|
|
func (f *CosFunction) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *CosFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
val, err := cast.ToFloat64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return math.Cos(val), nil
|
|
}
|
|
|
|
// CoshFunction 双曲余弦函数
|
|
type CoshFunction struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewCoshFunction() *CoshFunction {
|
|
return &CoshFunction{
|
|
BaseFunction: NewBaseFunction("cosh", TypeMath, "数学函数", "计算双曲余弦值", 1, 1),
|
|
}
|
|
}
|
|
|
|
func (f *CoshFunction) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *CoshFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
val, err := cast.ToFloat64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return math.Cosh(val), nil
|
|
}
|
|
|
|
// ExpFunction 指数函数
|
|
type ExpFunction struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewExpFunction() *ExpFunction {
|
|
return &ExpFunction{
|
|
BaseFunction: NewBaseFunction("exp", TypeMath, "数学函数", "计算e的幂", 1, 1),
|
|
}
|
|
}
|
|
|
|
func (f *ExpFunction) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *ExpFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
val, err := cast.ToFloat64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return math.Exp(val), nil
|
|
}
|
|
|
|
// FloorFunction 向下取整函数
|
|
type FloorFunction struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewFloorFunction() *FloorFunction {
|
|
return &FloorFunction{
|
|
BaseFunction: NewBaseFunction("floor", TypeMath, "数学函数", "向下取整", 1, 1),
|
|
}
|
|
}
|
|
|
|
func (f *FloorFunction) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *FloorFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
val, err := cast.ToFloat64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return math.Floor(val), nil
|
|
}
|
|
|
|
// LnFunction 自然对数函数
|
|
type LnFunction struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewLnFunction() *LnFunction {
|
|
return &LnFunction{
|
|
BaseFunction: NewBaseFunction("ln", TypeMath, "数学函数", "计算自然对数", 1, 1),
|
|
}
|
|
}
|
|
|
|
func (f *LnFunction) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *LnFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
val, err := cast.ToFloat64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if val <= 0 {
|
|
return nil, fmt.Errorf("ln: value must be positive")
|
|
}
|
|
return math.Log(val), nil
|
|
}
|
|
|
|
// LogFunction 自然对数函数 (log的别名)
|
|
type LogFunction struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewLogFunction() *LogFunction {
|
|
return &LogFunction{
|
|
BaseFunction: NewBaseFunction("log", TypeMath, "数学函数", "计算自然对数", 1, 1),
|
|
}
|
|
}
|
|
|
|
func (f *LogFunction) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *LogFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
val, err := cast.ToFloat64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if val <= 0 {
|
|
return nil, fmt.Errorf("log: value must be positive")
|
|
}
|
|
return math.Log(val), nil
|
|
}
|
|
|
|
// Log10Function 以10为底的对数函数
|
|
type Log10Function struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewLog10Function() *Log10Function {
|
|
return &Log10Function{
|
|
BaseFunction: NewBaseFunction("log10", TypeMath, "数学函数", "计算以10为底的对数", 1, 1),
|
|
}
|
|
}
|
|
|
|
func (f *Log10Function) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *Log10Function) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
val, err := cast.ToFloat64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if val <= 0 {
|
|
return nil, fmt.Errorf("log10: value must be positive")
|
|
}
|
|
return math.Log10(val), nil
|
|
}
|
|
|
|
// Log2Function 以2为底的对数函数
|
|
type Log2Function struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewLog2Function() *Log2Function {
|
|
return &Log2Function{
|
|
BaseFunction: NewBaseFunction("log2", TypeMath, "数学函数", "计算以2为底的对数", 1, 1),
|
|
}
|
|
}
|
|
|
|
func (f *Log2Function) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *Log2Function) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
val, err := cast.ToFloat64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if val <= 0 {
|
|
return nil, fmt.Errorf("log2: value must be positive")
|
|
}
|
|
return math.Log2(val), nil
|
|
}
|
|
|
|
// ModFunction 取模函数
|
|
type ModFunction struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewModFunction() *ModFunction {
|
|
return &ModFunction{
|
|
BaseFunction: NewBaseFunction("mod", TypeMath, "数学函数", "取模运算", 2, 2),
|
|
}
|
|
}
|
|
|
|
func (f *ModFunction) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *ModFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
x, err := cast.ToFloat64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
y, err := cast.ToFloat64E(args[1])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if y == 0 {
|
|
return nil, fmt.Errorf("mod: division by zero")
|
|
}
|
|
return math.Mod(x, y), nil
|
|
}
|
|
|
|
// RandFunction 随机数函数
|
|
type RandFunction struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewRandFunction() *RandFunction {
|
|
return &RandFunction{
|
|
BaseFunction: NewBaseFunction("rand", TypeMath, "数学函数", "生成0-1之间的随机数", 0, 0),
|
|
}
|
|
}
|
|
|
|
func (f *RandFunction) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *RandFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
// 使用当前时间作为种子
|
|
rand.Seed(time.Now().UnixNano())
|
|
return rand.Float64(), nil
|
|
}
|
|
|
|
// RoundFunction 四舍五入函数
|
|
type RoundFunction struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewRoundFunction() *RoundFunction {
|
|
return &RoundFunction{
|
|
BaseFunction: NewBaseFunction("round", TypeMath, "数学函数", "四舍五入", 1, 2),
|
|
}
|
|
}
|
|
|
|
func (f *RoundFunction) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *RoundFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
val, err := cast.ToFloat64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if len(args) == 1 {
|
|
return math.Round(val), nil
|
|
}
|
|
|
|
precision, err := cast.ToIntE(args[1])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
shift := math.Pow(10, float64(precision))
|
|
return math.Round(val*shift) / shift, nil
|
|
}
|
|
|
|
// SignFunction 符号函数
|
|
type SignFunction struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewSignFunction() *SignFunction {
|
|
return &SignFunction{
|
|
BaseFunction: NewBaseFunction("sign", TypeMath, "数学函数", "返回数字的符号", 1, 1),
|
|
}
|
|
}
|
|
|
|
func (f *SignFunction) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *SignFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
val, err := cast.ToFloat64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if val > 0 {
|
|
return 1, nil
|
|
} else if val < 0 {
|
|
return -1, nil
|
|
}
|
|
return 0, nil
|
|
}
|
|
|
|
// SinFunction 正弦函数
|
|
type SinFunction struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewSinFunction() *SinFunction {
|
|
return &SinFunction{
|
|
BaseFunction: NewBaseFunction("sin", TypeMath, "数学函数", "计算正弦值", 1, 1),
|
|
}
|
|
}
|
|
|
|
func (f *SinFunction) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *SinFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
val, err := cast.ToFloat64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return math.Sin(val), nil
|
|
}
|
|
|
|
// SinhFunction 双曲正弦函数
|
|
type SinhFunction struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewSinhFunction() *SinhFunction {
|
|
return &SinhFunction{
|
|
BaseFunction: NewBaseFunction("sinh", TypeMath, "数学函数", "计算双曲正弦值", 1, 1),
|
|
}
|
|
}
|
|
|
|
func (f *SinhFunction) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *SinhFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
val, err := cast.ToFloat64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return math.Sinh(val), nil
|
|
}
|
|
|
|
// TanFunction 正切函数
|
|
type TanFunction struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewTanFunction() *TanFunction {
|
|
return &TanFunction{
|
|
BaseFunction: NewBaseFunction("tan", TypeMath, "数学函数", "计算正切值", 1, 1),
|
|
}
|
|
}
|
|
|
|
func (f *TanFunction) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *TanFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
val, err := cast.ToFloat64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return math.Tan(val), nil
|
|
}
|
|
|
|
// TanhFunction 双曲正切函数
|
|
type TanhFunction struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewTanhFunction() *TanhFunction {
|
|
return &TanhFunction{
|
|
BaseFunction: NewBaseFunction("tanh", TypeMath, "数学函数", "计算双曲正切值", 1, 1),
|
|
}
|
|
}
|
|
|
|
func (f *TanhFunction) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *TanhFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
val, err := cast.ToFloat64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return math.Tanh(val), nil
|
|
}
|
|
|
|
// PowerFunction 幂函数
|
|
type PowerFunction struct {
|
|
*BaseFunction
|
|
}
|
|
|
|
func NewPowerFunction() *PowerFunction {
|
|
return &PowerFunction{
|
|
BaseFunction: NewBaseFunction("power", TypeMath, "数学函数", "计算x的y次幂", 2, 2),
|
|
}
|
|
}
|
|
|
|
func (f *PowerFunction) Validate(args []interface{}) error {
|
|
return f.ValidateArgCount(args)
|
|
}
|
|
|
|
func (f *PowerFunction) Execute(ctx *FunctionContext, args []interface{}) (interface{}, error) {
|
|
x, err := cast.ToFloat64E(args[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
y, err := cast.ToFloat64E(args[1])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return math.Pow(x, y), nil
|
|
}
|