or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

index.md
tile.json

tessl/npm-ieee754

Read/write IEEE754 floating point numbers from/to a Buffer or array-like object

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/ieee754@1.2.x

To install, run

npx @tessl/cli install tessl/npm-ieee754@1.2.0

index.mddocs/

IEEE754

IEEE754 is a lightweight JavaScript library for reading and writing IEEE754 floating point numbers from/to Buffer objects or array-like structures. It implements the IEEE Standard for Floating-Point Arithmetic (IEEE 754) with precise control over floating-point number encoding and decoding, supporting different endianness, mantissa lengths, and byte counts.

Package Information

  • Package Name: ieee754
  • Package Type: npm
  • Language: JavaScript
  • Installation: npm install ieee754

Core Imports

const ieee754 = require('ieee754');

For ES modules:

import * as ieee754 from 'ieee754';

Basic Usage

const ieee754 = require('ieee754');

// Create a buffer to work with
const buffer = Buffer.alloc(4);

// Write a 32-bit float (single precision)
const value = 42.42;
ieee754.write(buffer, value, 0, true, 23, 4);

// Read the 32-bit float back
const readValue = ieee754.read(buffer, 0, true, 23, 4);
console.log(readValue); // 42.42000007629395

// Working with 64-bit doubles
const doubleBuffer = Buffer.alloc(8);
const doubleValue = 12345.123456789;

// Write a 64-bit double (double precision)
ieee754.write(doubleBuffer, doubleValue, 0, true, 52, 8);

// Read the 64-bit double back
const readDouble = ieee754.read(doubleBuffer, 0, true, 52, 8);
console.log(readDouble); // 12345.123456789

Architecture

IEEE754 implements low-level binary operations for floating-point number encoding and decoding:

  • Binary Representation: Converts floating-point numbers to/from their binary IEEE754 representation
  • Configurable Precision: Supports different mantissa lengths and byte counts for various precision levels
  • Endianness Control: Handles both little-endian and big-endian byte ordering
  • Standards Compliance: Follows IEEE 754 specification including special value handling (Infinity, NaN, denormalized numbers)

Capabilities

Reading IEEE754 Numbers

Reads an IEEE754 floating point number from a buffer or array-like object.

/**
 * Reads an IEEE754 floating point number from a buffer
 * @param {Buffer|Uint8Array|Array} buffer - Buffer or array-like object containing the data
 * @param {number} offset - Offset into the buffer to start reading
 * @param {boolean} isLE - Whether to use little-endian byte order
 * @param {number} mLen - Mantissa length in bits
 * @param {number} nBytes - Number of bytes to read
 * @returns {number} The parsed floating point value
 */
function read(buffer, offset, isLE, mLen, nBytes);

Usage Examples:

const ieee754 = require('ieee754');

// Read a 32-bit float (single precision)
const buffer32 = Buffer.from([0x42, 0x28, 0xF5, 0xC3]); // Little-endian representation
const float32 = ieee754.read(buffer32, 0, true, 23, 4);

// Read a 64-bit double (double precision)
const buffer64 = Buffer.alloc(8);
buffer64.writeDoubleLE(3.141592653589793, 0);
const float64 = ieee754.read(buffer64, 0, true, 52, 8);

// Read big-endian format
const bigEndianBuffer = Buffer.from([0xC3, 0xF5, 0x28, 0x42]);
const bigEndianFloat = ieee754.read(bigEndianBuffer, 0, false, 23, 4);

Writing IEEE754 Numbers

Writes an IEEE754 floating point number to a buffer or array-like object.

/**
 * Writes an IEEE754 floating point number to a buffer
 * @param {Buffer|Uint8Array|Array} buffer - Buffer or array-like object to write to
 * @param {number} value - The floating point value to write
 * @param {number} offset - Offset into the buffer to start writing
 * @param {boolean} isLE - Whether to use little-endian byte order
 * @param {number} mLen - Mantissa length in bits
 * @param {number} nBytes - Number of bytes to write
 * @returns {void} Modifies the buffer in-place
 */
function write(buffer, value, offset, isLE, mLen, nBytes);

Usage Examples:

const ieee754 = require('ieee754');

// Write a 32-bit float (single precision)
const buffer32 = Buffer.alloc(4);
ieee754.write(buffer32, 42.42, 0, true, 23, 4);

// Write a 64-bit double (double precision)  
const buffer64 = Buffer.alloc(8);
ieee754.write(buffer64, 3.141592653589793, 0, true, 52, 8);

// Write in big-endian format
const bigEndianBuffer = Buffer.alloc(4);
ieee754.write(bigEndianBuffer, 123.456, 0, false, 23, 4);

// Write special values
const specialBuffer = Buffer.alloc(4);
ieee754.write(specialBuffer, Infinity, 0, true, 23, 4);
ieee754.write(specialBuffer, -Infinity, 0, true, 23, 4);
ieee754.write(specialBuffer, NaN, 0, true, 23, 4);

Common Patterns

Standard IEEE754 Formats

const ieee754 = require('ieee754');

// 32-bit single precision float (IEEE 754 binary32)
// mLen: 23 (mantissa bits), nBytes: 4 (total bytes)
const buffer32 = Buffer.alloc(4);
ieee754.write(buffer32, 1.5, 0, true, 23, 4);
const value32 = ieee754.read(buffer32, 0, true, 23, 4);

// 64-bit double precision float (IEEE 754 binary64)  
// mLen: 52 (mantissa bits), nBytes: 8 (total bytes)
const buffer64 = Buffer.alloc(8);
ieee754.write(buffer64, 1.5, 0, true, 52, 8);
const value64 = ieee754.read(buffer64, 0, true, 52, 8);

Endianness Handling

const ieee754 = require('ieee754');
const buffer = Buffer.alloc(4);
const value = 42.0;

// Little-endian (most common on x86/x64)
ieee754.write(buffer, value, 0, true, 23, 4);
const littleEndian = ieee754.read(buffer, 0, true, 23, 4);

// Big-endian (network byte order)
ieee754.write(buffer, value, 0, false, 23, 4);
const bigEndian = ieee754.read(buffer, 0, false, 23, 4);

Working with Typed Arrays

const ieee754 = require('ieee754');

// Works with Uint8Array and other typed arrays
const uint8Array = new Uint8Array(4);
ieee754.write(uint8Array, 3.14159, 0, true, 23, 4);
const result = ieee754.read(uint8Array, 0, true, 23, 4);

Error Handling

The library handles IEEE754 special values correctly:

  • Infinity: Positive and negative infinity values are preserved
  • NaN: Not-a-Number values are handled appropriately
  • Zero: Both positive and negative zero are supported
  • Denormalized numbers: Subnormal values are handled according to IEEE754 specification
const ieee754 = require('ieee754');
const buffer = Buffer.alloc(4);

// Special values
ieee754.write(buffer, Infinity, 0, true, 23, 4);
console.log(ieee754.read(buffer, 0, true, 23, 4)); // Infinity

ieee754.write(buffer, -Infinity, 0, true, 23, 4);
console.log(ieee754.read(buffer, 0, true, 23, 4)); // -Infinity

ieee754.write(buffer, NaN, 0, true, 23, 4);
console.log(ieee754.read(buffer, 0, true, 23, 4)); // NaN