github.com/sandwich-go/boost@v1.3.29/xmath/math.go

// Code generated by tools. DO NOT EDIT.
package xmath

import "math"

const (
	EPSILON64 float64 = 0.00000001
	EPSILON32 float32 = 0.00000001
)

// Integer limit values.
const (
	ConstMaxInt    = math.MaxInt
	ConstMinInt    = math.MinInt
	ConstMaxUint   = math.MaxUint
	ConstMaxInt8   = math.MaxInt8
	ConstMinInt8   = math.MinInt8
	ConstMaxInt16  = math.MaxInt16
	ConstMinInt16  = math.MinInt16
	ConstMaxInt32  = math.MaxInt32
	ConstMinInt32  = math.MinInt32
	ConstMaxInt64  = math.MaxInt64
	ConstMinInt64  = math.MinInt64
	ConstMaxUint8  = math.MaxUint8
	ConstMaxUint16 = math.MaxUint16
	ConstMaxUint32 = math.MaxUint32
	ConstMaxUint64 = math.MaxUint64
)

// Float64Equals 判断 float64 是否相等
func Float64Equals(a, b float64) bool {
	return (a-b) < EPSILON64 && (b-a) < EPSILON64
}

// Float32Equals 判断 float32 是否相等
func Float32Equals(a, b float32) bool {
	return (a-b) < EPSILON32 && (b-a) < EPSILON32
}

// IsZeroFloat64 判断 float64 是否是零值
func IsZeroFloat64(v float64) bool {
	return Float64Equals(v, 0)
}

// IsZeroFloat32 判断 float32 是否是零值
func IsZeroFloat32(v float32) bool {
	return Float32Equals(v, 0)
}

// IsBelowZeroFloat64 v == 0 时也返回true
func IsBelowZeroFloat64(v float64) bool {
	return (v - 0) < EPSILON64
}

// IsBelowZeroFloat32 v == 0 时也返回true
func IsBelowZeroFloat32(v float32) bool {
	return (v - 0) < EPSILON32
}

// MaxFloat32 返回 float32 类型大值
func MaxFloat32(a, b float32) float32 {
	return float32(math.Max(float64(a), float64(b)))
}

// MinFloat32 返回 float32 类型小值
func MinFloat32(a, b float32) float32 {
	return float32(math.Min(float64(a), float64(b)))
}

// AbsFloat32 返回 float32 类型绝对值
func AbsFloat32(v float32) float32 {
	if IsBelowZeroFloat32(v) {
		return -v
	}
	return v
}

// EffectZeroLimitFloat32 加 change 值，返回 float32 类型值，该值不会小于0
func EffectZeroLimitFloat32(v, change float32) float32 {
	v += change
	if IsBelowZeroFloat32(v) {
		v = 0
	}
	return v
}

// MaxFloat64 返回 float64 类型大值
func MaxFloat64(a, b float64) float64 {
	return math.Max(a, b)
}

// MinFloat64 返回 float64 类型小值
func MinFloat64(a, b float64) float64 {
	return math.Min(a, b)
}

// AbsFloat64 返回 float64 类型绝对值
func AbsFloat64(v float64) float64 {
	if IsBelowZeroFloat64(v) {
		return -v
	}
	return v
}

// EffectZeroLimitFloat64 加 change 值，返回 float64 类型值，该值不会小于0
func EffectZeroLimitFloat64(v, change float64) float64 {
	v += change
	if IsBelowZeroFloat64(v) {
		v = 0
	}
	return v
}

// MaxInt 返回 int 类型大值
func MaxInt(a, b int) int {
	if a > b {
		return a
	}
	return b
}

// MinInt 返回 int 类型小值
func MinInt(a, b int) int {
	if a < b {
		return a
	}
	return b
}

// AbsInt 返回 int 类型绝对值
func AbsInt(v int) int {
	if v < 0 {
		return -v
	}
	return v
}

// EffectZeroLimitInt 加 change 值，返回 int 类型值，该值不会小于0
func EffectZeroLimitInt(v, change int) int {
	v += change
	if v < 0 {
		v = 0
	}
	return v
}

// MaxInt16 返回 int16 类型大值
func MaxInt16(a, b int16) int16 {
	if a > b {
		return a
	}
	return b
}

// MinInt16 返回 int16 类型小值
func MinInt16(a, b int16) int16 {
	if a < b {
		return a
	}
	return b
}

// AbsInt16 返回 int16 类型绝对值
func AbsInt16(v int16) int16 {
	if v < 0 {
		return -v
	}
	return v
}

// EffectZeroLimitInt16 加 change 值，返回 int16 类型值，该值不会小于0
func EffectZeroLimitInt16(v, change int16) int16 {
	v += change
	if v < 0 {
		v = 0
	}
	return v
}

// MaxInt32 返回 int32 类型大值
func MaxInt32(a, b int32) int32 {
	if a > b {
		return a
	}
	return b
}

// MinInt32 返回 int32 类型小值
func MinInt32(a, b int32) int32 {
	if a < b {
		return a
	}
	return b
}

// AbsInt32 返回 int32 类型绝对值
func AbsInt32(v int32) int32 {
	if v < 0 {
		return -v
	}
	return v
}

// EffectZeroLimitInt32 加 change 值，返回 int32 类型值，该值不会小于0
func EffectZeroLimitInt32(v, change int32) int32 {
	v += change
	if v < 0 {
		v = 0
	}
	return v
}

// MaxInt64 返回 int64 类型大值
func MaxInt64(a, b int64) int64 {
	if a > b {
		return a
	}
	return b
}

// MinInt64 返回 int64 类型小值
func MinInt64(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

// AbsInt64 返回 int64 类型绝对值
func AbsInt64(v int64) int64 {
	if v < 0 {
		return -v
	}
	return v
}

// EffectZeroLimitInt64 加 change 值，返回 int64 类型值，该值不会小于0
func EffectZeroLimitInt64(v, change int64) int64 {
	v += change
	if v < 0 {
		v = 0
	}
	return v
}

// MaxInt8 返回 int8 类型大值
func MaxInt8(a, b int8) int8 {
	if a > b {
		return a
	}
	return b
}

// MinInt8 返回 int8 类型小值
func MinInt8(a, b int8) int8 {
	if a < b {
		return a
	}
	return b
}

// AbsInt8 返回 int8 类型绝对值
func AbsInt8(v int8) int8 {
	if v < 0 {
		return -v
	}
	return v
}

// EffectZeroLimitInt8 加 change 值，返回 int8 类型值，该值不会小于0
func EffectZeroLimitInt8(v, change int8) int8 {
	v += change
	if v < 0 {
		v = 0
	}
	return v
}

// MaxUint 返回 uint 类型大值
func MaxUint(a, b uint) uint {
	if a > b {
		return a
	}
	return b
}

// MinUint 返回 uint 类型小值
func MinUint(a, b uint) uint {
	if a < b {
		return a
	}
	return b
}

// MaxUint16 返回 uint16 类型大值
func MaxUint16(a, b uint16) uint16 {
	if a > b {
		return a
	}
	return b
}

// MinUint16 返回 uint16 类型小值
func MinUint16(a, b uint16) uint16 {
	if a < b {
		return a
	}
	return b
}

// MaxUint32 返回 uint32 类型大值
func MaxUint32(a, b uint32) uint32 {
	if a > b {
		return a
	}
	return b
}

// MinUint32 返回 uint32 类型小值
func MinUint32(a, b uint32) uint32 {
	if a < b {
		return a
	}
	return b
}

// MaxUint64 返回 uint64 类型大值
func MaxUint64(a, b uint64) uint64 {
	if a > b {
		return a
	}
	return b
}

// MinUint64 返回 uint64 类型小值
func MinUint64(a, b uint64) uint64 {
	if a < b {
		return a
	}
	return b
}

// MaxUint8 返回 uint8 类型大值
func MaxUint8(a, b uint8) uint8 {
	if a > b {
		return a
	}
	return b
}

// MinUint8 返回 uint8 类型小值
func MinUint8(a, b uint8) uint8 {
	if a < b {
		return a
	}
	return b
}