C's math.frexp in TypeScript

How to use

Install via yarn add locutus and import: import { frexp } from 'locutus/c/math/frexp'.

Or with CommonJS: const { frexp } = require('locutus/c/math/frexp')

Use a bundler that supports tree-shaking so you only ship the functions you actually use. Vite, webpack, Rollup, and Parcel all handle this. For server-side use this is less of a concern.

Examples

These examples are extracted from test cases that automatically verify our functions against their native counterparts.

#	code	expected result
1	frexp(1)	[0.5, 1]
2	frexp(1.5)	[0.75, 1]
3	frexp(3 * Math.pow(2, 500))	[0.75, 502]
4	frexp(-4)	[-0.5, 3]
5	frexp(Number.MAX_VALUE)	[0.9999999999999999, 1024]
6	frexp(Number.MIN_VALUE)	[0.5, -1073]
7	frexp(-Infinity)	[-Infinity, 0]
8	frexp(-0)	[-0, 0]
9	frexp(NaN)	[NaN, 0]

C types and TypeScript/JavaScript

C is statically typed while TypeScript/JavaScript is dynamically typed. Locutus C functions accept TypeScript/JavaScript's flexible types but are only parity-verified for inputs that would be valid in C.

For example, abs() in TypeScript/JavaScript accepts floats (like C's fabs()) and handles strings gracefully, but only integer inputs are verified against native C. This pragmatic approach gives you the expected C behavior for valid inputs while leveraging TypeScript/JavaScript's flexibility for edge cases.

Notes

• Instead of double frexp( double arg, int* exp ); this is built as [double, int] frexp( double arg ); due to the lack of pointers in JavaScript. See code comments for further information.

Here's what our current TypeScript equivalent to C's frexp found in the math.h header file looks like.

TSTypeScript JSJavaScript TSStandalone TS JSStandalone JS

Copy code

export function frexp(arg: number): [number, number] {
  //  discuss at: https://locutus.io/c/frexp/
  // original by: Oskar Larsson Högfeldt (https://oskar-lh.name/)
  //      note 1: Instead of
  //      note 1: double frexp( double arg, int* exp );
  //      note 1: this is built as
  //      note 1: [double, int] frexp( double arg );
  //      note 1: due to the lack of pointers in JavaScript.
  //      note 1: See code comments for further information.
  //   example 1: frexp(1)
  //   returns 1: [0.5, 1]
  //   example 2: frexp(1.5)
  //   returns 2: [0.75, 1]
  //   example 3: frexp(3 * Math.pow(2, 500))
  //   returns 3: [0.75, 502]
  //   example 4: frexp(-4)
  //   returns 4: [-0.5, 3]
  //   example 5: frexp(Number.MAX_VALUE)
  //   returns 5: [0.9999999999999999, 1024]
  //   example 6: frexp(Number.MIN_VALUE)
  //   returns 6: [0.5, -1073]
  //   example 7: frexp(-Infinity)
  //   returns 7: [-Infinity, 0]
  //   example 8: frexp(-0)
  //   returns 8: [-0, 0]
  //   example 9: frexp(NaN)
  //   returns 9: [NaN, 0]

  // Potential issue with this implementation:
  // the precisions of Math.pow and the ** operator are undefined in the ECMAScript standard,
  // however, sane implementations should give the same results for Math.pow(2, <integer>) operations

  // Like frexp of C and std::frexp of C++,
  // but returns an array instead of using a pointer argument for passing the exponent result.
  // Object.is(n, frexp(n)[0] * 2 ** frexp(n)[1]) for all number values of n except when Math.isFinite(n) && Math.abs(n) > 2**1023
  // Object.is(n, (2 * frexp(n)[0]) * 2 ** (frexp(n)[1] - 1)) for all number values of n
  // Object.is(n, frexp(n)[0]) for these values of n: 0, -0, NaN, Infinity, -Infinity
  // Math.abs(frexp(n)[0]) is >= 0.5 and < 1.0 for any other number-type value of n
  // See https://en.cppreference.com/w/c/numeric/math/frexp for a more detailed description

  arg = Number(arg)

  const result: [number, number] = [arg, 0]

  if (arg !== 0 && Number.isFinite(arg)) {
    const absArg = Math.abs(arg)
    // Math.log2 was introduced in ES2015, use it when available
    const log2 =
      Math.log2 ||
      function log2(n) {
        return Math.log(n) * Math.LOG2E
      }
    let exp = Math.max(-1023, Math.floor(log2(absArg)) + 1)
    let x = absArg * Math.pow(2, -exp)

    // These while loops compensate for rounding errors that sometimes occur because of ECMAScript's Math.log2's undefined precision
    // and also works around the issue of Math.pow(2, -exp) === Infinity when exp <= -1024
    while (x < 0.5) {
      x *= 2
      exp--
    }
    while (x >= 1) {
      x *= 0.5
      exp++
    }

    if (arg < 0) {
      x = -x
    }
    result[0] = x
    result[1] = exp
  }
  return result
}

export function frexp(arg) {
  //  discuss at: https://locutus.io/c/frexp/
  // original by: Oskar Larsson Högfeldt (https://oskar-lh.name/)
  //      note 1: Instead of
  //      note 1: double frexp( double arg, int* exp );
  //      note 1: this is built as
  //      note 1: [double, int] frexp( double arg );
  //      note 1: due to the lack of pointers in JavaScript.
  //      note 1: See code comments for further information.
  //   example 1: frexp(1)
  //   returns 1: [0.5, 1]
  //   example 2: frexp(1.5)
  //   returns 2: [0.75, 1]
  //   example 3: frexp(3 * Math.pow(2, 500))
  //   returns 3: [0.75, 502]
  //   example 4: frexp(-4)
  //   returns 4: [-0.5, 3]
  //   example 5: frexp(Number.MAX_VALUE)
  //   returns 5: [0.9999999999999999, 1024]
  //   example 6: frexp(Number.MIN_VALUE)
  //   returns 6: [0.5, -1073]
  //   example 7: frexp(-Infinity)
  //   returns 7: [-Infinity, 0]
  //   example 8: frexp(-0)
  //   returns 8: [-0, 0]
  //   example 9: frexp(NaN)
  //   returns 9: [NaN, 0]

  // Potential issue with this implementation:
  // the precisions of Math.pow and the ** operator are undefined in the ECMAScript standard,
  // however, sane implementations should give the same results for Math.pow(2, <integer>) operations

  // Like frexp of C and std::frexp of C++,
  // but returns an array instead of using a pointer argument for passing the exponent result.
  // Object.is(n, frexp(n)[0] * 2 ** frexp(n)[1]) for all number values of n except when Math.isFinite(n) && Math.abs(n) > 2**1023
  // Object.is(n, (2 * frexp(n)[0]) * 2 ** (frexp(n)[1] - 1)) for all number values of n
  // Object.is(n, frexp(n)[0]) for these values of n: 0, -0, NaN, Infinity, -Infinity
  // Math.abs(frexp(n)[0]) is >= 0.5 and < 1.0 for any other number-type value of n
  // See https://en.cppreference.com/w/c/numeric/math/frexp for a more detailed description

  arg = Number(arg)

  const result = [arg, 0]

  if (arg !== 0 && Number.isFinite(arg)) {
    const absArg = Math.abs(arg)
    // Math.log2 was introduced in ES2015, use it when available
    const log2 =
      Math.log2 ||
      function log2(n) {
        return Math.log(n) * Math.LOG2E
      }
    let exp = Math.max(-1023, Math.floor(log2(absArg)) + 1)
    let x = absArg * Math.pow(2, -exp)

    // These while loops compensate for rounding errors that sometimes occur because of ECMAScript's Math.log2's undefined precision
    // and also works around the issue of Math.pow(2, -exp) === Infinity when exp <= -1024
    while (x < 0.5) {
      x *= 2
      exp--
    }
    while (x >= 1) {
      x *= 0.5
      exp++
    }

    if (arg < 0) {
      x = -x
    }
    result[0] = x
    result[1] = exp
  }
  return result
}

Improve this function

Locutus is a community effort following The McDonald's Theory: we ship first iterations, hoping others will improve them. If you see something that could be better, we'd love your contribution.

View on GitHub · Edit on GitHub · View Raw

---

We have 20 C functions so far - help us add more

Got a rainy Sunday afternoon and a taste for a porting puzzle?

• Get inspiration from the C math.h documentation, the C math.h source.
• Click "New file" in the appropriate folder on GitHub. This will fork the project to your account, directly add the file to it, and send a Pull Request to us.

We will then review it. If it's useful to the project and in line with our contributing guidelines your work will become part of Locutus and you'll be automatically credited in the authors section accordingly.

« More C math functions

Star