230 lines
4.4 KiB
Go
230 lines
4.4 KiB
Go
package lua
|
|
|
|
import (
|
|
"math"
|
|
"math/rand"
|
|
)
|
|
|
|
func mathOpen(L *LState) {
|
|
mod := L.RegisterModule("math", mathFuncs).(*LTable)
|
|
mod.RawSetString("pi", LNumber(math.Pi))
|
|
mod.RawSetString("huge", LNumber(math.MaxFloat64))
|
|
}
|
|
|
|
var mathFuncs = map[string]LGFunction{
|
|
"abs": mathAbs,
|
|
"acos": mathAcos,
|
|
"asin": mathAsin,
|
|
"atan": mathAtan,
|
|
"atan2": mathAtan2,
|
|
"ceil": mathCeil,
|
|
"cos": mathCos,
|
|
"cosh": mathCosh,
|
|
"deg": mathDeg,
|
|
"exp": mathExp,
|
|
"floor": mathFloor,
|
|
"fmod": mathFmod,
|
|
"frexp": mathFrexp,
|
|
"ldexp": mathLdexp,
|
|
"log": mathLog,
|
|
"log10": mathLog10,
|
|
"max": mathMax,
|
|
"min": mathMin,
|
|
"mod": mathMod,
|
|
"modf": mathModf,
|
|
"pow": mathPow,
|
|
"rad": mathRad,
|
|
"random": mathRandom,
|
|
"randomseed": mathRandomseed,
|
|
"sin": mathSin,
|
|
"sinh": mathSinh,
|
|
"sqrt": mathSqrt,
|
|
"tan": mathTan,
|
|
"tanh": mathTanh,
|
|
}
|
|
|
|
func mathAbs(L *LState) int {
|
|
L.Push(LNumber(math.Abs(float64(L.CheckNumber(1)))))
|
|
return 1
|
|
}
|
|
|
|
func mathAcos(L *LState) int {
|
|
L.Push(LNumber(math.Acos(float64(L.CheckNumber(1)))))
|
|
return 1
|
|
}
|
|
|
|
func mathAsin(L *LState) int {
|
|
L.Push(LNumber(math.Asin(float64(L.CheckNumber(1)))))
|
|
return 1
|
|
}
|
|
|
|
func mathAtan(L *LState) int {
|
|
L.Push(LNumber(math.Atan(float64(L.CheckNumber(1)))))
|
|
return 1
|
|
}
|
|
|
|
func mathAtan2(L *LState) int {
|
|
L.Push(LNumber(math.Atan2(float64(L.CheckNumber(1)), float64(L.CheckNumber(2)))))
|
|
return 1
|
|
}
|
|
|
|
func mathCeil(L *LState) int {
|
|
L.Push(LNumber(math.Ceil(float64(L.CheckNumber(1)))))
|
|
return 1
|
|
}
|
|
|
|
func mathCos(L *LState) int {
|
|
L.Push(LNumber(math.Cos(float64(L.CheckNumber(1)))))
|
|
return 1
|
|
}
|
|
|
|
func mathCosh(L *LState) int {
|
|
L.Push(LNumber(math.Cosh(float64(L.CheckNumber(1)))))
|
|
return 1
|
|
}
|
|
|
|
func mathDeg(L *LState) int {
|
|
L.Push(LNumber(float64(L.CheckNumber(1)) * 180 / math.Pi))
|
|
return 1
|
|
}
|
|
|
|
func mathExp(L *LState) int {
|
|
L.Push(LNumber(math.Exp(float64(L.CheckNumber(1)))))
|
|
return 1
|
|
}
|
|
|
|
func mathFloor(L *LState) int {
|
|
L.Push(LNumber(math.Floor(float64(L.CheckNumber(1)))))
|
|
return 1
|
|
}
|
|
|
|
func mathFmod(L *LState) int {
|
|
L.Push(LNumber(math.Mod(float64(L.CheckNumber(1)), float64(L.CheckNumber(2)))))
|
|
return 1
|
|
}
|
|
|
|
func mathFrexp(L *LState) int {
|
|
v1, v2 := math.Frexp(float64(L.CheckNumber(1)))
|
|
L.Push(LNumber(v1))
|
|
L.Push(LNumber(v2))
|
|
return 2
|
|
}
|
|
|
|
func mathLdexp(L *LState) int {
|
|
L.Push(LNumber(math.Ldexp(float64(L.CheckNumber(1)), L.CheckInt(2))))
|
|
return 1
|
|
}
|
|
|
|
func mathLog(L *LState) int {
|
|
L.Push(LNumber(math.Log(float64(L.CheckNumber(1)))))
|
|
return 1
|
|
}
|
|
|
|
func mathLog10(L *LState) int {
|
|
L.Push(LNumber(math.Log10(float64(L.CheckNumber(1)))))
|
|
return 1
|
|
}
|
|
|
|
func mathMax(L *LState) int {
|
|
if L.GetTop() == 0 {
|
|
L.RaiseError("wrong number of arguments")
|
|
}
|
|
max := L.CheckNumber(1)
|
|
top := L.GetTop()
|
|
for i := 2; i <= top; i++ {
|
|
v := L.CheckNumber(i)
|
|
if v > max {
|
|
max = v
|
|
}
|
|
}
|
|
L.Push(max)
|
|
return 1
|
|
}
|
|
|
|
func mathMin(L *LState) int {
|
|
if L.GetTop() == 0 {
|
|
L.RaiseError("wrong number of arguments")
|
|
}
|
|
min := L.CheckNumber(1)
|
|
top := L.GetTop()
|
|
for i := 2; i <= top; i++ {
|
|
v := L.CheckNumber(i)
|
|
if v < min {
|
|
min = v
|
|
}
|
|
}
|
|
L.Push(min)
|
|
return 1
|
|
}
|
|
|
|
func mathMod(L *LState) int {
|
|
lhs := L.CheckNumber(1)
|
|
rhs := L.CheckNumber(2)
|
|
L.Push(luaModulo(lhs, rhs))
|
|
return 1
|
|
}
|
|
|
|
func mathModf(L *LState) int {
|
|
v1, v2 := math.Modf(float64(L.CheckNumber(1)))
|
|
L.Push(LNumber(v1))
|
|
L.Push(LNumber(v2))
|
|
return 2
|
|
}
|
|
|
|
func mathPow(L *LState) int {
|
|
L.Push(LNumber(math.Pow(float64(L.CheckNumber(1)), float64(L.CheckNumber(2)))))
|
|
return 1
|
|
}
|
|
|
|
func mathRad(L *LState) int {
|
|
L.Push(LNumber(float64(L.CheckNumber(1)) * math.Pi / 180))
|
|
return 1
|
|
}
|
|
|
|
func mathRandom(L *LState) int {
|
|
switch L.GetTop() {
|
|
case 0:
|
|
L.Push(LNumber(rand.Float64()))
|
|
case 1:
|
|
n := L.CheckInt(1)
|
|
L.Push(LNumber(rand.Intn(n-1) + 1))
|
|
default:
|
|
min := L.CheckInt(1)
|
|
max := L.CheckInt(2) + 1
|
|
L.Push(LNumber(rand.Intn(max-min) + min))
|
|
}
|
|
return 1
|
|
}
|
|
|
|
func mathRandomseed(L *LState) int {
|
|
rand.Seed(L.CheckInt64(1))
|
|
return 0
|
|
}
|
|
|
|
func mathSin(L *LState) int {
|
|
L.Push(LNumber(math.Sin(float64(L.CheckNumber(1)))))
|
|
return 1
|
|
}
|
|
|
|
func mathSinh(L *LState) int {
|
|
L.Push(LNumber(math.Sinh(float64(L.CheckNumber(1)))))
|
|
return 1
|
|
}
|
|
|
|
func mathSqrt(L *LState) int {
|
|
L.Push(LNumber(math.Sqrt(float64(L.CheckNumber(1)))))
|
|
return 1
|
|
}
|
|
|
|
func mathTan(L *LState) int {
|
|
L.Push(LNumber(math.Tan(float64(L.CheckNumber(1)))))
|
|
return 1
|
|
}
|
|
|
|
func mathTanh(L *LState) int {
|
|
L.Push(LNumber(math.Tanh(float64(L.CheckNumber(1)))))
|
|
return 1
|
|
}
|
|
|
|
//
|