# float-clamp

Floating-point Epsilon-aware Interval Clamping

## Usage no npm install needed!

``````<script type="module">
import floatClamp from 'https://cdn.skypack.dev/float-clamp';
</script>``````

# FLOAT CLAMP

Clamp numbers to ranges taking into account the epsilon of the numbers at the end of the ranges. A range is string in Interval Notation such as "[2..4)" which means "between 2 (inclusive) and 4 (exclusive)." ## Install

``````npm install float-clamp
``````

..then `require` float-clamp:

``````var floatClamp = require('float-clamp');
``````

## Basic Usage

``````var randomClamper = floatClamp.makeDoubleClamper('[0..1)');

//- Now randomClamper is a function that will clamp numbers to between 0 (inclusive)
//- and 1 (exclusive)
//- This is exactly the same range as values returned from Math.random()

randomClamper(-0.01) //=> 0
randomClamper(0)     //=> 0
randomClamper(0.01)  //=> 0.01
randomClamper(1)     //=> 0.9999999999999999
``````

See below for clamp generators for other precision floating point numbers (and even an integer)

## API

`floatClamp.makeDoubleClamper(rangeString)`

Shown above, generates clampers that calculates epsilons for double-precision floating point numbers. Every `Number` in JavaScript is a double as well as `Float64Array` typed arrays.

`floatClamp.makeSingleClamper(rangeString)`

Generates clampers that calculates epsilons for single-precision floating point numbers. In other words, `Float32Array` typed arrays.

`floatClamp.makeHalfClamper(rangeString)`

Generates clampers that calculates epsilons for half-precision floating point numbers. I'm not sure half-floats (16 bit storage) are even available in JavaScript but they are heavily used in GPUs so I included it for possible future proofing in case WebGL or WebCL add support (ie. `Float16Array`).

`floatClamp.makeIntegerClamper(rangeString)`

Integer clamping is easy, right?

Not so fast! All `Numbers` in JavaScript are doubles. After +-2^53, the episilon for doubles is greater than one. The calculations for determining a number nearest-to-endpoint must take that into account for very large ranges.

Integers greater than 2^53 can not be represented exactly. This library takes that into account when used with very large exclsuive end-points and will clamp to the nearest valid integer to that exclusive end-point.

## Versions

• v1.0.0 Initial functionality