Basic floating point functions

Basic real functions

• Operator overloading, general real functions
  • Operator overloading: scope and restrictions
  • The cost of creating and destroying objects
  • Raw addition of two floating point numbers
    • ctx.rawadd()
  • Raw subtraction of two floating point numbers
    • ctx.rawsub()
  • Raw multiplication of two floating point numbers
    • ctx.rawmul()
  • Raw division of two floating point numbers
    • ctx.rawdiv()
  • Raw addition of a floating point number and a signed 32 bit integer
    • ctx.rawaddint32()
  • Raw subtraction of a floating point number and a signed 32 bit integer
    • ctx.rawsubint32()
    • ctx.rawIntSub()
  • Raw multiplication of a floating point number and a signed 32 bit integer
    • ctx.rawmulint32()
  • Raw division of a floating point number and a signed 32 bit integer
    • ctx.rawdivint32()
    • ctx.rawIntDiv()
  • Fused multiplication and addition: \(\mathrm{fma}(x, y, z)\)
    • ctx.fma()
  • Maximum of two floating point numbers: \(\mathrm{fmax}(x, y)\)
    • ctx.fmax()
  • Minimum of two floating point numbers: \(\mathrm{fmin}(x, y)\)
    • ctx.fmin()
• Machine constants, general
  • Zero, positive zero
    • ctx.zero
  • Negative zero
    • ctx.negzero
  • One
    • Cxt.one
  • Positive infinity
    • ctx.inf()
  • Negative infinity
    • ctx.neginf()
  • NaN (Not a Number)
    • ctx.nan()
• Properties of numbers
  • Test for signbit
    • ctx.signbit()
  • Test for a finite number
    • ctx.isfinite()
  • Test for infinity
    • ctx.isinf()
  • Test for positive infinity
    • ctx.isposinf()
  • Test for negative infinity
    • ctx.isneginf()
  • Test for NaN
    • ctx.isnan()
  • Test for zero
    • ctx.iszero()
  • Test for one
    • ctx.isone()
  • Test if a number is an integer
    • ctx.isinteger()
  • Test if a number is a simple number (not an infinity or NaN)
    • ctx.isnumber()
  • Test if a number is a regular number (not zero, an infinity or NaN)
    • ctx.isregular()
  • Test if a number is a normal number (not subnormal, zero, an infinity or NaN)
    • ctx.isnormal()
  • Test if 2 numbers are unordered
    • ctx.isunordered()
  • Test if a number fits in a signed 32 bit integer
    • ctx.fitsint32()
  • Test if a number fits in a signed 64 bit integer
    • ctx.fitsint64()
• Integer related functions
  • Integral value nearest \(x\) (rounding to nearest): \(\mathrm{nearbyint}(x), \mathrm{rint}(x)\)
    • ctx.rint()
    • ctx.nearbyint()
  • 32 bit integer nearest \(x\) (rounding to nearest): \(\mathrm{lrint}(x)\)
    • ctx.lrint()
  • 64 bit integer nearest \(x\) (rounding to nearest): \(\mathrm{llrint}(x)\)
    • ctx.llrint()
  • Smallest integral value not less than \(x: \mathrm{ceil}(x)\)
    • ctx.ceil()
  • Largest integral value not greater than \(x: \mathrm{floor}(x)\)
    • ctx.floor()
  • Nearest integral value not greater in magnitude than \(x: \mathrm{trunc}(x)\)
    • ctx.trunc()
  • Nearest integral value, rounding halfway cases away from zero: \(\mathrm{round}(x)\)
    • ctx.round()
  • Nearest 32 bit integer, rounding halfway cases away from zero: \(\mathrm{lround}(x)\)
    • ctx.lround()
  • Nearest 64 bit integer, rounding halfway cases away from zero: \(\mathrm{llround}(x)\)
    • ctx.llround()
• Floating point functions for real numbers
  • Efficient computation of \(|x| \cdot \mathrm{sign}(y): \mathrm{copysign}(x, y)\)
    • ctx.copysign()
  • Decomposition of \(x\) as \(x = m \cdot 2^e; 0.5<m<1: \mathrm{frexp}(x)\)
    • ctx.frexp()
  • Integral value \(e\), from the decomposition of \(x\) as \(x = m \cdot 2^e; 1<m<2: \mathrm{logb}(x)\)
    • ctx.logb()
  • 32 bit integer \(e\), from the decomposition of \(x\) as \(x = m \cdot 2^e; 1<m<2: \mathrm{ilogb}(x)\)
    • ctx.ilogb()
  • Efficient computation of \(x \cdot 2^e: \mathrm{ldexp}(x,e), \mathrm{scalbn}(x,e), \mathrm{scalbln}(x,e)\)
    • ctx.ldexp()
    • ctx.scalbn()
    • ctx.scalbln()
  • Positive difference between \(x\) and \(y\): \(\mathrm{fdim}(x, y)\)
    • ctx.fdim()
• Fraction and remainder related functions
  • Integral and fractional part of a floating point number: \(\mathrm{modf}(x)\)
    • ctx.modf()
  • Floating point remainder: \(\mathrm{fmod}(x, y)\)
    • ctx.fmod()
  • IEEE floating point remainder: \(\mathrm{remainder}(x, y)\)
    • ctx.remainder()
  • IEEE floating point remainder and part of quotient: \(\mathrm{remquo}(x, y)\)
    • ctx.remquo()
• Functions related to mantissa width and exponent range
  • Machine Epsilon
    • ctx.epsilon()
  • Unit in the last place
    • ctx.ulp()
  • Largest representable number
    • ctx.maxvalue()
  • Lowest representable number
    • ctx.lowestvalue()
  • Smallest representable positive number
    • ctx.minposvalue()
  • Next representable floating point number: \(\mathrm{nexttowards}(x, y)\)
    • ctx.nexttowards()
  • Next representable floating point number: \(\mathrm{nextabove}(x)\)
    • ctx.nextabove()
  • Next representable floating point number: \(\mathrm{nextbelow}(x)\)
    • ctx.nextbelow()
• Mathematical Constants
  • Degree
    • ctx.degree
  • Golden ratio phi
    • ctx.phi
  • Natural logarithm of 2
    • ctx.ln2
  • Natural logarithm of 10
    • ctx.ln10
  • Pi (\(\pi\))
    • ctx.pi
  • Euler e
    • ctx.e
  • Euler-Mascheroni constant \(\gamma\)
    • ctx.egamma
  • Apéry’s constant
    • ctx.apery
  • Catalan’s constant
    • ctx.catalan
  • Glaisher’s constant
    • ctx.glaisher
  • Khinchin’s constant
    • ctx.khinchin
  • Imaginary One
    • ctx.onei