# microns
**microns** is a simple, dependency-free Rust library that enables working with floating-point values as fixed-precision integers. Its primary purpose is to help avoid the pitfalls of floating-point arithmetic in contexts where a fixed, micrometer-level precision is sufficient.
## Overview
**microns** gets its name from the idea of converting millimeter-formatted floating-point values (`f32`) into integer-based micrometer values (`i32`). Instead of dealing with floating-point numbers directly and risking errors due to floating-point precision, you convert your `f32` values into `Microns` (stored internally as `i32`), and then use standard arithmetic operations on these integers.
By scaling values such that `1_000 microns = 1 millimeter`, `microns` makes it convenient to represent geometric coordinates, distances, and other measurements at a micron-level resolution. Although the primary use case might be for CNC machines, 3D printers, or robotics—where consistent, small increments matter—this library can be useful whenever controlled precision is required and `i32::MIN < float < i32::MAX`.
**Key points:**
- Represent floating-point values as integers at a micron-level scale.
- No dependencies required (optional integration with `serde` for serialization).
- Simple, straightforward API for conversion, arithmetic, and comparisons.
- Safer integer arithmetic helps avoid subtle floating-point rounding errors.
## Features
- **Fixed-precision representation**: Values are stored as `i32` integers, allowing you to consistently reason about increments of 1 micron.
- **Arithmetic operations**: Add, subtract, multiply, and divide by `f32` values, returning `Microns`.
- **Conversions**:
- Convert from `f32` to `Microns` using `Microns::from(f32)`.
- Convert back to `f32` using `f32::from(microns)`.
- **Abs operation**: Compute the absolute value of a `Microns` instance.
- **Range checks**: The `works()` function ensures that the `f32` value can fit in an `i32` after scaling to microns.
## When to Use
Use **microns** when:
- You need stable, predictable fixed-point arithmetic without the overhead of arbitrary precision libraries.
- You are working with machine coordinates (e.g., CNC, 3D printers) where a micron-level resolution is sufficiently precise and where raw floating-point arithmetic might introduce unacceptable rounding errors.
- You need an easy-to-understand scale factor (e.g., 1/1000 for mm-to-microns) to standardize calculations.