@petamoriken/float16

What is @petamoriken/float16?

@petamoriken/float16 is an npm package that provides utilities for handling 16-bit floating-point numbers (half-precision). It allows for conversion between 16-bit floats and other numeric types, as well as arithmetic operations on 16-bit floats.

What are @petamoriken/float16's main functionalities?

Conversion from 32-bit float to 16-bit float

This feature allows you to convert a 32-bit floating-point number to a 16-bit floating-point number. The code sample demonstrates converting the 32-bit float value 1.5 to its 16-bit float representation.

const { float32ToFloat16 } = require('@petamoriken/float16');
const float32 = 1.5;
const float16 = float32ToFloat16(float32);
console.log(float16); // Output: 15360

Conversion from 16-bit float to 32-bit float

This feature allows you to convert a 16-bit floating-point number back to a 32-bit floating-point number. The code sample demonstrates converting the 16-bit float value 15360 back to its 32-bit float representation.

const { float16ToFloat32 } = require('@petamoriken/float16');
const float16 = 15360;
const float32 = float16ToFloat32(float16);
console.log(float32); // Output: 1.5

Arithmetic operations on 16-bit floats

This feature provides basic arithmetic operations (addition, subtraction, multiplication, and division) on 16-bit floating-point numbers. The code sample demonstrates these operations using two 16-bit float values representing 1.5.

const { addFloat16, subFloat16, mulFloat16, divFloat16 } = require('@petamoriken/float16');
const a = 15360; // 1.5 in 16-bit float
const b = 15360; // 1.5 in 16-bit float
console.log(addFloat16(a, b)); // Output: 16384 (3.0 in 16-bit float)
console.log(subFloat16(a, b)); // Output: 0 (0.0 in 16-bit float)
console.log(mulFloat16(a, b)); // Output: 15872 (2.25 in 16-bit float)
console.log(divFloat16(a, b)); // Output: 15360 (1.0 in 16-bit float)

Other packages similar to @petamoriken/float16

float16

The 'float16' package provides similar functionality for handling 16-bit floating-point numbers. It includes methods for converting between 16-bit and 32-bit floats, as well as arithmetic operations. However, it may have a different API and performance characteristics compared to @petamoriken/float16.

README

float16

half precision floating point for JavaScript

Supports (at least)

Last 2 versions of modern browser (Chrome, Firefox) and latest version of default browser on Windows 10 or macOS (Edge, Safari) and Node latest.

• Chrome: Last 2 versions
• Firefox: Last 2 versions and ESR
• Edge: Latest version
• Safari: Latest version
• Node.js: Latest version

This library's Float16Array uses Proxy, so IE11 is never supported.

Install

yarn add @petamoriken/float16

or

npm install @petamoriken/float16 --save

Require

// ES6 Modules
import { Float16Array, getFloat16, setFloat16, hfround } from "@petamoriken/float16";

or

// CommonJS
const { Float16Array, getFloat16, setFloat16, hfround } = require("@petamoriken/float16");

API

• Float16Array

  This API is similar to TypedArray such as Float32Array.

  let float16 = new Float16Array([1.0, 1.1, 1.2]);
  for(const val of float16) {
      console.log(val); // => 1, 1.099609375, 1.19921875
  }
  
  float16.reduce((prev, current) => prev + current); // 3.298828125
  

• getFloat16(view: DataView, byteOffset: number [, littleEndian: boolean])

• setFloat16(view: DataView, byteOffset: number, value: number [, littleEndian: boolean])

  These APIs are similar to DataView methods such as DataView#getFloat32 and DataView#setFloat32.

  let buffer = new ArrayBuffer(10);
  let view = new DataView(buffer);
  
  view.setUint16(0, 0x1234);
  getFloat16(view, 0); // 0.0007572174072265625
  
  // You can append to DataView instance
  view.getFloat16 = getFloat16.bind(null, view);
  view.setFloat16 = setFloat16.bind(null, view);
  
  view.getFloat16(0); // 0.0007572174072265625
  
  view.setFloat16(0, Math.PI, true);
  view.getFloat16(0, true); // 3.140625
  

• hfround(x: number)

  This API is similar to Math.fround (MDN).
  This function returns nearest half precision float representation of a number.

  Math.fround(1.337); // 1.3370000123977661
  hfround(1.337); // 1.3369140625