ember/base_math.go at main · besmpl/ember · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
package ember

import (
	"fmt"
	"math"
)

func baseMath() *Table {
	table := newTableWithCapacity(0, 5)
	_ = table.Set(StringValue("abs"), HostFuncValue(baseMathAbs))
	_ = table.Set(StringValue("floor"), HostFuncValue(baseMathFloor))
	_ = table.Set(StringValue("max"), HostFuncValue(baseMathMax))
	_ = table.Set(StringValue("min"), nativeFuncValueWithID(baseMathMinNative, nativeFuncMathMin))
	_ = table.Set(StringValue("pi"), NumberValue(math.Pi))
	return table
}

func baseMathAbs(args []Value) ([]Value, error) {
	value, err := numberArg("math.abs", args, 0)
	if err != nil {
		return nil, err
	}
	return []Value{NumberValue(math.Abs(value))}, nil
}

func baseMathFloor(args []Value) ([]Value, error) {
	value, err := numberArg("math.floor", args, 0)
	if err != nil {
		return nil, err
	}
	return []Value{NumberValue(math.Floor(value))}, nil
}

func baseMathMax(args []Value) ([]Value, error) {
	values, err := numberArgs("math.max", args)
	if err != nil {
		return nil, err
	}
	maximum := values[0]
	for _, value := range values[1:] {
		maximum = math.Max(maximum, value)
	}
	return []Value{NumberValue(maximum)}, nil
}

func baseMathMin(args []Value) ([]Value, error) {
	minimum, err := baseMathMinValue(args)
	if err != nil {
		return nil, err
	}
	return []Value{NumberValue(minimum)}, nil
}

func baseMathMinNative(_ *globalEnv, args []Value) ([]Value, error) {
	return baseMathMin(args)
}

func baseMathMinValue(args []Value) (float64, error) {
	if len(args) == 0 {
		return 0, fmt.Errorf("math.min: argument #1 is nil, want number")
	}
	minimum, err := numberArg("math.min", args, 0)
	if err != nil {
		return 0, err
	}
	for i := 1; i < len(args); i++ {
		value, err := numberArg("math.min", args, i)
		if err != nil {
			return 0, err
		}
		minimum = math.Min(minimum, value)
	}
	return minimum, nil
}

func numberArgs(fn string, args []Value) ([]float64, error) {
	if len(args) == 0 {
		return nil, fmt.Errorf("%s: argument #1 is nil, want number", fn)
	}
	values := make([]float64, len(args))
	for i := range args {
		value, err := numberArg(fn, args, i)
		if err != nil {
			return nil, err
		}
		values[i] = value
	}
	return values, nil
}