### `ComparableQuantity<Q>` Arithmetic Operations

Source: https://context7.com/unitsofmeasurement/indriya/llms.txt

Demonstrates how to perform addition, subtraction, multiplication, and division on quantities. It also shows how to compare quantities and perform cross-type arithmetic, with automatic unit conversion and type safety.

```APIDOC
## `ComparableQuantity<Q>` Arithmetic

Performs typed arithmetic on quantities, returning `ComparableQuantity` and handling automatic unit conversions.

### Methods

- **add(ComparableQuantity<Q> quantity)**: Adds another quantity to this quantity, performing unit conversion if necessary.
- **multiply(double scalar)**: Multiplies the quantity by a scalar value.
- **divide(double scalar)**: Divides the quantity by a scalar value.
- **divide(ComparableQuantity<Q> quantity, Class<Q> quantityType)**: Divides this quantity by another quantity, returning a new quantity of the specified type.
- **isLessThan(ComparableQuantity<Q> quantity)**: Checks if this quantity is less than another quantity.
- **isGreaterThanOrEqualTo(ComparableQuantity<Q> quantity)**: Checks if this quantity is greater than or equal to another quantity.

### Example
```java
import tech.units.indriya.quantity.Quantities;
import tech.units.indriya.unit.Units;
import tech.units.indriya.ComparableQuantity;
import static javax.measure.MetricPrefix.KILO;
import javax.measure.quantity.*;

ComparableQuantity<Length> a = Quantities.getQuantity(3.0, Units.METRE);
ComparableQuantity<Length> b = Quantities.getQuantity(200.0, KILO(Units.METRE));

// Addition auto-converts b to metres before summing
ComparableQuantity<Length> sum = a.add(b);
System.out.println(sum); // "200003.0 m"

// Scalar multiplication / division
ComparableQuantity<Length> doubled  = a.multiply(2);    // 6.0 m
ComparableQuantity<Length> halved   = a.divide(2);      // 1.5 m

// Comparison (auto-converts units)
System.out.println(a.isLessThan(b));             // true
System.out.println(a.isGreaterThanOrEqualTo(a)); // true

// Cross-type: Length / Time → Speed
ComparableQuantity<Time>  t     = Quantities.getQuantity(2.0, Units.SECOND);
ComparableQuantity<Speed> speed = a.divide(t, Speed.class);
System.out.println(speed); // "1.5 m/s"
```
```

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

### Create and Format Quantity Ranges

Source: https://context7.com/unitsofmeasurement/indriya/llms.txt

Demonstrates creating a QuantityRange for mass with minimum, maximum, and resolution, and also shows open-ended ranges. Use this to define and format intervals for quantity values.

```java
import tech.units.indriya.quantity.Quantities;
import tech.units.indriya.quantity.QuantityRange;
import tech.units.indriya.format.SimpleQuantityFormat;
import tech.units.indriya.unit.Units;
import javax.measure.Quantity;
import javax.measure.quantity.Mass;

Quantity<Mass> oneKg   = Quantities.getQuantity(1d,  Units.KILOGRAM);
Quantity<Mass> tenKg   = Quantities.getQuantity(10d, Units.KILOGRAM);
Quantity<Mass> twoKg   = Quantities.getQuantity(2d,  Units.KILOGRAM);

// Closed range with resolution
@SuppressWarnings("unchecked")
QuantityRange<Mass> range = QuantityRange.of(oneKg, tenKg, twoKg);
System.out.println(range.getMinimum());  // "1 kg"
System.out.println(range.getMaximum());  // "10 kg"
System.out.println(range.getResolution()); // "2 kg"

// Open-ended ranges (null boundary)
@SuppressWarnings("unchecked")
QuantityRange<Mass> atLeastOne = QuantityRange.of(oneKg, null);
System.out.println(atLeastOne.hasMaximum()); // false

// Format a range with compact pattern
SimpleQuantityFormat compactFmt = SimpleQuantityFormat.getInstance("rc");
System.out.println(compactFmt.formatRange(range));
// "min=1 kg, max=10 kg"
```

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

### DefaultQuantityFactory Usage

Source: https://context7.com/unitsofmeasurement/indriya/llms.txt

Demonstrates how to obtain a QuantityFactory for a specific quantity type and use it to create quantities with units.

```APIDOC
## `DefaultQuantityFactory<Q>` — SPI factory for typed quantities

`DefaultQuantityFactory<Q>` implements the JSR 385 `QuantityFactory<Q>` SPI, enabling framework-friendly quantity creation without static imports. Factories are cached per quantity type and discovered via the standard `ServiceLoader` mechanism.

```java
import tech.units.indriya.quantity.DefaultQuantityFactory;
import javax.measure.Quantity;
import javax.measure.quantity.Length;
import javax.measure.spi.QuantityFactory;
import tech.units.indriya.unit.Units;

// Obtain a factory for a specific quantity type
QuantityFactory<Length> factory = DefaultQuantityFactory.getInstance(Length.class);

// Create quantities
Quantity<Length> l1 = factory.create(5.0, Units.METRE);
Quantity<Length> l2 = factory.create(200, Units.KILOMETRE_PER_HOUR.asType(Length.class));

System.out.println(l1);               // "5.0 m"
System.out.println(factory.getSystemUnit()); // "m"
```
```

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

### TimeQuantities for java.time Integration

Source: https://context7.com/unitsofmeasurement/indriya/llms.txt

Illustrates how to use TimeQuantities to bridge JSR 385 Time quantities with Java's java.time API, including duration calculations and sub-second unit handling.

```APIDOC
## `TimeQuantities` — Bridge between JSR 385 and `java.time`

`TimeQuantities` bridges `javax.measure.quantity.Time` with `java.time.temporal.Temporal`, `LocalTime`, `TimeUnit`, and `TemporalUnit`. It provides factory methods that compute durations between two time points and convenience constants for sub-second units (MILLISECOND, MICROSECOND, NANOSECOND) not present in `Units`.

```java
import tech.units.indriya.quantity.time.TimeQuantities;
import tech.units.indriya.unit.Units;
import javax.measure.Quantity;
import javax.measure.quantity.Time;
import java.time.LocalDate;
import java.time.LocalTime;
import java.util.concurrent.TimeUnit;

// Duration between two Temporals (result in DAYS)
Quantity<Time> period = TimeQuantities.getQuantity(
    LocalDate.of(2024, 1, 1),
    LocalDate.of(2024, 12, 31)
);
System.out.println(period.getValue() + " days"); // "365 days"

// Duration between two LocalTimes (result in HOURS)
Quantity<Time> hours = TimeQuantities.getQuantity(
    LocalTime.of(8, 0),
    LocalTime.of(17, 30)
);
System.out.println(hours.getValue() + " h"); // "9 h"

// java.util.concurrent.TimeUnit interop
var tuq = TimeQuantities.getQuantity(500L, TimeUnit.MILLISECONDS);
System.out.println(tuq);

// Sub-second units
var ms  = TimeQuantities.MILLISECOND;
var ns  = TimeQuantities.NANOSECOND;
Quantity<Time> latency = tech.units.indriya.quantity.Quantities.getQuantity(250, ms);
Quantity<Time> inNs    = latency.to(ns);
System.out.println(inNs.getValue()); // 2.5E+8
```
```

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

### Create and Extract Mixed Radix Time Quantities

Source: https://context7.com/unitsofmeasurement/indriya/llms.txt

Demonstrates creating a MixedRadix unit for time (hours, minutes, seconds) and then creating and extracting quantities from it. Use this to represent and work with compound time values.

```java
import tech.units.indriya.function.MixedRadix;
import tech.units.indriya.quantity.MixedQuantity;
import tech.units.indriya.quantity.Quantities;
import tech.units.indriya.unit.Units;
import tech.units.indriya.function.MultiplyConverter;
import tech.units.indriya.function.RationalNumber;
import javax.measure.Quantity;
import javax.measure.Unit;
import javax.measure.quantity.*;

// Time: hours, minutes, seconds
MixedRadix<Time> hms = MixedRadix.of(Units.HOUR).mix(Units.MINUTE).mix(Units.SECOND);

// Build a quantity from mixed values: 1h 30min 0s
Quantity<Time> duration = hms.createQuantity(new Number[]{1, 30, 0});
System.out.println(duration); // total in primary (trailing) unit: seconds

// Decompose back into mixed components
Number[] parts = hms.extract(duration);
System.out.println(parts[0] + "h " + parts[1] + "min " + parts[2] + "s"); // "1h 30min 0s"

// MixedQuantity (retains all components separately)
MixedQuantity<Time> mixedTime = hms.createMixedQuantity(new Number[]{2, 15, 45});
System.out.println(mixedTime.getUnits()); // [h, min, s]

// via Quantities facade
@SuppressWarnings("unchecked")
Quantity<Time> q = Quantities.getQuantity(new Number[]{1, 30}, Units.HOUR, Units.MINUTE);
System.out.println(q.to(Units.MINUTE).getValue()); // 90
```

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

### `Units` — Predefined SI and Common Units

Source: https://context7.com/unitsofmeasurement/indriya/llms.txt

Access to a singleton instance of `SystemOfUnits` containing predefined SI base units, SI derived units, and common accepted units.

```APIDOC
## `Units` — Predefined SI units and common derived units

`tech.units.indriya.unit.Units` is a `SystemOfUnits` singleton containing all SI base units, SI derived units, and common accepted units. Metric and binary prefixes are applied via `MetricPrefix.*` and `BinaryPrefix.*` static helpers.

### Accessing Units

- **Units.METRE**: The unit for Length (SI base unit).
- **Units.KILOGRAM**: The unit for Mass (SI base unit).
- **Units.SECOND**: The unit for Time (SI base unit).
- **Units.NEWTON**: The unit for Force (SI derived unit).
- **Units.CELSIUS**: The unit for Temperature (Non-SI accepted).
- **Units.KILOMETRE_PER_HOUR**: The unit for Speed (Non-SI accepted).
- **Units.PERCENT**: The unit for Percentage (Non-SI accepted).

### Applying Prefixes

- **MetricPrefix.KILO(Units.METRE)**: Returns the unit for kilometer.
- **MetricPrefix.CENTI(Units.METRE)**: Returns the unit for centimeter.
- **BinaryPrefix.KIBI(Units.BYTE)**: Returns the unit for kibibyte.

### System of Units Instance

- **Units.getInstance()**: Retrieves the singleton `SystemOfUnits` instance.
- **sou.getUnit(Quantity.class)**: Retrieves a unit for a given quantity type.

### Example
```java
import tech.units.indriya.unit.Units;
import static javax.measure.MetricPrefix.*;
import static javax.measure.BinaryPrefix.*;
import javax.measure.Unit;
import javax.measure.quantity.*;

// Base units
Unit<Length>      m   = Units.METRE;
Unit<Mass>        kg  = Units.KILOGRAM;
Unit<Temperature> K   = Units.KELVIN;
Unit<Time>        s   = Units.SECOND;

// Metric prefixes
Unit<Length>      km  = KILO(Units.METRE);    // km
Unit<Length>      cm  = CENTI(Units.METRE);   // cm
Unit<Mass>        mg  = MILLI(Units.GRAM);    // mg
Unit<Frequency>   MHz = MEGA(Units.HERTZ);    // MHz

// Lookup unit by quantity type via system instance
javax.measure.spi.SystemOfUnits sou = Units.getInstance();
Unit<?> timeUnit = sou.getUnit(Time.class);
System.out.println(timeUnit); // "s"

// Non-SI accepted
System.out.println(Units.CELSIUS);          // "℃"
System.out.println(Units.KILOMETRE_PER_HOUR); // "km/h"
System.out.println(Units.PERCENT);          // "%"
```
```

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

### Quantity.to(Unit<Q>)

Source: https://context7.com/unitsofmeasurement/indriya/llms.txt

Converts a quantity to another compatible unit, automatically computing the unit-converter chain. The original quantity remains unchanged.

```APIDOC
## Quantity.to(Unit<Q>) 

### Description
Converts a quantity to another compatible unit by automatically computing the unit-converter chain. The result is a new `Quantity<Q>` expressed in the target unit; the original quantity is unchanged. This method works for any two compatible units, including prefix-scaled units and temperature scales.

### Method Signature
`<R extends Quantity<R>> Quantity<R> to(Unit<R> unit)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```java
import tech.units.indriya.quantity.Quantities;
import tech.units.indriya.unit.Units;
import static javax.measure.MetricPrefix.*;
import javax.measure.Quantity;
import javax.measure.quantity.*;

// Length: metres → centimetres
Quantity<Length> metres = Quantities.getQuantity(4.0, Units.METRE);
Quantity<Length> cm     = metres.to(CENTI(Units.METRE));

// Time: 1 year → seconds
Quantity<Time> year = Quantities.getQuantity(1, Units.YEAR);
Quantity<Time> secs = year.to(Units.SECOND);

// Temperature: Celsius ↔ Kelvin
Quantity<Temperature> boiling = Quantities.getQuantity(100.0, Units.CELSIUS);
Quantity<Temperature> kelvin  = boiling.to(Units.KELVIN);

Quantity<Temperature> fromK = Quantities.getQuantity(273.15, Units.KELVIN).to(Units.CELSIUS);
```

### Response
#### Success Response (200)
Returns a new `Quantity<Q>` object representing the converted value in the target unit.

#### Response Example
```
System.out.println(cm.getValue()); // 400.0
System.out.println(secs.getValue()); // 31556952
System.out.println(kelvin.getValue()); // 373.15
System.out.println(fromK.getValue()); // 0.0
```
```

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

### Format and Parse Quantities with SimpleQuantityFormat

Source: https://context7.com/unitsofmeasurement/indriya/llms.txt

Use `SimpleQuantityFormat.getInstance()` for locale-neutral formatting and parsing. It supports standard unit representations and can parse quantity strings into `Quantity` objects. Custom delimiters can be configured using `NumberDelimiterQuantityFormat.Builder`.

```java
import tech.units.indriya.format.SimpleQuantityFormat;
import tech.units.indriya.format.NumberDelimiterQuantityFormat;
import tech.units.indriya.quantity.Quantities;
import tech.units.indriya.unit.Units;
import static javax.measure.MetricPrefix.*;
import javax.measure.Quantity;
import javax.measure.format.QuantityFormat;
import javax.measure.quantity.*;
import java.text.DecimalFormat;
import java.util.Locale;

SimpleQuantityFormat fmt = SimpleQuantityFormat.getInstance();

// Format
Quantity<Frequency> tenHz    = Quantities.getQuantity(10,   Units.HERTZ);
Quantity<Frequency> fiveKhz  = Quantities.getQuantity(5,    KILO(Units.HERTZ));
Quantity<Frequency> oneMHz   = Quantities.getQuantity(1,    MEGA(Units.HERTZ));
System.out.println(fmt.format(tenHz));    // "10 Hz"
System.out.println(fmt.format(fiveKhz)); // "5 kHz"
System.out.println(oneMHz.toString());   // "1 MHz"
```

```java
// Parse
Quantity<?> parsed = fmt.parse("10 min");
System.out.println(parsed); // "10 min"

Quantity<Length> height = Quantities.getQuantity("1.70 m").asType(Length.class);
System.out.println(height); // "1.70 m"
```

```java
// Custom delimiter format
QuantityFormat custom = new NumberDelimiterQuantityFormat.Builder()
        .setNumberFormat(DecimalFormat.getInstance(Locale.ENGLISH))
        .setUnitFormat(tech.units.indriya.format.SimpleUnitFormat.getInstance())
        .setDelimiter("_")
        .setLocaleSensitive(true)
        .build();
Quantity<Length> l = Quantities.getQuantity(150, CENTI(Units.METRE));
System.out.println(custom.format(l)); // "150_cm"
```

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

### Create Typed Quantities with DefaultQuantityFactory

Source: https://context7.com/unitsofmeasurement/indriya/llms.txt

Use DefaultQuantityFactory to obtain a factory for a specific quantity type and create quantities with units. Factories are cached per quantity type.

```java
import tech.units.indriya.quantity.DefaultQuantityFactory;
import javax.measure.Quantity;
import javax.measure.quantity.Length;
import javax.measure.spi.QuantityFactory;
import tech.units.indriya.unit.Units;

// Obtain a factory for a specific quantity type
QuantityFactory<Length> factory = DefaultQuantityFactory.getInstance(Length.class);

// Create quantities
Quantity<Length> l1 = factory.create(5.0, Units.METRE);
Quantity<Length> l2 = factory.create(200, Units.KILOMETRE_PER_HOUR.asType(Length.class));

System.out.println(l1);               // "5.0 m"
System.out.println(factory.getSystemUnit()); // "m"
```

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

### Create and Convert MixedQuantity Length

Source: https://context7.com/unitsofmeasurement/indriya/llms.txt

Shows how to create a MixedQuantity for length by combining individual quantities (e.g., meters and centimeters). Use this to represent compound measurements and convert them to a single unit.

```java
import tech.units.indriya.quantity.MixedQuantity;
import tech.units.indriya.quantity.Quantities;
import tech.units.indriya.unit.Units;
import static javax.measure.MetricPrefix.CENTI;
import javax.measure.Quantity;
import javax.measure.quantity.Length;
import java.math.BigDecimal;

// Create from individual sub-quantities
@SuppressWarnings("unchecked")
Quantity<Length>[] parts = new Quantity[]{
    Quantities.getQuantity(1,  Units.METRE),
    Quantities.getQuantity(70, CENTI(Units.METRE))
};
MixedQuantity<Length> height = MixedQuantity.of(parts);

System.out.println(height);              // "1 m 70 cm"
System.out.println(height.getUnits());   // "[m, cm]"

// Convert to a single unit
Quantity<Length> inMetres = height.to(Units.METRE);
System.out.println(inMetres.getValue()); // 1.7

Quantity<Length> inCm = height.to(CENTI(Units.METRE));
System.out.println(inCm.getValue());     // 170
```

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

### Quantity Creation with Arithmetic Characteristic (Runtime Checks)

Source: https://github.com/unitsofmeasurement/indriya/wiki/Arithmetic-Rules-for-Difference-vs-Absolute-Quantities-(DRAFT)

Use Quantities.getQuantity with an optional ArithmeticCharacteristic for units that support both absolute and difference policies. For UNIFIED_ONLY units, only the number and unit are needed.

```java
Quantities.getQuantity(5, KELVIN)
Quantities.getQuantity(5, KELVIN, ABSOLUTE)
Quantities.getQuantity(5, KELVIN, DIFFERENCE)

Quantities.getQuantity(5, CELSIUS)
Quantities.getQuantity(5, CELSIUS, ABSOLUTE)
Quantities.getQuantity(5, CELSIUS, DIFFERENCE)
```

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

### Accessing Predefined SI and Common Units

Source: https://context7.com/unitsofmeasurement/indriya/llms.txt

Utilize the Units class to access predefined SI base units, SI derived units, and common accepted units. Metric and binary prefixes can be applied using static helper methods. Units can also be looked up by quantity type.

```java
import tech.units.indriya.unit.Units;
import static javax.measure.MetricPrefix.*;
import static javax.measure.BinaryPrefix.*;
import javax.measure.Unit;
import javax.measure.quantity.*;

// Base units
Unit<Length>      m   = Units.METRE;
Unit<Mass>        kg  = Units.KILOGRAM;
Unit<Temperature> K   = Units.KELVIN;
Unit<Time>        s   = Units.SECOND;

// Metric prefixes
Unit<Length>      km  = KILO(Units.METRE);    // km
Unit<Length>      cm  = CENTI(Units.METRE);   // cm
Unit<Mass>        mg  = MILLI(Units.GRAM);    // mg
Unit<Frequency>   MHz = MEGA(Units.HERTZ);    // MHz

// Lookup unit by quantity type via system instance
javax.measure.spi.SystemOfUnits sou = Units.getInstance();
Unit<?> timeUnit = sou.getUnit(Time.class);
System.out.println(timeUnit); // "s"

// Non-SI accepted
System.out.println(Units.CELSIUS);          // "℃"
System.out.println(Units.KILOMETRE_PER_HOUR); // "km/h"
System.out.println(Units.PERCENT);          // "%"
```

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

### SimpleQuantityFormat

Source: https://context7.com/unitsofmeasurement/indriya/llms.txt

`SimpleQuantityFormat` provides locale-neutral formatting and parsing of quantities. It supports default formatting, custom delimiters, and locale-sensitive parsing.

```APIDOC
## `SimpleQuantityFormat` — Format and parse quantities as strings

`SimpleQuantityFormat` is the default locale-neutral `QuantityFormat` implementation. Patterns use `n` (number), `u` (unit), `~` (mixed-radix delimiter), and `rc` (range compact). `NumberDelimiterQuantityFormat` provides a builder for custom separators and locale-sensitive formatting.

```java
import tech.units.indriya.format.SimpleQuantityFormat;
import tech.units.indriya.format.NumberDelimiterQuantityFormat;
import tech.units.indriya.quantity.Quantities;
import tech.units.indriya.unit.Units;
import static javax.measure.MetricPrefix.*;
import javax.measure.Quantity;
import javax.measure.format.QuantityFormat;
import javax.measure.quantity.*;
import java.text.DecimalFormat;
import java.util.Locale;

SimpleQuantityFormat fmt = SimpleQuantityFormat.getInstance();

// Format
Quantity<Frequency> tenHz    = Quantities.getQuantity(10,   Units.HERTZ);
Quantity<Frequency> fiveKhz  = Quantities.getQuantity(5,    KILO(Units.HERTZ));
Quantity<Frequency> oneMHz   = Quantities.getQuantity(1,    MEGA(Units.HERTZ));
System.out.println(fmt.format(tenHz));    // "10 Hz"
System.out.println(fmt.format(fiveKhz)); // "5 kHz"
System.out.println(oneMHz.toString());   // "1 MHz"

// Parse
Quantity<?> parsed = fmt.parse("10 min");
System.out.println(parsed); // "10 min"

Quantity<Length> height = Quantities.getQuantity("1.70 m").asType(Length.class);
System.out.println(height); // "1.70 m"

// Custom delimiter format
QuantityFormat custom = new NumberDelimiterQuantityFormat.Builder()
        .setNumberFormat(DecimalFormat.getInstance(Locale.ENGLISH))
        .setUnitFormat(tech.units.indriya.format.SimpleUnitFormat.getInstance())
        .setDelimiter("_")
        .setLocaleSensitive(true)
        .build();
Quantity<Length> l = Quantities.getQuantity(150, CENTI(Units.METRE));
System.out.println(custom.format(l)); // "150_cm"
```
```

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

### Quantity Creation without Exposing ArithmeticCharacteristic (Runtime Checks)

Source: https://github.com/unitsofmeasurement/indriya/wiki/Arithmetic-Rules-for-Difference-vs-Absolute-Quantities-(DRAFT)

Use specific factory methods like getAbsoluteQuantity or getDifferenceQuantity for units that support ABSOLUTE_OR_DIFFERENCE policies, avoiding direct exposure of ArithmeticCharacteristic. For UNIFIED_ONLY units, Quantities.getQuantity is used.

```java
Quantities.getQuantity(5, KELVIN)
Quantities.getAbsoluteQuantity(5, KELVIN)
Quantities.getDifferenceQuantity(5, KELVIN)

Quantities.getQuantity(5, CELSIUS)
Quantities.getAbsoluteQuantity(5, CELSIUS)
Quantities.getDifferenceQuantity(5, CELSIUS)
```

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

### Quantities.getQuantity(Number, Unit<Q>)

Source: https://context7.com/unitsofmeasurement/indriya/llms.txt

Creates a typed quantity from a number and a unit. Supports primitive numeric types and BigDecimal/BigInteger. A variant allows for RELATIVE scale quantities.

```APIDOC
## Quantities.getQuantity(Number, Unit<Q>) 

### Description
Creates a typed quantity from a number and unit. Accepts any `Number` subtype and a `Unit<Q>`, returning an ABSOLUTE-scale quantity. A variant accepting a `Scale` parameter lets callers produce RELATIVE quantities (e.g. temperature differences).

### Method Signature
`Quantity<Q> getQuantity(Number value, Unit<Q> unit)`
`Quantity<Q> getQuantity(Number value, Unit<Q> unit, Quantity.Scale scale)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```java
import tech.units.indriya.quantity.Quantities;
import tech.units.indriya.unit.Units;
import javax.measure.Quantity;
import javax.measure.quantity.*;

// Primitive numeric types
Quantity<Length>      len  = Quantities.getQuantity(1.70, Units.METRE);
Quantity<Mass>        mass = Quantities.getQuantity(75,   Units.KILOGRAM);
Quantity<Temperature> temp = Quantities.getQuantity(23.0, Units.CELSIUS);
Quantity<Pressure>    pres = Quantities.getQuantity(java.math.BigDecimal.ONE, Units.PASCAL);

// RELATIVE scale (temperature intervals / differences)
import static javax.measure.Quantity.Scale.RELATIVE;
Quantity<Temperature> delta = Quantities.getQuantity(5.0, Units.CELSIUS, RELATIVE);
```

### Response
#### Success Response (200)
Returns a `Quantity<Q>` object representing the specified amount and unit.

#### Response Example
```
System.out.println(temp);   // "23 ℃"
System.out.println(len);    // "1.7 m"
System.out.println(delta.getScale()); // "RELATIVE"
```
```

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

### `Unit<Q>.getConverterTo(Unit<Q>)` Unit Conversion

Source: https://context7.com/unitsofmeasurement/indriya/llms.txt

Obtain a low-level `UnitConverter` to map numeric values between units. This is useful for converting large arrays of raw numbers efficiently.

```APIDOC
## `Unit<Q>.getConverterTo(Unit<Q>)` — Obtain a low-level UnitConverter

Returns a `UnitConverter` function object that maps numeric values from the source unit to the target unit. Converters compose, invert, and simplify automatically.

### Method

- **getConverterTo(Unit<Q> targetUnit)**: Returns a `UnitConverter` to convert from the current unit to the `targetUnit`.

### Parameters

#### Path Parameters

- **targetUnit** (Unit<Q>) - Required - The unit to convert to.

### Request Example
```java
import tech.units.indriya.unit.Units;
import static javax.measure.MetricPrefix.*;
import javax.measure.UnitConverter;
import javax.measure.Unit;
import javax.measure.quantity.Length;

Unit<Length> source = Units.METRE;
Unit<Length> target = CENTI(Units.METRE);

UnitConverter converter = source.getConverterTo(target);
System.out.println(converter.convert(4.0));  // 400.0
System.out.println(converter.convert(6.0));  // 600.0

// Inverse
UnitConverter inverse = converter.inverse();
System.out.println(inverse.convert(400.0)); // 4.0

// Symmetry: kg→g converter equals g→kg converter (inverted)
System.out.println(
    Units.KILOGRAM.getConverterTo(KILO(Units.GRAM))
        .equals(KILO(Units.GRAM).getConverterTo(Units.KILOGRAM))
);
```
```

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

### Create Typed Quantity with Quantities.getQuantity

Source: https://context7.com/unitsofmeasurement/indriya/llms.txt

Use Quantities.getQuantity to create a ComparableQuantity from a Number and Unit. Supports primitive numeric types and BigDecimal/BigInteger. A variant allows creating RELATIVE scale quantities for differences or intervals.

```java
import tech.units.indriya.quantity.Quantities;
import tech.units.indriya.unit.Units;
import javax.measure.Quantity;
import javax.measure.quantity.*;

// Primitive numeric types
Quantity<Length>      len  = Quantities.getQuantity(1.70, Units.METRE);        // 1.7 m
Quantity<Mass>        mass = Quantities.getQuantity(75,   Units.KILOGRAM);     // 75 kg
Quantity<Temperature> temp = Quantities.getQuantity(23.0, Units.CELSIUS);      // 23.0 °C
Quantity<Pressure>    pres = Quantities.getQuantity(java.math.BigDecimal.ONE, Units.PASCAL);

System.out.println(temp);   // "23 ℃"
System.out.println(len);    // "1.7 m"

// RELATIVE scale (temperature intervals / differences)
import static javax.measure.Quantity.Scale.RELATIVE;
Quantity<Temperature> delta = Quantities.getQuantity(5.0, Units.CELSIUS, RELATIVE);
System.out.println(delta.getScale()); // "RELATIVE"
```

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

### API Extension: Quantity Creation 2

Source: https://github.com/unitsofmeasurement/indriya/wiki/Arithmetic-Rules-for-Difference-vs-Absolute-Quantities-(DRAFT)

This API extension provides a variant to 'Quantity Creation 1' without exposing ArithmeticCharacteristic to the public API. It offers specific methods for creating absolute or difference quantities.

```APIDOC
## API Extension: Quantity Creation 2

Variant to 'Quantity Creation 1' w/o exposing `ArithmeticCharacteristic` to the public API

1) For Unit with policy `UNIFIED_ONLY` use:  
`Quantities.getQuantity(Number, Unit)` ... a Quantity w/ characteristic UNIFIED 

2) For Unit with policy `ABSOLUTE_OR_DIFFERENCE` use:  
`Quantities.getAbsoluteQuantity(Number, Unit)` ... Quantity w/ ABSOLUTE characteristic 
`Quantities.getDifferenceQuantity(Number, Unit)` ... Quantity w/ DIFFERENCE characteristic 

### Examples utilizing checks at run-time
`Quantities.getQuantity(5, KELVIN)` ... OK  
`Quantities.getAbsoluteQuantity(5, KELVIN)` ... IllegalArgumentException or OK ??? 
`Quantities.getDifferenceQuantity(5, KELVIN)` ... IllegalArgumentException or OK ???

`Quantities.getQuantity(5, CELSIUS)` ... IllegalArgumentException   
`Quantities.getAbsoluteQuantity(5, CELSIUS)` ... OK  
`Quantities.getDifferenceQuantity(5, CELSIUS)` ... OK
```

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

### API Extension: Quantity Creation 1

Source: https://github.com/unitsofmeasurement/indriya/wiki/Arithmetic-Rules-for-Difference-vs-Absolute-Quantities-(DRAFT)

This API extension allows for the creation of quantities with specific arithmetic characteristics by providing an optional ArithmeticCharacteristic. It is useful for units that support both absolute and difference characteristics.

```APIDOC
## API Extension: Quantity Creation 1

It would be desirable to extend the programming model, such that we can enforce this policy at compile-time, but this example does not:

1) For Unit with policy `UNIFIED_ONLY` use:  
`Quantities.getQuantity(Number, Unit)` ... a Quantity w/ characteristic UNIFIED 

2) For Unit with policy `ABSOLUTE_OR_DIFFERENCE` use:  
`Quantities.getQuantity(Number, Unit, ArithmeticCharacteristic)` ... Quantity w/ either ABS. or DIF. characteristic 

### Examples utilizing checks at run-time
`Quantities.getQuantity(5, KELVIN)` ... OK  
`Quantities.getQuantity(5, KELVIN, ABSOLUTE)` ... IllegalArgumentException or OK ???   
`Quantities.getQuantity(5, KELVIN, DIFFERENCE)` ... IllegalArgumentException or OK ???   

`Quantities.getQuantity(5, CELSIUS)` ... IllegalArgumentException   
`Quantities.getQuantity(5, CELSIUS, ABSOLUTE)` ... OK  
`Quantities.getQuantity(5, CELSIUS, DIFFERENCE)` ... OK
```

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

### QuantityRange<Q>

Source: https://context7.com/unitsofmeasurement/indriya/llms.txt

`QuantityRange<Q>` represents a min/max interval with an optional resolution step over a quantity dimension. Null boundaries model open-ended ranges, and it supports formatting with a compact pattern.

```APIDOC
## `QuantityRange<Q>` — Typed range of quantity values

`QuantityRange<Q>` represents a min/max interval (with optional resolution step) over a quantity dimension. Null boundaries model open-ended ranges. The `SimpleQuantityFormat` supports a `"rc"` (range compact) pattern token for formatting ranges.

```java
import tech.units.indriya.quantity.Quantities;
import tech.units.indriya.quantity.QuantityRange;
import tech.units.indriya.format.SimpleQuantityFormat;
import tech.units.indriya.unit.Units;
import javax.measure.Quantity;
import javax.measure.quantity.Mass;

Quantity<Mass> oneKg   = Quantities.getQuantity(1d,  Units.KILOGRAM);
Quantity<Mass> tenKg   = Quantities.getQuantity(10d, Units.KILOGRAM);
Quantity<Mass> twoKg   = Quantities.getQuantity(2d,  Units.KILOGRAM);

// Closed range with resolution
@SuppressWarnings("unchecked")
QuantityRange<Mass> range = QuantityRange.of(oneKg, tenKg, twoKg);
System.out.println(range.getMinimum());  // "1 kg"
System.out.println(range.getMaximum());  // "10 kg"
System.out.println(range.getResolution()); // "2 kg"

// Open-ended ranges (null boundary)
@SuppressWarnings("unchecked")
QuantityRange<Mass> atLeastOne = QuantityRange.of(oneKg, null);
System.out.println(atLeastOne.hasMaximum()); // false

// Format a range with compact pattern
SimpleQuantityFormat compactFmt = SimpleQuantityFormat.getInstance("rc");
System.out.println(compactFmt.formatRange(range));
// "min=1 kg, max=10 kg"
```
```

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

### Convert Quantity to Another Unit with Quantity.to

Source: https://context7.com/unitsofmeasurement/indriya/llms.txt

Use the to() method on a Quantity object to convert it to a different compatible unit. This automatically computes the unit-converter chain. Works for prefix-scaled units and temperature scales.

```java
import tech.units.indriya.quantity.Quantities;
import tech.units.indriya.unit.Units;
import static javax.measure.MetricPrefix.*;
import javax.measure.Quantity;
import javax.measure.quantity.*;

// Length: metres → centimetres
Quantity<Length> metres = Quantities.getQuantity(4.0, Units.METRE);
Quantity<Length> cm     = metres.to(CENTI(Units.METRE));
System.out.println(cm.getValue()); // 400.0

// Time: 1 year → seconds
Quantity<Time> year = Quantities.getQuantity(1, Units.YEAR);
Quantity<Time> secs = year.to(Units.SECOND);
System.out.println(secs.getValue()); // 31556952

// Temperature: Celsius ↔ Kelvin
Quantity<Temperature> boiling = Quantities.getQuantity(100.0, Units.CELSIUS);
Quantity<Temperature> kelvin  = boiling.to(Units.KELVIN);
System.out.println(kelvin.getValue()); // 373.15

Quantity<Temperature> fromK = Quantities.getQuantity(273.15, Units.KELVIN).to(Units.CELSIUS);
System.out.println(fromK.getValue()); // 0.0
```

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

### Quantities.getQuantity(CharSequence)

Source: https://context7.com/unitsofmeasurement/indriya/llms.txt

Parses a quantity string, supporting simple, prefixed, and mixed-radix representations. A unit part is required for successful parsing.

```APIDOC
## `Quantities.getQuantity(CharSequence)` — Parse a quantity string including mixed-unit expressions

Parses a locale-neutral string containing one or more number-unit pairs. Supports simple (`"1.70 m"`), prefixed (`"170 cm"`), and mixed-radix (`"1 m 70 cm"`) representations. Requires a unit part to be present; parsing unit-less strings throws `IllegalArgumentException`.

```java
import tech.units.indriya.quantity.Quantities;
import javax.measure.Quantity;
import javax.measure.quantity.*;

// Single unit
Quantity<Length> h1 = Quantities.getQuantity("1.70 m").asType(Length.class);
Quantity<Length> h2 = Quantities.getQuantity("170 cm").asType(Length.class);

// Mixed unit (1 m 70 cm) – both representations are equivalent
Quantity<Length> h3 = Quantities.getQuantity("1 m 70 cm").asType(Length.class);

// Speed
Quantity<Speed> s = Quantities.getQuantity("15.0 km/h").asType(Speed.class);

// Verify equivalence across representations
tech.units.indriya.ComparableQuantity<Length> ref =
    Quantities.getQuantity(1.70, tech.units.indriya.unit.Units.METRE);
System.out.println(ref.isEquivalentTo(h1)); // true
System.out.println(ref.isEquivalentTo(h2)); // true
System.out.println(ref.isEquivalentTo(h3)); // true

// IllegalArgumentException for unit-less string
try {
    Quantities.getQuantity("170");
} catch (IllegalArgumentException e) {
    System.out.println("Unit required: " + e.getMessage());
}
```
```

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

### MixedQuantity<Q>

Source: https://context7.com/unitsofmeasurement/indriya/llms.txt

`MixedQuantity<Q>` groups an array of typed sub-quantities sharing the same dimension, preserving each component. It converts to any compatible unit and supports string output in a "value unit value unit …" form.

```APIDOC
## `MixedQuantity<Q>` — Quantity composed of several sub-quantities

`MixedQuantity<Q>` groups an array of typed sub-quantities sharing the same dimension, preserving each component. It converts to any compatible unit with `to(Unit<Q>)` and supports string output in "value unit value unit …" form.

```java
import tech.units.indriya.quantity.MixedQuantity;
import tech.units.indriya.quantity.Quantities;
import tech.units.indriya.unit.Units;
import static javax.measure.MetricPrefix.CENTI;
import javax.measure.Quantity;
import javax.measure.quantity.Length;
import java.math.BigDecimal;

// Create from individual sub-quantities
@SuppressWarnings("unchecked")
Quantity<Length>[] parts = new Quantity[]{
    Quantities.getQuantity(1,  Units.METRE),
    Quantities.getQuantity(70, CENTI(Units.METRE))
};
MixedQuantity<Length> height = MixedQuantity.of(parts);

System.out.println(height);              // "1 m 70 cm"
System.out.println(height.getUnits());   // "[m, cm]"

// Convert to a single unit
Quantity<Length> inMetres = height.to(Units.METRE);
System.out.println(inMetres.getValue()); // 1.7

Quantity<Length> inCm = height.to(CENTI(Units.METRE));
System.out.println(inCm.getValue());     // 170
```
```

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

### Parse Quantity Strings with Mixed Units

Source: https://context7.com/unitsofmeasurement/indriya/llms.txt

Use `Quantities.getQuantity(CharSequence)` to parse strings representing quantities, including simple, prefixed, and mixed-unit expressions. A unit part is mandatory; parsing unit-less strings will result in an `IllegalArgumentException`.

```java
import tech.units.indriya.quantity.Quantities;
import javax.measure.Quantity;
import javax.measure.quantity.*;

// Single unit
Quantity<Length> h1 = Quantities.getQuantity("1.70 m").asType(Length.class);
Quantity<Length> h2 = Quantities.getQuantity("170 cm").asType(Length.class);

// Mixed unit (1 m 70 cm) – both representations are equivalent
Quantity<Length> h3 = Quantities.getQuantity("1 m 70 cm").asType(Length.class);

// Speed
Quantity<Speed> s = Quantities.getQuantity("15.0 km/h").asType(Speed.class);

// Verify equivalence across representations
tech.units.indriya.ComparableQuantity<Length> ref =
    Quantities.getQuantity(1.70, tech.units.indriya.unit.Units.METRE);
System.out.println(ref.isEquivalentTo(h1)); // true
System.out.println(ref.isEquivalentTo(h2)); // true
System.out.println(ref.isEquivalentTo(h3)); // true
```

```java
// IllegalArgumentException for unit-less string
try {
    Quantities.getQuantity("170");
} catch (IllegalArgumentException e) {
    System.out.println("Unit required: " + e.getMessage());
}
```

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

### Add Indriya Maven Dependency

Source: https://github.com/unitsofmeasurement/indriya/blob/master/docs/index.html

Include this dependency in your Maven project to use the Indriya library. Check MavenCentral for the latest version.

```xml
<dependency>
  <groupId>tech.units</groupId>
  <artifactId>indriya</artifactId>
  <version>2.2.3</version>
</dependency>
```

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

### UnitConverter for Raw Number Conversion

Source: https://context7.com/unitsofmeasurement/indriya/llms.txt

Obtain a UnitConverter to map numeric values between units without wrapping each in a Quantity. Converters compose, invert, and simplify automatically. Useful for converting large arrays of raw numbers.

```java
import tech.units.indriya.unit.Units;
import static javax.measure.MetricPrefix.*;
import javax.measure.UnitConverter;
import javax.measure.Unit;
import javax.measure.quantity.Length;

Unit<Length> source = Units.METRE;
Unit<Length> target = CENTI(Units.METRE);

UnitConverter converter = source.getConverterTo(target);
System.out.println(converter.convert(4.0));  // 400.0
System.out.println(converter.convert(6.0));  // 600.0

// Inverse
UnitConverter inverse = converter.inverse();
System.out.println(inverse.convert(400.0)); // 4.0

// Symmetry: kg→g converter equals g→kg converter (inverted)
System.out.println(
    Units.KILOGRAM.getConverterTo(KILO(Units.GRAM))
        .equals(KILO(Units.GRAM).getConverterTo(Units.KILOGRAM))
); // true
```

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

### ComparableQuantity Arithmetic Operations

Source: https://context7.com/unitsofmeasurement/indriya/llms.txt

Perform typed arithmetic operations like add, subtract, multiply, and divide on quantities. Automatic unit conversion is handled for compatible units. Cross-type division or multiplication yields a ComparableQuantity<?> that can be cast to the expected derived type.

```java
import tech.units.indriya.quantity.Quantities;
import tech.units.indriya.unit.Units;
import tech.units.indriya.ComparableQuantity;
import static javax.measure.MetricPrefix.KILO;
import javax.measure.quantity.*;

ComparableQuantity<Length> a = Quantities.getQuantity(3.0, Units.METRE);
ComparableQuantity<Length> b = Quantities.getQuantity(200.0, KILO(Units.METRE));

// Addition auto-converts b to metres before summing
ComparableQuantity<Length> sum = a.add(b);
System.out.println(sum); // "200003.0 m"

// Scalar multiplication / division
ComparableQuantity<Length> doubled  = a.multiply(2);    // 6.0 m
ComparableQuantity<Length> halved   = a.divide(2);      // 1.5 m

// Comparison (auto-converts units)
System.out.println(a.isLessThan(b));             // true
System.out.println(a.isGreaterThanOrEqualTo(a)); // true

// Cross-type: Length / Time → Speed
ComparableQuantity<Time>  t     = Quantities.getQuantity(2.0, Units.SECOND);
ComparableQuantity<Speed> speed = a.divide(t, Speed.class);
System.out.println(speed); // "1.5 m/s"
```

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

### MixedRadix<Q>

Source: https://context7.com/unitsofmeasurement/indriya/llms.txt

`MixedRadix<Q>` represents a compound unit made up of multiple sub-units of the same dimension. It allows for creating quantities from mixed values and decomposing single-unit quantities into their mixed-radix components.

```APIDOC
## `MixedRadix<Q>` — Mixed-radix (compound) unit representations

`MixedRadix<Q>` represents a compound unit made up of multiple sub-units of the same dimension (e.g. hours + minutes + seconds, or feet + inches). It provides `createQuantity(Number[])` and `createMixedQuantity(Number[])` to assemble values, and its `extract(Quantity)` method decomposes a single-unit quantity into its mixed-radix components.

```java
import tech.units.indriya.function.MixedRadix;
import tech.units.indriya.quantity.MixedQuantity;
import tech.units.indriya.quantity.Quantities;
import tech.units.indriya.unit.Units;
import tech.units.indriya.function.MultiplyConverter;
import tech.units.indriya.function.RationalNumber;
import javax.measure.Quantity;
import javax.measure.Unit;
import javax.measure.quantity.*;

// Time: hours, minutes, seconds
MixedRadix<Time> hms = MixedRadix.of(Units.HOUR).mix(Units.MINUTE).mix(Units.SECOND);

// Build a quantity from mixed values: 1h 30min 0s
Quantity<Time> duration = hms.createQuantity(new Number[]{1, 30, 0});
System.out.println(duration); // total in primary (trailing) unit: seconds

// Decompose back into mixed components
Number[] parts = hms.extract(duration);
System.out.println(parts[0] + "h " + parts[1] + "min " + parts[2] + "s"); // "1h 30min 0s"

// MixedQuantity (retains all components separately)
MixedQuantity<Time> mixedTime = hms.createMixedQuantity(new Number[]{2, 15, 45});
System.out.println(mixedTime.getUnits()); // [h, min, s]

// via Quantities facade
@SuppressWarnings("unchecked")
Quantity<Time> q = Quantities.getQuantity(new Number[]{1, 30}, Units.HOUR, Units.MINUTE);
System.out.println(q.to(Units.MINUTE).getValue()); // 90
```
```

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

### Bridge JSR 385 Time Quantities with java.time

Source: https://context7.com/unitsofmeasurement/indriya/llms.txt

TimeQuantities provides factory methods to compute durations between java.time Temporals and LocalTimes, and supports interoperation with java.util.concurrent.TimeUnit. It also offers constants for sub-second units.

```java
import tech.units.indriya.quantity.time.TimeQuantities;
import tech.units.indriya.unit.Units;
import javax.measure.Quantity;
import javax.measure.quantity.Time;
import java.time.LocalDate;
import java.time.LocalTime;
import java.util.concurrent.TimeUnit;

// Duration between two Temporals (result in DAYS)
Quantity<Time> period = TimeQuantities.getQuantity(
    LocalDate.of(2024, 1, 1),
    LocalDate.of(2024, 12, 31)
);
System.out.println(period.getValue() + " days"); // "365 days"

// Duration between two LocalTimes (result in HOURS)
Quantity<Time> hours = TimeQuantities.getQuantity(
    LocalTime.of(8, 0),
    LocalTime.of(17, 30)
);
System.out.println(hours.getValue() + " h"); // "9 h"

// java.util.concurrent.TimeUnit interop
var tuq = TimeQuantities.getQuantity(500L, TimeUnit.MILLISECONDS);
System.out.println(tuq);

// Sub-second units
var ms  = TimeQuantities.MILLISECOND;
var ns  = TimeQuantities.NANOSECOND;
Quantity<Time> latency = tech.units.indriya.quantity.Quantities.getQuantity(250, ms);
Quantity<Time> inNs    = latency.to(ns);
System.out.println(inNs.getValue()); // 2.5E+8
```

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

### ArithmeticPolicy Enum

Source: https://github.com/unitsofmeasurement/indriya/wiki/Arithmetic-Rules-for-Difference-vs-Absolute-Quantities-(DRAFT)

Defines the arithmetic policy for units: UNIFIED_ONLY (quantities can only have UNIFIED characteristic) and ABSOLUTE_OR_DIFFERENCE (quantities can have ABSOLUTE or DIFFERENCE characteristic). Use to specify how a unit influences the arithmetic characteristics of quantities.

```java
public enum ArithmeticPolicy{

  /** Quantities of Units with policy UNIFIED_ONLY can only have UNIFIED 
   * characteristic */
  UNIFIED_ONLY,

  /** Quantities of Units with policy ABSOLUTE_OR_DIFFERENCE can either have 
   * ABSOLUTE or DIFFERENCE characteristic */
  ABSOLUTE_OR_DIFFERENCE
}
```