Dependency-free normalization for real AI/ML data prep

Map messy data into deterministic [-1, 1] features.

libRangeMap is a small, dependency-free SDK for turning ordinary numbers, text, bytes, nested data, records, and image-like values into bounded floating-point representations. It is built for pipelines that need explainable normalization without mystery imports, silent coercion, or magic fallback values.

Paste the quickstart Explore features Read the docs

0 depsCore runtime uses Python standard library only.

25 wrappersInstall from GitHub and use the same contract everywhere.

[-1, 1]Bounded output is the default contract.

python quickstart

# install from this repository
python -m pip install .

# map known numeric ranges into [-1.0, 1.0]
from librangemap import IntegerRangeMapper

mapper = IntegerRangeMapper(input_range=(0, 100))
score = mapper.map_value(75)

# 0 -> -1.0, 50 -> 0.0, 100 -> 1.0
print(score)        # 0.5
print(mapper.to_spec())

Normalization that behaves like infrastructure, not a notebook trick.

Designed for AI dataset preparation, feature collection, model training inputs, and reproducible preprocessing where every value needs an audit trail.

Dependency-free core

No NumPy, pandas, Pillow, pydantic, CLI frameworks, or runtime imports outside the standard library. The SDK stays small, inspectable, and easy to embed.

Deterministic by contract

The same input plus the same config produces the same output. Fitted ranges, vocabularies, alphabets, policies, and metadata are captured in specs.

Explicit failures

Invalid ranges, NaN/Inf, unknown tokens, empty data, unsupported types, and missing metadata fail loudly with typed errors instead of hidden fallbacks.

Canonical formula

Simple math, strict policy.

The default output range is always [-1.0, 1.0] unless explicitly changed. Mapping remains bounded by design, and clipping behavior is documented instead of implied.

out_min + ((value - in_min) / (in_max - in_min)) * (out_max - out_min)

1Declare or fit policy.Choose ranges, vocabularies, alphabets, sequence policy, record policy, and edge-case behavior.

2Map values safely.Numbers, booleans, strings, bytes, maps, structs, nested sequences, and image-like arrays keep shape and policy.

3Serialize the spec.Persist JSON-compatible mapper specs so training and inference use the same fitted metadata.

Built for the places preprocessing usually breaks.

libRangeMap is intentionally boring where it should be boring: stable, bounded, transparent, and easy to reason about in CI.

Feature normalization

Convert ordinary numeric and categorical fields into consistent floating-point feature values without pulling a data-science stack into production code.

Dataset collection

Capture raw values with explicit mapper metadata so future retraining runs can reproduce the same preprocessing decisions.

Cross-language SDKs

Use documented policies for Python, C, Java, C++, C#, JavaScript, SQL, Rust, Go, Ruby, PHP, MATLAB, COBOL, and more.

One mapper contract. 25 language surfaces.

Use the same normalization model across the required language set, with documented policies for values, strings, bytes, sequences, maps, records, custom objects, and image-like data.

Python 01C 02Java 03C++ 04C# 05JavaScript 06Visual Basic 07R 08SQL 09Delphi/Object Pascal 10Fortran 11Scratch 12Perl 13PHP 14Rust 15Go 16Assembly 17Swift 18Ada 19MATLAB 20Classic VB 21PL/SQL 22Ruby 23Prolog 24COBOL 25

Useinstall, map, serialize

Download from GitHub and normalize data in three steps.

Clone the repository, install the Python package, then create mappers with explicit ranges or fitted metadata. Every mapper follows the same contract: validate input, map with a documented policy, keep output bounded, and expose a JSON-serializable spec.

Numbers map through the canonical linear formula into the configured output range.
Strings, bytes, tokens, sequences, maps, records, and image-like values use explicit policies instead of silent coercion.
Nested inputs preserve shape so downstream pipelines can reason about structure.
Specs capture fitted ranges, vocabularies, alphabets, policies, and metadata for reproducible training and inference.

Install from GitHub and ship the first mapper in minutes.

Start with paste-ready examples, then move into the mapper contract, type policies, serialization, and language-specific usage guides.

QuickstartThe fastest path from install to mapped values.open Mapping contractCanonical formula, range behavior, determinism, and typed failures.open Wrapper contractHow language surfaces expose the same mapper behavior.open

Compatibility matrixSupported data families and wrapper policies.open SerializationReproducible JSON specs for fitted mappers.open Language supportExamples and policies for supported language wrappers.open

Normalize data without importing a universe.

Use libRangeMap when your AI pipeline needs portable preprocessing, reproducible mapper specs, and bounded values that stay explainable from local experiments to production jobs.

Start with the quickstart Read the no-dependency policy