halton

Generate n points of the Halton sequence in n-dimensions.

Installation

npm install halton

Usage

import halton from "halton";

const points = halton(pointsCount);
// =>
// 0: [0, 0]
// 1: [0.5, 0.3333333333333333]
// 2: [0.25, 0.6666666666666666]
// 3: [0.75, 0.1111111111111111]

Scrambling

Higher bases show regular patterns. Scramble each base with a digit permutation to break them.

With Faure permutations (deterministic):

import halton, { createFaurePermutations } from "halton";

const bases = [11, 13];
const points = halton(pointsCount, bases, createFaurePermutations(bases));

With random permutations (Math.random by default). Pass a seeded random function, e.g. from pex-random, for reproducible results:

import halton, { createPermutations } from "halton";
import random from "pex-random";

const bases = [11, 13];
const points = halton(pointsCount, bases, createPermutations(bases));

const prng = random.create(1);
const seededPoints = halton(
  pointsCount,
  bases,
  createPermutations(bases, () => prng.float()),
);

API

halton

• halton
  • .haltonSequence(index, base, [permutation]) ⇒ number
  • .createPermutations([bases], [random]) ⇒ Array.<Array.<number>>
  • .createFaurePermutations([bases]) ⇒ Array.<Array.<number>>
  • .default(count, [bases], [permutations]) ⇒ Array.<Array.<number>>

halton.haltonSequence(index, base, [permutation]) ⇒ number

The Halton sequence algorithm (radical inverse), optionally scrambled with a digit permutation.

Kind: static method of halton See

• Wikipedia Halton_sequence
• PBR Book The Halton Sampler

| Param | Type | Description | | ------------- | --------------------------------- | ---------------------------------------------------------------- | | index | number | Index in the sequence. | | base | number | An integer, preferably prime number. | | [permutation] | Array.<number> | A permutation of the digits [0, base - 1] applied to each digit. |

halton.createPermutations([bases], [random]) ⇒ Array.<Array.<number>>

Create a random digit permutation for each base, to scramble the Halton sequence.

Kind: static method of halton

| Param | Type | Default | Description | | -------- | --------------------------------- | ------------------------ | ----------------------------------------------------- | | [bases] | Array.<number> | [2, 3] | The bases to create a permutation for. | | [random] | function | Math.random | A random number generator returning values in [0, 1). |

halton.createFaurePermutations([bases]) ⇒ Array.<Array.<number>>

Create a deterministic Faure digit permutation for each base, to scramble the Halton sequence.

Kind: static method of halton See: Faure, "Good permutations for extreme discrepancy", Journal of Number Theory, 1992.

| Param | Type | Default | Description | | ------- | --------------------------------- | ------------------- | -------------------------------------- | | [bases] | Array.<number> | [2, 3] | The bases to create a permutation for. |

halton.default(count, [bases], [permutations]) ⇒ Array.<Array.<number>>

Generate n points of the Halton sequence in n-dimensions. The "bases" parameter defines how many dimensions. Pass "permutations" to scramble the sequence and break the regular patterns of higher bases.

Kind: static method of halton

| Param | Type | Default | Description | | -------------- | ----------------------------------------------- | ------------------- | ------------------------------------------------------------------------------------ | | count | number | | Number of points in the sequence to generate. | | [bases] | Array.<number> | [2, 3] | The bases for the Van der Corput operation. Best results with small coprime numbers. | | [permutations] | Array.<Array.<number>> | | A digit permutation per base. See createPermutations and createFaurePermutations. |

License

MIT. See license file.