tessl/npm-thi-ng--math

Assorted common math functions & utilities for TypeScript/JavaScript applications

—

Pending

Overview

Eval results

Files

Integer Mathematics

Name: tessl/npm-thi-ng--math
Author: tessl

Specialized integer operations with overflow handling for 8-bit, 16-bit, and 32-bit signed and unsigned arithmetic.

Capabilities

Sign Extension

Functions for extending the sign of smaller integer types.

/**
 * Sign extends 8-bit value to full integer
 * @param a - 8-bit value to sign extend
 * @returns Sign-extended value
 */
function signExtend8(a: number): number;

/**
 * Sign extends 16-bit value to full integer
 * @param a - 16-bit value to sign extend
 * @returns Sign-extended value
 */
function signExtend16(a: number): number;

8-bit Signed Integer Operations

Arithmetic and bitwise operations with 8-bit signed overflow behavior.

/** 8-bit signed addition with overflow wrapping */
function addi8(a: number, b: number): number;

/** 8-bit signed subtraction with overflow wrapping */
function subi8(a: number, b: number): number;

/** 8-bit signed multiplication with overflow wrapping */
function muli8(a: number, b: number): number;

/** 8-bit signed division */
function divi8(a: number, b: number): number;

/** 8-bit signed bitwise AND */
function andi8(a: number, b: number): number;

/** 8-bit signed bitwise OR */
function ori8(a: number, b: number): number;

/** 8-bit signed bitwise XOR */
function xori8(a: number, b: number): number;

/** 8-bit signed bitwise NOT */
function noti8(a: number): number;

/** 8-bit signed left shift */
function lshifti8(a: number, b: number): number;

/** 8-bit signed right shift (arithmetic) */
function rshifti8(a: number, b: number): number;

16-bit Signed Integer Operations

Arithmetic and bitwise operations with 16-bit signed overflow behavior.

/** 16-bit signed addition with overflow wrapping */
function addi16(a: number, b: number): number;

/** 16-bit signed subtraction with overflow wrapping */
function subi16(a: number, b: number): number;

/** 16-bit signed multiplication with overflow wrapping */
function muli16(a: number, b: number): number;

/** 16-bit signed division */
function divi16(a: number, b: number): number;

/** 16-bit signed bitwise AND */
function andi16(a: number, b: number): number;

/** 16-bit signed bitwise OR */
function ori16(a: number, b: number): number;

/** 16-bit signed bitwise XOR */
function xori16(a: number, b: number): number;

/** 16-bit signed bitwise NOT */
function noti16(a: number): number;

/** 16-bit signed left shift */
function lshifti16(a: number, b: number): number;

/** 16-bit signed right shift (arithmetic) */
function rshifti16(a: number, b: number): number;

32-bit Signed Integer Operations

Arithmetic and bitwise operations with 32-bit signed overflow behavior.

/** 32-bit signed addition with overflow wrapping */
function addi32(a: number, b: number): number;

/** 32-bit signed subtraction with overflow wrapping */
function subi32(a: number, b: number): number;

/** 32-bit signed multiplication with overflow wrapping */
function muli32(a: number, b: number): number;

/** 32-bit signed division */
function divi32(a: number, b: number): number;

/** 32-bit signed bitwise AND */
function andi32(a: number, b: number): number;

/** 32-bit signed bitwise OR */
function ori32(a: number, b: number): number;

/** 32-bit signed bitwise XOR */
function xori32(a: number, b: number): number;

/** 32-bit signed bitwise NOT */
function noti32(a: number): number;

/** 32-bit signed left shift */
function lshifti32(a: number, b: number): number;

/** 32-bit signed right shift (arithmetic) */
function rshifti32(a: number, b: number): number;

8-bit Unsigned Integer Operations

Arithmetic and bitwise operations with 8-bit unsigned overflow behavior.

/** 8-bit unsigned addition with overflow wrapping */
function addu8(a: number, b: number): number;

/** 8-bit unsigned subtraction with underflow wrapping */
function subu8(a: number, b: number): number;

/** 8-bit unsigned multiplication with overflow wrapping */
function mulu8(a: number, b: number): number;

/** 8-bit unsigned division */
function divu8(a: number, b: number): number;

/** 8-bit unsigned bitwise AND */
function andu8(a: number, b: number): number;

/** 8-bit unsigned bitwise OR */
function oru8(a: number, b: number): number;

/** 8-bit unsigned bitwise XOR */
function xoru8(a: number, b: number): number;

/** 8-bit unsigned bitwise NOT */
function notu8(a: number): number;

/** 8-bit unsigned left shift */
function lshiftu8(a: number, b: number): number;

/** 8-bit unsigned right shift (logical) */
function rshiftu8(a: number, b: number): number;

16-bit Unsigned Integer Operations

Arithmetic and bitwise operations with 16-bit unsigned overflow behavior.

/** 16-bit unsigned addition with overflow wrapping */
function addu16(a: number, b: number): number;

/** 16-bit unsigned subtraction with underflow wrapping */
function subu16(a: number, b: number): number;

/** 16-bit unsigned multiplication with overflow wrapping */
function mulu16(a: number, b: number): number;

/** 16-bit unsigned division */
function divu16(a: number, b: number): number;

/** 16-bit unsigned bitwise AND */
function andu16(a: number, b: number): number;

/** 16-bit unsigned bitwise OR */
function oru16(a: number, b: number): number;

/** 16-bit unsigned bitwise XOR */
function xoru16(a: number, b: number): number;

/** 16-bit unsigned bitwise NOT */
function notu16(a: number): number;

/** 16-bit unsigned left shift */
function lshiftu16(a: number, b: number): number;

/** 16-bit unsigned right shift (logical) */
function rshiftu16(a: number, b: number): number;

32-bit Unsigned Integer Operations

Arithmetic and bitwise operations with 32-bit unsigned overflow behavior.

/** 32-bit unsigned addition with overflow wrapping */
function addu32(a: number, b: number): number;

/** 32-bit unsigned subtraction with underflow wrapping */
function subu32(a: number, b: number): number;

/** 32-bit unsigned multiplication with overflow wrapping */
function mulu32(a: number, b: number): number;

/** 32-bit unsigned division */
function divu32(a: number, b: number): number;

/** 32-bit unsigned bitwise AND */
function andu32(a: number, b: number): number;

/** 32-bit unsigned bitwise OR */
function oru32(a: number, b: number): number;

/** 32-bit unsigned bitwise XOR */
function xoru32(a: number, b: number): number;

/** 32-bit unsigned bitwise NOT */
function notu32(a: number): number;

/** 32-bit unsigned left shift */
function lshiftu32(a: number, b: number): number;

/** 32-bit unsigned right shift (logical) */
function rshiftu32(a: number, b: number): number;

Usage Examples:

import { 
  addi8, muli16, signExtend8, 
  addu32, lshiftu16, andi32 
} from "@thi.ng/math/int";

// 8-bit signed arithmetic with overflow
const overflow = addi8(127, 1); // -128 (wraps around)
const signExtended = signExtend8(overflow); // Properly sign-extended

// 16-bit unsigned multiplication
const product = mulu16(300, 300); // Handles 16-bit overflow

// 32-bit operations for larger values
const sum = addu32(0xFFFFFFFF, 1); // 0 (32-bit unsigned overflow)
const shifted = lshiftu16(0x8000, 1); // 0 (shifts out high bit)

// Bitwise operations
const masked = andi32(0x12345678, 0xFF00FF00); // Mask specific bits

Install with Tessl CLI