geom/math.go

package geom

import "math"

func emulate32(f float32, fn func(float64) float64) float32 {
	return float32(fn(float64(f)))
}

// Pi constant https://oeis.org/A000796
const Pi = math.Pi

// Abs returns the absolute value.
func Abs(f float64) float64 {
	return math.Abs(f)
}

// Abs32 returns the absolute value.
func Abs32(f float32) float32 {
	return float32(Abs(float64(f)))
}

// Atan returns the arc tangent of f.
func Atan(f float64) float64 {
	return math.Atan(f)
}

// Atan2 returns the arc tangent of y/x.
func Atan2(y, x float64) float64 {
	return math.Atan2(y, x)
}

// Atan32 returns the arc tangent of f.
func Atan32(f float32) float32 {
	return float32(math.Atan(float64(f)))
}

// Atan232 returns the arc tangent of y/x.
func Atan232(y, x float32) float32 {
	return float32(math.Atan2(float64(y), float64(x)))
}

// Ceil rounds f up to an natural number.
func Ceil(f float64) float64 {
	return math.Ceil(f)
}

// Ceil32 rounds f up to an natural number.
func Ceil32(f float32) float32 { return emulate32(f, math.Ceil) }

// Cos returns the cosine of f.
func Cos(f float64) float64 {
	return math.Cos(f)
}

// Cos32 returns the cosine of f.
func Cos32(f float32) float32 {
	return float32(math.Cos(float64(f)))
}

// Floor rounds f down to an natural number.
func Floor(f float64) float64 {
	return math.Floor(f)
}

// Floor32 rounds f down to an natural number.
func Floor32(f float32) float32 { return emulate32(f, math.Floor) }

// IsNaN checks if the floating point number is not a number.
func IsNaN(f float64) bool {
	return f != f
}

// IsNaN32 checks if the floating point number is not a number.
func IsNaN32(f float32) bool {
	return f != f
}

// Max the maximum of the two values.
func Max(a, b float64) float64 {
	return math.Max(a, b)
}

// Max32 the maximum of the two values.
func Max32(a, b float32) float32 {
	return float32(math.Max(float64(a), float64(b)))
}

// Min the minimum of the two values.
func Min(a, b float64) float64 {
	return math.Min(a, b)
}

// Min32 the minimum of the two values.
func Min32(a, b float32) float32 {
	return float32(math.Min(float64(a), float64(b)))
}

// NaN returns not a floating point number.
func NaN() float64 {
	return math.NaN()
}

// NaN32 returns not a floating point number.
func NaN32() float32 {
	return float32(NaN())
}

// Pow returns the power e of base b.
func Pow(b, e float64) float64 {
	return math.Pow(b, e)
}

// Pow32 returns the power e of base b.
func Pow32(b, e float32) float32 {
	return float32(Pow(float64(b), float64(e)))
}

// Round rounds to the nearest integer.
func Round(f float64) float64 {
	return math.Round(f)
}

// Round32 rounds to the nearest integer.
func Round32(f float32) float32 {
	return float32(math.Round(float64(f)))
}

// Sin returns the sine of f.
func Sin(f float64) float64 {
	return math.Sin(f)
}

// Sin32 returns the sine of f.
func Sin32(f float32) float32 {
	return float32(math.Sin(float64(f)))
}

// Sq returns the squared value of f.
func Sq(f float64) float64 {
	return f * f
}

// Sq32 returns the squared value of f.
func Sq32(f float32) float32 {
	return f * f
}

// Sqrt the square root of the value.
func Sqrt(f float64) float64 {
	return math.Sqrt(f)
}

// Sqrt32 the square root of the value.
func Sqrt32(f float32) float32 {
	return float32(Sqrt(float64(f)))
}

// Tan returns the tangent of f.
func Tan(f float64) float64 {
	return math.Tan(f)
}

// Tan32 returns the tangent of f.
func Tan32(f float32) float32 {
	return float32(math.Tan(float64(f)))
}