miyaokamarina

Random 32-bit magic number generator

A magic number for a binary file format should satisfy the following requirements:

• invalid in UTF-8,

  Must contain either invalid bytes or invalid sequences.

• is not ascending,
• has no equal bytes,
• has no bytes that are common in binary data, > 00, 01, 80, FF

miyaokamarina

// The worker binary.

// Compile as
// gcc -Wall -O3 -o ./OUT_DIR/tu01 ./tu01.c
//     -Iinclude -Llib -ltestu01 -lprobdist -lmylib -lm

#include <TestU01.h>

// Should provide:
// • void reset();   -- Init/reset the state.

miyaokamarina

/**
 * Modular multiplicative inverse (mod 2^w).
 *
 * Find x, s.t.
 *
 *     ax ≡ 1 (mod 2^w)
 *
 * Based on Hurchalla, J. (2022). “An Improved Integer Modular Multiplicative
 * Inverse (modulo 2^w)”. https://arxiv.org/abs/2204.04342
 *

miyaokamarina

// @ts-check
// SPDX-License-Identifier: CC0-1.0

/**
 * 4-bit hash.
 *
 * Single LCG step + xorshift.
 *
 * @param {number} x
 */

miyaokamarina

Desktop Entry Parsers

KConfig

• Only recognizes \n newlines.
• Accepts [ \t\n\r] as whitespace:
  • At the start of line.
  • At the end of line.
  • Before =.
• After =.

miyaokamarina

const segmenter = new Intl.Segmenter('en-us', {
    granularity: 'grapheme',
});

const length = x => {
    x = x.normalize('NFC');

    const graphemes = segmenter.segment(x);

    return Array.from(graphemes).length;

miyaokamarina

{
    const MASK = 0;
    const COPY = 1;

    const ADD  = 0;
    const SUB  = 1;
    const SET  = 2;

    const Symbolic = (s, o, v) => {
        s ??= { class: 0o7, umasked: true };

miyaokamarina

Yet Another Mersenne Twister

• Hella fast.
• Compact af.
• Built with typed arrays.
• Provides an API to save/restore the state.
• Written in TypeScript.

import { MersenneTwister } from './mersenne-twister.ts';

miyaokamarina

Largest number less than one

IEEE 754 binary64

0 01111111110 1111111111111111111111111111111111111111111111111111 === 1 - 2**(-53)

miyaokamarina

declare type Refine<from, to> = from extends to ? from : never;
declare type ArraySize<t> = Refine<GetProperty<t, 'length'>, number>;
declare type GetProperty<t, k> = t[Refine<k, keyof t>];
declare type ArrayType<t> = t extends ReadonlyArray<infer u> ? u : never;
declare type ArrayHead<a> = a extends readonly [infer h] ? h : never;
declare type Rebuild<t> = { [k in keyof t]: t[k] };
declare type KeyofReq<o, k extends keyof o = keyof o> = k extends any ? (undefined extends o[k] ? never : k) : never;

// Binary spread
declare type ObjectSpread<