mirror of
https://github.com/phishingclub/phishingclub.git
synced 2026-10-04 22:46:49 +02:00
159 lines
6.2 KiB
Go
159 lines
6.2 KiB
Go
package g
|
|
|
|
import "math"
|
|
|
|
// IsNaN reports whether the Float is an IEEE 754 "not-a-number" value.
|
|
func (f Float) IsNaN() bool { return math.IsNaN(f.Std()) }
|
|
|
|
// IsInf reports whether the Float is an infinity, either positive or negative.
|
|
func (f Float) IsInf() bool { return math.IsInf(f.Std(), 0) }
|
|
|
|
// IsFinite reports whether the Float is neither NaN nor an infinity.
|
|
func (f Float) IsFinite() bool { return !f.IsNaN() && !f.IsInf() }
|
|
|
|
// IsNormal reports whether the Float is a normal IEEE 754 number:
|
|
// neither zero, subnormal, infinite, nor NaN.
|
|
func (f Float) IsNormal() bool {
|
|
exp := f.Bits() >> 52 & 0x7ff
|
|
|
|
return exp != 0 && exp != 0x7ff
|
|
}
|
|
|
|
// Signum returns a Float representing the sign of the Float:
|
|
// 1 if the sign bit is clear (including +0), -1 if the sign bit is set (including -0),
|
|
// and NaN if the Float is NaN.
|
|
func (f Float) Signum() Float {
|
|
if f.IsNaN() {
|
|
return f
|
|
}
|
|
|
|
return Float(math.Copysign(1, f.Std()))
|
|
}
|
|
|
|
// IsSignPositive reports whether the Float has a positive sign bit.
|
|
// This includes +0.0 and positive infinity.
|
|
// Note: NaN carries a sign bit too, so a NaN with a clear sign bit (e.g. math.NaN())
|
|
// is reported as sign-positive; use IsNaN to detect NaN itself.
|
|
func (f Float) IsSignPositive() bool { return !math.Signbit(f.Std()) }
|
|
|
|
// IsSignNegative reports whether the Float has a negative sign bit.
|
|
// This includes -0.0 and negative infinity.
|
|
// Note: NaN carries a sign bit too, so a NaN with a set sign bit (e.g.
|
|
// math.Copysign(math.NaN(), -1)) is reported as sign-negative; use IsNaN to
|
|
// detect NaN itself.
|
|
func (f Float) IsSignNegative() bool { return math.Signbit(f.Std()) }
|
|
|
|
// Ceil returns the least integer value greater than or equal to the Float.
|
|
func (f Float) Ceil() Float { return Float(math.Ceil(f.Std())) }
|
|
|
|
// Floor returns the greatest integer value less than or equal to the Float.
|
|
func (f Float) Floor() Float { return Float(math.Floor(f.Std())) }
|
|
|
|
// Trunc returns the integer part of the Float, rounding toward zero.
|
|
func (f Float) Trunc() Float { return Float(math.Trunc(f.Std())) }
|
|
|
|
// Fract returns the fractional part of the Float (f - f.Trunc()).
|
|
// For NaN and ±Inf the result is NaN.
|
|
func (f Float) Fract() Float { return f - f.Trunc() }
|
|
|
|
// Clamp restricts the Float to the inclusive range [min, max].
|
|
// If the Float is NaN, NaN is returned.
|
|
// The caller must ensure min <= max and that neither bound is NaN: this method
|
|
// does not panic on an invalid range — a NaN bound never
|
|
// compares true, so the corresponding check is silently skipped, and with
|
|
// min > max the lower bound wins.
|
|
func (f Float) Clamp(min, max Float) Float {
|
|
if f < min {
|
|
return min
|
|
}
|
|
|
|
if f > max {
|
|
return max
|
|
}
|
|
|
|
return f
|
|
}
|
|
|
|
// Recip returns the reciprocal (multiplicative inverse) of the Float, 1/f.
|
|
func (f Float) Recip() Float { return 1 / f }
|
|
|
|
// Copysign returns a Float with the magnitude of the Float and the sign of sign.
|
|
func (f Float) Copysign(sign Float) Float { return Float(math.Copysign(f.Std(), sign.Std())) }
|
|
|
|
// MulAdd returns f*b + c computed as a fused multiply-add with only one rounding.
|
|
func (f Float) MulAdd(b, c Float) Float { return Float(math.FMA(f.Std(), b.Std(), c.Std())) }
|
|
|
|
// Hypot returns Sqrt(f*f + b*b), avoiding unnecessary overflow and underflow.
|
|
func (f Float) Hypot(b Float) Float { return Float(math.Hypot(f.Std(), b.Std())) }
|
|
|
|
// Cbrt returns the cube root of the Float.
|
|
func (f Float) Cbrt() Float { return Float(math.Cbrt(f.Std())) }
|
|
|
|
// Exp returns e**f, the base-e exponential of the Float.
|
|
func (f Float) Exp() Float { return Float(math.Exp(f.Std())) }
|
|
|
|
// Exp2 returns 2**f, the base-2 exponential of the Float.
|
|
func (f Float) Exp2() Float { return Float(math.Exp2(f.Std())) }
|
|
|
|
// ExpM1 returns e**f - 1, which is more accurate than Exp().Sub(1) when the Float is near zero.
|
|
func (f Float) ExpM1() Float { return Float(math.Expm1(f.Std())) }
|
|
|
|
// Ln returns the natural logarithm of the Float.
|
|
func (f Float) Ln() Float { return Float(math.Log(f.Std())) }
|
|
|
|
// Ln1p returns the natural logarithm of 1 plus the Float,
|
|
// which is more accurate than Add(1).Ln() when the Float is near zero.
|
|
func (f Float) Ln1p() Float { return Float(math.Log1p(f.Std())) }
|
|
|
|
// Log2 returns the base-2 logarithm of the Float.
|
|
func (f Float) Log2() Float { return Float(math.Log2(f.Std())) }
|
|
|
|
// Log10 returns the base-10 logarithm of the Float.
|
|
func (f Float) Log10() Float { return Float(math.Log10(f.Std())) }
|
|
|
|
// Sin returns the sine of the Float (in radians).
|
|
func (f Float) Sin() Float { return Float(math.Sin(f.Std())) }
|
|
|
|
// Cos returns the cosine of the Float (in radians).
|
|
func (f Float) Cos() Float { return Float(math.Cos(f.Std())) }
|
|
|
|
// Tan returns the tangent of the Float (in radians).
|
|
func (f Float) Tan() Float { return Float(math.Tan(f.Std())) }
|
|
|
|
// Asin returns the arcsine of the Float, in radians.
|
|
func (f Float) Asin() Float { return Float(math.Asin(f.Std())) }
|
|
|
|
// Acos returns the arccosine of the Float, in radians.
|
|
func (f Float) Acos() Float { return Float(math.Acos(f.Std())) }
|
|
|
|
// Atan returns the arctangent of the Float, in radians.
|
|
func (f Float) Atan() Float { return Float(math.Atan(f.Std())) }
|
|
|
|
// Atan2 returns the arctangent of f/b (with f as y and b as x), in radians,
|
|
// using the signs of the two to determine the quadrant of the result.
|
|
func (f Float) Atan2(b Float) Float { return Float(math.Atan2(f.Std(), b.Std())) }
|
|
|
|
// Sinh returns the hyperbolic sine of the Float.
|
|
func (f Float) Sinh() Float { return Float(math.Sinh(f.Std())) }
|
|
|
|
// Cosh returns the hyperbolic cosine of the Float.
|
|
func (f Float) Cosh() Float { return Float(math.Cosh(f.Std())) }
|
|
|
|
// Tanh returns the hyperbolic tangent of the Float.
|
|
func (f Float) Tanh() Float { return Float(math.Tanh(f.Std())) }
|
|
|
|
// Asinh returns the inverse hyperbolic sine of the Float.
|
|
func (f Float) Asinh() Float { return Float(math.Asinh(f.Std())) }
|
|
|
|
// Acosh returns the inverse hyperbolic cosine of the Float.
|
|
func (f Float) Acosh() Float { return Float(math.Acosh(f.Std())) }
|
|
|
|
// Atanh returns the inverse hyperbolic tangent of the Float.
|
|
func (f Float) Atanh() Float { return Float(math.Atanh(f.Std())) }
|
|
|
|
// ToDegrees converts the Float from radians to degrees.
|
|
func (f Float) ToDegrees() Float { return f * (180 / math.Pi) }
|
|
|
|
// ToRadians converts the Float from degrees to radians.
|
|
func (f Float) ToRadians() Float { return f * (math.Pi / 180) }
|