### Formatter::default

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Creates a default formatter with SI short scaling (K, M, B, T), comma thousands separator, and 3 decimal places precision. This is the recommended starting point for general-purpose number formatting.

```APIDOC
## Formatter::default

### Description
Creates a default formatter with SI short scaling (K, M, B, T), comma thousands separator, and 3 decimal places precision. This is the recommended starting point for general-purpose number formatting.

### Method
Associated function (constructor)

### Endpoint
N/A (Rust struct method)

### Parameters
None

### Request Example
```rust
use numfmt::Formatter;

let mut f = Formatter::default();
```

### Response
#### Success Response (Instance of Formatter)
- **Formatter** - A new Formatter instance with default settings.

#### Response Example
```rust
// Example usage within the code
use numfmt::Formatter;

let mut f = Formatter::default();
assert_eq!(f.fmt2(0.0), "0");
assert_eq!(f.fmt2(12345.6789), "12.345 K");
assert_eq!(f.fmt2(0.00012345), "1.234e-4");
assert_eq!(f.fmt2(123456e22), "1,234.559 Y");
```
```

--------------------------------

### Customize Formatter settings

Source: https://github.com/kurtlawrence/numfmt/blob/main/README.md

Demonstrates creating a currency formatter with specific separators, prefixes, and decimal precision.

```rust
# use numfmt::*;
let mut f = Formatter::new() // start with blank representation
    .separator(',').unwrap()
    .prefix("AU$").unwrap()
    .precision(Precision::Decimals(2));

assert_eq!(f.fmt(0.52), "AU$0.52");
assert_eq!(f.fmt(1234.567), "AU$1,234.56");
assert_eq!(f.fmt(12345678900.0), "AU$12,345,678,900.0");
```

--------------------------------

### Configure currency formatting

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Sets up a formatter for currency with a prefix, comma separator, and 2 decimal places.

```rust
use numfmt::*;

let mut f = Formatter::currency("$").unwrap();
assert_eq!(f.fmt2(12345.6789), "$12,345.67");
assert_eq!(f.fmt2(1234_f64), "$1,234.0");
assert_eq!(f.fmt2(0.52), "$0.52");

// Currency with different symbol
let mut euro = Formatter::currency("\u{20AC}").unwrap();
assert_eq!(euro.fmt2(1234.56), "\u{20AC}1,234.56");
```

--------------------------------

### Initialize a default Formatter

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Creates a formatter with SI short scaling, comma separators, and 3 decimal places.

```rust
use numfmt::*;

let mut f = Formatter::default();
assert_eq!(f.fmt2(0.0), "0");
assert_eq!(f.fmt2(12345.6789), "12.345 K");
assert_eq!(f.fmt2(0.00012345), "1.234e-4");
assert_eq!(f.fmt2(123456e22), "1,234.559 Y");
```

--------------------------------

### Build File Size Formatter

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Construct a file size formatter using binary scaling, significant figures, and a suffix.

```rust
use numfmt::*;

let mut f = Formatter::new()
    .scales(Scales::binary())
    .precision(Precision::Significance(3))
    .suffix("B").unwrap();

assert_eq!(f.fmt2(123_f64), "123 B");
assert_eq!(f.fmt2(1234_f64), "1.20 kiB");
assert_eq!(f.fmt2(1_048_576_f64), "1.0 MiB");
assert_eq!(f.fmt2(123456789876543_f64), "112 TiB");
```

--------------------------------

### Create a file size formatter

Source: https://github.com/kurtlawrence/numfmt/blob/main/README.md

Combines binary scaling, significant figure precision, and a suffix to format file sizes.

```rust
# use numfmt::*;
let mut f = Formatter::new()
                .scales(Scales::binary())
                .precision(Precision::Significance(3))
                .suffix("B").unwrap();

assert_eq!(f.fmt(123_f64), "123 B");
assert_eq!(f.fmt(1234_f64), "1.20 kiB");
assert_eq!(f.fmt(1_048_576_f64), "1.0 MiB");
assert_eq!(f.fmt(123456789876543_f64), "112 TiB");
```

--------------------------------

### Configure percentage formatting

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Multiplies input by 100 and appends a % suffix, with optional precision control.

```rust
use numfmt::*;

let mut f = Formatter::percentage();
assert_eq!(f.fmt2(0.678912), "67.8912%");
assert_eq!(f.fmt2(1.23), "123.0%");
assert_eq!(f.fmt2(0.5), "50.0%");

// Combine with precision
let mut f = Formatter::percentage().precision(Precision::Decimals(2));
assert_eq!(f.fmt2(0.01234), "1.23%");
assert_eq!(f.fmt2(0.999), "99.90%");
```

--------------------------------

### Initialize a new Formatter

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Creates a base formatter with no scaling or default options, suitable for method chaining.

```rust
use numfmt::*;

let mut f = Formatter::new();
assert_eq!(f.fmt2(12345.6789), "12345.6789");
assert_eq!(f.fmt2(0.0), "0");
assert_eq!(f.fmt2(1000000.0), "1000000.0");
```

--------------------------------

### Parse Format Strings

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Demonstrates parsing a format string into a Formatter using the grammar prefix[[.#|~#][%|s|b|n][/<char>]]suffix.

```rust
use numfmt::*;

// Empty string returns default formatter
let mut f: Formatter = "".parse().unwrap();
assert_eq!(f.fmt2(12345.0), "12.345 K");

// Prefix only
let mut f: Formatter = "prefix ".parse().unwrap();
assert_eq!(f.fmt2(1.234), "prefix 1.234");

// Suffix only
let mut f: Formatter = "[] suffix".parse().unwrap();
assert_eq!(f.fmt2(1.234), "1.234 suffix");

// Precision with decimals
let mut f: Formatter = "[.2]".parse().unwrap();
assert_eq!(f.fmt2(1.2345), "1.23");

// Precision with significant figures
let mut f: Formatter = "[~3]".parse().unwrap();
assert_eq!(f.fmt2(1.234), "1.23");
assert_eq!(f.fmt2(10.234), "10.2");

// Percentage scaling
let mut f: Formatter = "[.2%]".parse().unwrap();
assert_eq!(f.fmt2(0.012345), "1.23%");

// No scaling
let mut f: Formatter = "[n]".parse().unwrap();
assert_eq!(f.fmt2(12345.0), "12,345.0");

// Binary scaling
let mut f: Formatter = "[b]".parse().unwrap();
assert_eq!(f.fmt2(3.14 * 1024.0 * 1024.0), "3.14 Mi");

// Custom separator
let mut f: Formatter = "[n/_]".parse().unwrap();
assert_eq!(f.fmt2(12345.0), "12_345.0");

// No separator
let mut f: Formatter = "[n/]".parse().unwrap();
assert_eq!(f.fmt2(12345.0), "12345.0");

// European style with comma decimal marker
let mut f: Formatter = "[,2]".parse().unwrap();
assert_eq!(f.fmt2(1.2345), "1,23");
```

--------------------------------

### Compose complex formats in Rust

Source: https://github.com/kurtlawrence/numfmt/blob/main/README.md

Combine prefix, number format, and suffix. The recommended order is precision, scaling, and separator.

```rust
# use numfmt::*;
let mut f: Formatter;

// Percentages to two decimal places
f = "[.2%]".parse().unwrap();
assert_eq!(f.fmt(0.012345), "1.23%");

// Currency to zero decimal places
// notice the `n` for no scaling
f = "$[.0n] USD".parse().unwrap();
assert_eq!(f.fmt(123_456_789.12345), "$123,456,789 USD");

// Formatting file sizes
f = "[~3b]B".parse().unwrap();
assert_eq!(f.fmt(123_456_789.0), "117 MiB");

// Units to 1 decimal place
f = "[.1n] m/s".parse().unwrap();
assert_eq!(f.fmt(12345.68), "12,345.6 m/s");
```

--------------------------------

### Formatter::new

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Creates a new formatter with no scaling and no default formatting options. This is the base constructor for building custom formatters through method chaining.

```APIDOC
## Formatter::new

### Description
Creates a new formatter with no scaling and no default formatting options. This is the base constructor for building custom formatters through method chaining.

### Method
Associated function (constructor)

### Endpoint
N/A (Rust struct method)

### Parameters
None

### Request Example
```rust
use numfmt::Formatter;

let mut f = Formatter::new();
```

### Response
#### Success Response (Instance of Formatter)
- **Formatter** - A new Formatter instance.

#### Response Example
```rust
// Example usage within the code
let mut f = Formatter::new();
assert_eq!(f.fmt2(12345.6789), "12345.6789");
assert_eq!(f.fmt2(0.0), "0");
assert_eq!(f.fmt2(1000000.0), "1000000.0");
```
```

--------------------------------

### Add prefixes and suffixes

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Appends custom strings before or after the formatted number, limited to 12 bytes each.

```rust
use numfmt::*;

let mut f = Formatter::new()
    .separator(',').unwrap()
    .prefix("AU$").unwrap()
    .precision(Precision::Decimals(2));

assert_eq!(f.fmt2(0.52), "AU$0.52");
assert_eq!(f.fmt2(1234.567), "AU$1,234.56");
assert_eq!(f.fmt2(12345678900.0), "AU$12,345,678,900.0");

// With suffix
let mut f = Formatter::new()
    .suffix(" USD").unwrap()
    .separator(',').unwrap();
assert_eq!(f.fmt2(1234.56), "1,234.56 USD");
```

--------------------------------

### Compose Format Strings

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Combine multiple formatting options in a single format string for complex use cases.

```rust
use numfmt::*;

// Currency to zero decimal places (n = no scaling)
let mut f: Formatter = "$[.0n] USD".parse().unwrap();
assert_eq!(f.fmt2(123_456_789.12345), "$123,456,789 USD");

// File size formatting
let mut f: Formatter = "[~3b]B".parse().unwrap();
assert_eq!(f.fmt2(123_f64), "123 B");
assert_eq!(f.fmt2(1234_f64), "1.20 kiB");
assert_eq!(f.fmt2(123_456_789.0), "117 MiB");

// Units with decimal precision
let mut f: Formatter = "[.1n] m/s".parse().unwrap();
assert_eq!(f.fmt2(12345.68), "12,345.6 m/s");

// European number format with underscore separator
let mut f: Formatter = "[,1n/_]".parse().unwrap();
assert_eq!(f.fmt2(12345.68), "12_345,6");

// Escaped brackets in prefix/suffix
let mut f: Formatter = "[[prefix [] suffix]]".parse().unwrap();
assert_eq!(f.fmt2(1.234), "[prefix 1.234 suffix]");
```

--------------------------------

### Formatter::prefix and Formatter::suffix

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Adds a prefix before the number or suffix after the number. Maximum length is 12 bytes each.

```APIDOC
## Formatter::prefix and Formatter::suffix

### Description
Adds a prefix before the number or suffix after the number. Maximum length is 12 bytes each.

### Method
Instance methods

### Endpoint
N/A (Rust struct methods)

### Parameters
- **prefix** (string) - Required - The string to prepend to the formatted number.
- **suffix** (string) - Required - The string to append to the formatted number.

### Request Example
```rust
use numfmt::Formatter;

let mut f = Formatter::new()
    .separator(',').unwrap()
    .prefix("AU$").unwrap()
    .precision(numfmt::Precision::Decimals(2));
```

### Response
#### Success Response (Instance of Formatter)
- **Formatter** - The Formatter instance with updated prefix/suffix settings.

#### Response Example
```rust
// Example usage within the code
use numfmt::Formatter;

let mut f = Formatter::new()
    .separator(',').unwrap()
    .prefix("AU$").unwrap()
    .precision(numfmt::Precision::Decimals(2));

assert_eq!(f.fmt2(0.52), "AU$0.52");
assert_eq!(f.fmt2(1234.567), "AU$1,234.56");
assert_eq!(f.fmt2(12345678900.0), "AU$12,345,678,900.0");

// With suffix
let mut f = Formatter::new()
    .suffix(" USD").unwrap()
    .separator(',').unwrap();
assert_eq!(f.fmt2(1234.56), "1,234.56 USD");
```
```

--------------------------------

### Format numbers with default settings

Source: https://github.com/kurtlawrence/numfmt/blob/main/README.md

Uses the default Formatter configuration which includes short scaling, comma separators, and 3 decimal places.

```rust
# use numfmt::*;
let mut f = Formatter::default();
assert_eq!(f.fmt(0.0), "0");
assert_eq!(f.fmt(12345.6789), "12.345 K");
assert_eq!(f.fmt(0.00012345), "1.234e-4");
assert_eq!(f.fmt(123456e22), "1,234.559 Y");
```

--------------------------------

### Apply scaling in Rust

Source: https://github.com/kurtlawrence/numfmt/blob/main/README.md

Define scaling behavior using characters like 's' for SI, '%' for percentage, 'm' for metric, 'b' for binary, or 'n' for no scaling.

```rust
# use numfmt::*;
let mut f: Formatter;
f = "".parse().unwrap(); // default si scaling used
assert_eq!(f.fmt(12345.0), "12.345 K");

f = "[n]".parse().unwrap(); // turn off scaling
assert_eq!(f.fmt(12345.0), "12,345.0");

f = "[%.2]".parse().unwrap(); // format as percentages with 2 decimal places
assert_eq!(f.fmt(0.234), "23.40%");

f = "[b]".parse().unwrap(); // use a binary scaler
assert_eq!(f.fmt(3.14 * 1024.0 * 1024.0), "3.14 Mi");
```

--------------------------------

### Configure precision in Rust

Source: https://github.com/kurtlawrence/numfmt/blob/main/README.md

Use '.' for decimal places or '~' for significant figures. The '.*' syntax removes default precision constraints.

```rust
# use numfmt::*;
let mut f: Formatter;
f = "[.2]".parse().unwrap(); // use two decimal places
assert_eq!(f.fmt(1.2345), "1.23");

f = "[.0]".parse().unwrap(); // use zero decimal places
assert_eq!(f.fmt(10.234), "10");

f = "[.*]".parse().unwrap(); // arbitrary precision
assert_eq!(f.fmt(1.234), "1.234");
assert_eq!(f.fmt(12.2), "12.2");

f = "[~3]".parse().unwrap(); // 3 significant figures
assert_eq!(f.fmt(1.234), "1.23");
assert_eq!(f.fmt(10.234), "10.2");
```

--------------------------------

### Create Custom Scales

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Define custom scales with a specified base and unit labels.

```rust
use numfmt::*;

// Custom scale with base 60 (for time-like units)
let custom_scales = Scales::new(60, vec!["s", "m", "h"]).unwrap();
let mut f = Formatter::new()
    .scales(custom_scales)
    .precision(Precision::Decimals(1));

assert_eq!(f.fmt2(30.0), "30.0s");
assert_eq!(f.fmt2(90.0), "1.5m");
assert_eq!(f.fmt2(3600.0), "1.0h");
```

--------------------------------

### Formatter::fmt_string

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Formats a number into an owned String.

```APIDOC
## Formatter::fmt_string

### Description
Formats a number and returns an owned String. Useful when you need to store the result or when the formatter is shared.

### Request Example
```rust
let result: String = f.fmt_string(12345.6789);
```
```

--------------------------------

### Format Numbers to String with Formatter::fmt_string

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Returns an owned String containing the formatted number, suitable for storage or sharing.

```rust
use numfmt::*;

let f = Formatter::default();
let result: String = f.fmt_string(12345.6789);
assert_eq!(result, "12.345 K");

// Useful for collecting formatted values
let numbers = vec![1000.0, 2000.0, 3000.0];
let formatted: Vec<String> = numbers.iter().map(|&n| f.fmt_string(n)).collect();
assert_eq!(formatted, vec!["1.0 K", "2.0 K", "3.0 K"]);
```

--------------------------------

### Set formatting precision

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Configures decimal places, significant figures, or full precision output.

```rust
use numfmt::*;

let mut f = Formatter::new();
assert_eq!(f.fmt2(1234.56789), "1234.56789");

// Fixed decimal places
f = f.precision(Precision::Decimals(2));
assert_eq!(f.fmt2(1234.56789), "1234.56");
assert_eq!(f.fmt2(1234.5), "1234.5");

// Significant figures
f = f.precision(Precision::Significance(5));
assert_eq!(f.fmt2(1234.56789), "1234.5");
assert_eq!(f.fmt2(0.00123456), "0.0012345");

// Unspecified (full precision)
f = f.precision(Precision::Unspecified);
assert_eq!(f.fmt2(1.234), "1.234");
```

--------------------------------

### Configure Formatter Scales

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Sets automatic scaling for large numbers using built-in scale types like short, metric, binary, or none.

```rust
use numfmt::*;

// SI short scale (default)
let mut f = Formatter::default().scales(Scales::short()).precision(Precision::Decimals(1));
assert_eq!(f.fmt2(12.34e0), "12.3");
assert_eq!(f.fmt2(12.34e3), "12.3 K");
assert_eq!(f.fmt2(12.34e6), "12.3 M");
assert_eq!(f.fmt2(12.34e9), "12.3 B");
assert_eq!(f.fmt2(12.34e12), "12.3 T");

// Metric scale
let mut f = Formatter::new().scales(Scales::metric());
assert_eq!(f.fmt2(123456.0), "123.456 k");
assert_eq!(f.fmt2(123456789.0), "123.456789 M");

// Binary scale (for file sizes)
let mut f = Formatter::new().scales(Scales::binary());
assert_eq!(f.fmt2(1024.0 * 1024.0), "1.0 Mi");
assert_eq!(f.fmt2(3.14 * 1024.0 * 1024.0), "3.14 Mi");

// No scaling
let mut f = Formatter::new().scales(Scales::none()).separator(',').unwrap();
assert_eq!(f.fmt2(12345.0), "12,345.0");
```

--------------------------------

### Formatter::fmt_into

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Appends a formatted number to an existing String buffer.

```APIDOC
## Formatter::fmt_into

### Description
Formats a number and appends the result to an existing String buffer. Efficient for building larger strings.

### Request Example
```rust
f.fmt_into(&mut buffer, 12345.6789);
```
```

--------------------------------

### Parse formatter from string

Source: https://github.com/kurtlawrence/numfmt/blob/main/README.md

Uses the parsing grammar to define a Formatter from a string representation, including prefix and suffix handling.

```rust
# use numfmt::*;
let mut f: Formatter;
f = "".parse().unwrap();
assert_eq!(f.fmt(1.234), "1.234");

f = "prefix ".parse().unwrap();
assert_eq!(f.fmt(1.234), "prefix 1.234");

f = "[] suffix".parse().unwrap();
assert_eq!(f.fmt(1.234), "1.234 suffix");

f = "[[prefix [] suffix]]".parse().unwrap();
assert_eq!(f.fmt(1.234), "[prefix 1.234 suffix]");
```

--------------------------------

### Formatter::percentage

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Creates a formatter that multiplies the input by 100 and appends a % suffix. Useful for displaying ratios and proportions as percentages.

```APIDOC
## Formatter::percentage

### Description
Creates a formatter that multiplies the input by 100 and appends a % suffix. Useful for displaying ratios and proportions as percentages.

### Method
Associated function (constructor)

### Endpoint
N/A (Rust struct method)

### Parameters
None

### Request Example
```rust
use numfmt::Formatter;

let mut f = Formatter::percentage();
```

### Response
#### Success Response (Instance of Formatter)
- **Formatter** - A new Formatter instance configured for percentage display.

#### Response Example
```rust
// Example usage within the code
use numfmt::{Formatter, Precision};

let mut f = Formatter::percentage();
assert_eq!(f.fmt2(0.678912), "67.8912%");
assert_eq!(f.fmt2(1.23), "123.0%");
assert_eq!(f.fmt2(0.5), "50.0%");

// Combine with precision
let mut f = Formatter::percentage().precision(Precision::Decimals(2));
assert_eq!(f.fmt2(0.01234), "1.23%");
assert_eq!(f.fmt2(0.999), "99.90%");
```
```

--------------------------------

### Formatter::comma

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Configures the decimal marker character.

```APIDOC
## Formatter::comma

### Description
Sets whether to use a comma as the decimal marker instead of a period (European number format).

### Request Example
```rust
f = f.comma(true);
```
```

--------------------------------

### Append Formatted Numbers with Formatter::fmt_into

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Appends a formatted number directly to an existing String buffer for efficient string building.

```rust
use numfmt::*;

let f = Formatter::default();
let mut buffer = String::from("Value: ");
f.fmt_into(&mut buffer, 12345.6789);
assert_eq!(buffer, "Value: 12.345 K");

// Build a formatted list
let mut output = String::new();
for (i, num) in [1000.0, 2000.0, 3000.0].iter().enumerate() {
    if i > 0 { output.push_str(", "); }
    f.fmt_into(&mut output, *num);
}
assert_eq!(output, "1.0 K, 2.0 K, 3.0 K");
```

--------------------------------

### Formatter::fmt2

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Formats a number into a borrowed string slice.

```APIDOC
## Formatter::fmt2

### Description
Formats any number implementing the Numeric trait. Returns a borrowed string slice from the internal buffer.

### Request Example
```rust
let result = f.fmt2(12345.6789);
```
```

--------------------------------

### Convert Values with Formatter::convert

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Applies a custom transformation function to input numbers before formatting, useful for unit conversions.

```rust
use numfmt::*;

// Convert Celsius to Fahrenheit
let mut f = Formatter::new()
    .convert(|c| c * 9.0 / 5.0 + 32.0)
    .precision(Precision::Decimals(1))
    .suffix("\u{00B0}F").unwrap();

assert_eq!(f.fmt2(0.0), "32.0\u{00B0}F");
assert_eq!(f.fmt2(100.0), "212.0\u{00B0}F");
assert_eq!(f.fmt2(-40.0), "-40.0\u{00B0}F");
```

--------------------------------

### Formatter::convert

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Sets a custom transformation function for input numbers.

```APIDOC
## Formatter::convert

### Description
Sets a custom value converter function that transforms the input number before formatting. Useful for unit conversions or mathematical transformations.

### Request Example
```rust
let mut f = Formatter::new().convert(|c| c * 9.0 / 5.0 + 32.0);
```
```

--------------------------------

### Formatter::currency

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Creates a formatter configured for currency display with a custom prefix symbol, comma separator, and 2 decimal places. Returns a Result that can error if the prefix is too long.

```APIDOC
## Formatter::currency

### Description
Creates a formatter configured for currency display with a custom prefix symbol, comma separator, and 2 decimal places. Returns a Result that can error if the prefix is too long.

### Method
Associated function (constructor)

### Endpoint
N/A (Rust struct method)

### Parameters
- **prefix** (string) - Required - The currency symbol or prefix to display before the number.

### Request Example
```rust
use numfmt::Formatter;

let mut f = Formatter::currency("$").unwrap();
```

### Response
#### Success Response (Instance of Formatter)
- **Formatter** - A new Formatter instance configured for currency.

#### Response Example
```rust
// Example usage within the code
use numfmt::Formatter;

let mut f = Formatter::currency("$").unwrap();
assert_eq!(f.fmt2(12345.6789), "$12,345.67");
assert_eq!(f.fmt2(1234_f64), "$1,234.0");
assert_eq!(f.fmt2(0.52), "$0.52");

// Currency with different symbol
let mut euro = Formatter::currency("\u{20AC}").unwrap();
assert_eq!(euro.fmt2(1234.56), "\u{20AC}1,234.56");
```
```

--------------------------------

### Format Numbers with Formatter::fmt2

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Formats primitive numeric types and returns a borrowed string slice from the internal buffer.

```rust
use numfmt::*;

let mut f = Formatter::default();

// Format different numeric types
assert_eq!(f.fmt2(12345_u32), "12.345 K");
assert_eq!(f.fmt2(12345_i64), "12.345 K");
assert_eq!(f.fmt2(12345.6789_f64), "12.345 K");
assert_eq!(f.fmt2(12345.6789_f32), "12.345 K");

// Special values
assert_eq!(f.fmt2(f64::NAN), "NaN");
assert_eq!(f.fmt2(f64::INFINITY), "\u{221E}");
assert_eq!(f.fmt2(f64::NEG_INFINITY), "-\u{221E}");
```

--------------------------------

### Adjust precision settings

Source: https://github.com/kurtlawrence/numfmt/blob/main/README.md

Configures the Formatter to use either a fixed number of decimal places or a specific number of significant figures.

```rust
# use numfmt::*;
let mut f = Formatter::new();
assert_eq!(f.fmt(1234.56789), "1234.56789");

f = f.precision(Precision::Decimals(2));
assert_eq!(f.fmt(1234.56789), "1234.56");

f = f.precision(Precision::Significance(5));
assert_eq!(f.fmt(1234.56789), "1234.5");
```

--------------------------------

### Formatter::scales

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Configures the automatic scaling behavior for large numbers.

```APIDOC
## Formatter::scales

### Description
Sets automatic scaling for large numbers. Built-in scales include short (K, M, B), metric (k, M, G), binary (ki, Mi, Gi), and none.

### Request Example
```rust
let mut f = Formatter::default().scales(Scales::short());
```
```

--------------------------------

### Formatter::separator

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Sets the thousands separator character. Use None to disable separation. Using '.' as separator automatically switches to comma as the decimal marker (European style).

```APIDOC
## Formatter::separator

### Description
Sets the thousands separator character. Use None to disable separation. Using '.' as separator automatically switches to comma as the decimal marker (European style).

### Method
Instance method

### Endpoint
N/A (Rust struct method)

### Parameters
- **separator** (char or None) - Required - The character to use as a thousands separator, or `None` to disable.

### Request Example
```rust
use numfmt::Formatter;

let mut f = Formatter::new().separator(',').unwrap();
```

### Response
#### Success Response (Instance of Formatter)
- **Formatter** - The Formatter instance with updated separator settings.

#### Response Example
```rust
// Example usage within the code
use numfmt::Formatter;

let mut f = Formatter::new().separator(',').unwrap();
assert_eq!(f.fmt2(12345.67), "12,345.67");

// Space separator
f = f.separator(' ').unwrap();
assert_eq!(f.fmt2(12345.67), "12 345.67");

// No separator
f = f.separator(None).unwrap();
assert_eq!(f.fmt2(12345.67), "12345.67");

// European style (period separator, comma decimal)
f = f.separator('.').unwrap();
assert_eq!(f.fmt2(12345.67), "12.345,67");
```
```

--------------------------------

### Formatter::precision

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Sets the precision for number formatting. Supports decimal places, significant figures, or unspecified precision.

```APIDOC
## Formatter::precision

### Description
Sets the precision for number formatting. Supports decimal places, significant figures, or unspecified precision.

### Method
Instance method

### Endpoint
N/A (Rust struct method)

### Parameters
- **precision** (Precision enum) - Required - The precision setting. Can be `Precision::Decimals(u8)`, `Precision::Significance(u8)`, or `Precision::Unspecified`.

### Request Example
```rust
use numfmt::{Formatter, Precision};

let mut f = Formatter::new();
f = f.precision(Precision::Decimals(2));
```

### Response
#### Success Response (Instance of Formatter)
- **Formatter** - The Formatter instance with updated precision settings.

#### Response Example
```rust
// Example usage within the code
use numfmt::{Formatter, Precision};

let mut f = Formatter::new();
assert_eq!(f.fmt2(1234.56789), "1234.56789");

// Fixed decimal places
f = f.precision(Precision::Decimals(2));
assert_eq!(f.fmt2(1234.56789), "1234.56");
assert_eq!(f.fmt2(1234.5), "1234.5");

// Significant figures
f = f.precision(Precision::Significance(5));
assert_eq!(f.fmt2(1234.56789), "1234.5");
assert_eq!(f.fmt2(0.00123456), "0.0012345");

// Unspecified (full precision)
f = f.precision(Precision::Unspecified);
assert_eq!(f.fmt2(1.234), "1.234");
```
```

--------------------------------

### Set Decimal Marker with Formatter::comma

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Configures the formatter to use a comma as the decimal marker, supporting European number formatting styles.

```rust
use numfmt::*;

let mut f = Formatter::new();
assert_eq!(f.fmt2(12345.67), "12345.67");

// Use comma as decimal marker
f = f.comma(true);
assert_eq!(f.fmt2(12345.67), "12345,67");

// Combine with period separator (European style)
f = f.separator('.').unwrap();
assert_eq!(f.fmt2(12345.67), "12.345,67");
```

--------------------------------

### Customize separators in Rust

Source: https://github.com/kurtlawrence/numfmt/blob/main/README.md

Specify a separator character using a forward slash followed by the desired character. Use ']' to set the separator to None.

```rust
# use numfmt::*;
let mut f: Formatter;
f = "[n]".parse().unwrap(); // turn off scaling to see separator
assert_eq!(f.fmt(12345.0), "12,345.0");

f = "[n/]".parse().unwrap(); // use no separator
assert_eq!(f.fmt(12345.0), "12345.0");

f = "[n/.]".parse().unwrap(); // use a period
assert_eq!(f.fmt(12345.0), "12.345.0");

f = "[n/_]".parse().unwrap(); // use a underscroll
assert_eq!(f.fmt(12345.0), "12_345.0");

f = "[n/ ]".parse().unwrap(); // use a space
assert_eq!(f.fmt(12345.0), "12 345.0");
```

--------------------------------

### Format Primitive Numeric Types

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

The Numeric trait allows formatting for all primitive numeric types.

```rust
use numfmt::*;

let mut f = Formatter::default();

// All primitive types work
assert_eq!(f.fmt2(1000_u8), "1.0 K");
assert_eq!(f.fmt2(1000_u16), "1.0 K");
assert_eq!(f.fmt2(1000_u32), "1.0 K");
assert_eq!(f.fmt2(1000_u64), "1.0 K");
assert_eq!(f.fmt2(1000_i32), "1.0 K");
assert_eq!(f.fmt2(1000_i64), "1.0 K");
assert_eq!(f.fmt2(1000.0_f32), "1.0 K");
assert_eq!(f.fmt2(1000.0_f64), "1.0 K");
assert_eq!(f.fmt2(1000_usize), "1.0 K");
```

--------------------------------

### Set thousands separator

Source: https://context7.com/kurtlawrence/numfmt/llms.txt

Defines the thousands separator character, with support for European-style decimal markers.

```rust
use numfmt::*;

let mut f = Formatter::new().separator(',').unwrap();
assert_eq!(f.fmt2(12345.67), "12,345.67");

// Space separator
f = f.separator(' ').unwrap();
assert_eq!(f.fmt2(12345.67), "12 345.67");

// No separator
f = f.separator(None).unwrap();
assert_eq!(f.fmt2(12345.67), "12345.67");

// European style (period separator, comma decimal)
f = f.separator('.').unwrap();
assert_eq!(f.fmt2(12345.67), "12.345,67");
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.