Decimal

https://hexdocs.pm/decimal
Admin
Elixir library for arbitrary precision decimal arithmetic supporting exact calculations with any...
Tokens:32,862
Snippets:353
Trust Score:9
Update:4 months ago
Show doc for...
Tokens:
Raw
### Get and Inspect Decimal Context

Source: https://hexdocs.pm/decimal/index.html

Retrieve and inspect the current Decimal context, which includes precision, rounding mode, and trap settings.

```Elixir
iex> D.Context.get()
%Decimal.Context{
  precision: 9,
  rounding: :half_up,
  emax: :infinity,
  emin: :infinity,
  flags: [:rounded, :inexact],
  traps: [:invalid_operation, :division_by_zero]
}
```

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

### Unset Division by Zero Trap and Observe Infinity

Source: https://hexdocs.pm/decimal/index.html

Demonstrates unsetting the default trap enablers and then performing a division by zero. This shows how to get 'Infinity' instead of a Decimal.Error by disabling the trap.

```iex
iex> D.Context.get().traps
[:invalid_operation, :division_by_zero]

iex> D.div(42, 0)
** (Decimal.Error)

iex> D.Context.set(%D.Context{D.Context.get() | traps: [], flags: []})
:ok

iex> D.div(42, 0)
Decimal.new("Infinity")

iex> D.Context.get().flags
[:division_by_zero]
```

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

### Decimal Context Functions

Source: https://hexdocs.pm/decimal/Decimal.Context.html

Provides functions to interact with the Decimal context, allowing users to get, set, update, and run operations within a specific context.

```APIDOC
## get()

### Description
Gets the current process's Decimal context.

### Method
`get/0`

### Parameters
None

### Response Example
```elixir
%Decimal.Context{precision: 34, rounding: :half_up, emax: 6144, emin: -6143, flags: [], traps: [:invalid_operation, :division_by_zero]}
```

## set(context)

### Description
Sets the Decimal context for the current process.

### Method
`set/1`

### Parameters
#### Request Body
- **context** (t()) - Required - The Decimal context to set.

### Response Example
```elixir
:ok
```

## update(fun)

### Description
Updates the Decimal context for the current process by applying a function to the current context.

### Method
`update/1`

### Parameters
#### Request Body
- **fun** ((t()) -> t()) - Required - A function that takes the current context and returns the updated context.

### Response Example
```elixir
:ok
```

## with(context, fun)

### Description
Runs a given function within a specified Decimal context. The context is restored after the function completes.

### Method
`with/2`

### Parameters
#### Request Body
- **context** (t()) - Required - The Decimal context to use for the function execution.
- **fun** (() -> x) - Required - The function to run within the specified context.

### Response Example
```elixir
x # The return value of the function
```
```

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

### Decimal Equality Comparison

Source: https://hexdocs.pm/decimal_arithmetic/DecimalArithmetic.html

Checks for equality between decimal numbers using the `==` operator. Examples show comparing a Decimal to a number and two Decimals.

```elixir
iex> ~m(3.15) == 3.15
true
iex> ~m(5.304) == 5.304
true
iex> ~m(1.00001) == ~m(1.00002)
false
```

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

### Decimal Less Than Comparison

Source: https://hexdocs.pm/decimal_arithmetic/DecimalArithmetic.html

Compares decimal numbers using the less than operator (`<`). Examples show comparing a number to a Decimal, a Decimal to a number, and two Decimals.

```elixir
iex> 3 < ~m(2)
false
iex> ~m(3) < 5
true
iex> ~m(2.21) < ~m(2.20)
false
```

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

### Decimal Less Than or Equal To Comparison

Source: https://hexdocs.pm/decimal_arithmetic/DecimalArithmetic.html

Compares decimal numbers using the less than or equal to operator (`<=`). Examples include comparing a number to a Decimal, a Decimal to a number, and two Decimals.

```elixir
iex> 3 <= ~m(2)
false
iex> ~m(3) <= 3
true
iex> ~m(2.20) <= ~m(2.21)
true
```

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

### Get Current Decimal Context

Source: https://hexdocs.pm/decimal/Decimal.Context.html

Retrieves the current Decimal context for the process. This function is available since version 1.9.0.

```Elixir
@spec get() :: t()
```

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

### Decimal Greater Than Comparison

Source: https://hexdocs.pm/decimal_arithmetic/DecimalArithmetic.html

Compares decimal numbers using the greater than operator (`>`). Examples show comparing a number to a Decimal, a Decimal to a number, and two Decimals.

```elixir
iex> 3 > ~m(2)
true
iex> ~m(3) > 5
false
iex> ~m(2.21) > ~m(2.20)
true
```

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

### Set Decimal Context Traps

Source: https://hexdocs.pm/decimal/index.html

Modify the Decimal context to change the trap enablers, for example, by setting them to an empty list.

```Elixir
iex> D.Context.set(%D.Context{D.Context.get() | traps: []})
:ok

iex> D.Context.get()
%Decimal.Context{
  precision: 9,
  rounding: :half_up,
  emax: :infinity,
  emin: :infinity,
  flags: [:rounded, :inexact],
  traps: []
}
```

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

### Create Decimal Values

Source: https://hexdocs.pm/decimal/index.html

Demonstrates creating Decimal values with different signs, coefficients, and exponents to represent various numbers.

```Elixir
Decimal.new(_sign = 1, _coefficient = 42, _exponent = 0) #=> Decimal.new("42")
Decimal.new(-1, 42, 0) #=> Decimal.new("-42")
Decimal.new(1, 42, -1) #=> Decimal.new("4.2")
Decimal.new(1, 42, -20) #=> Decimal.new("4.2E-19")
Decimal.new(1, 42, 20) #=> Decimal.new("4.2E+21")
Decimal.new(1, 123456789987654321, -9) #=> Decimal.new("123456789.987654321")
```

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

### Divide Two Decimals and Get Integer Part

Source: https://hexdocs.pm/decimal/Decimal.html

Divides two decimal numbers and returns only the integer part of the result.

```Elixir
@spec div_int(decimal(), decimal()) :: t()
```

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

### __using__(options)

Source: https://hexdocs.pm/decimal_env/DecimalEnv.Operators.html

Imports the Decimal operators, replacing the Kernel ones. This function is typically used within a module definition.

```APIDOC
## __using__(options)

### Description
Imports the Decimal operators, replacing the Kernel ones. This function is typically used within a module definition.

### Method
`__using__` (Macro)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Response
This is a macro that affects the compilation environment and does not return a value in the typical sense.

### Examples
```elixir
iex> use DecimalEnv.Operators
# This line imports the Decimal operators into the current scope.
```
```

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

### new(binary, opts \\ [])

Source: https://hexdocs.pm/decimal/Decimal.html

Creates a new decimal number from a binary representation with optional arguments.

```APIDOC
## new(binary, opts \\ [])

### Description
Creates a new decimal number from a binary representation with optional arguments.

### Parameters
#### Path Parameters
- **binary** (Binary) - The binary representation.
- **opts** (KeywordList) - Optional arguments.
```

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

### Basic Decimal Addition

Source: https://hexdocs.pm/decimal_env/index.html

Demonstrates a simple addition operation within the decimal macro. Imports DecimalEnv to use the macro.

```elixir
iex(1)> import DecimalEnv
iex(2)> decimal do
...(2)>   21.0 + "21.0"
...(2)> end
#Decimal<42.0>
```

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

### Basic Decimal Arithmetic Operations

Source: https://hexdocs.pm/decimal_arithmetic/DecimalArithmetic.html

Demonstrates basic arithmetic operations like multiplication, division, addition, and subtraction using Decimal types. It also shows how to combine operations and round the final result.

```elixir
iex> a = ~m(98.01)
#Decimal<98.01>
iex> b = ~m(10.01)
#Decimal<10.01>
iex> c = a * b
#Decimal<981.0801>
iex> d = c / 77
#Decimal<12.7413>
iex> (a + b * c / d) * 3.14
#Decimal<2727.9692>
iex> net_price = ~m(34.78)
#Decimal<34.78>
iex> vat_rate = 23
23
iex> net_price * (1 + vat_rate / 100) |> Decimal.round(2)
#Decimal<42.78>
```

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

### Get Absolute Value of Decimal

Source: https://hexdocs.pm/decimal/Decimal.html

Calculates the absolute value of a decimal number by setting its sign to positive. Handles regular numbers, NaN, and Infinity.

```Elixir
@spec abs(t()) :: t()
```

```Elixir
iex> Decimal.abs(Decimal.new("1"))
Decimal.new("1")
```

```Elixir
iex> Decimal.abs(Decimal.new("-1"))
Decimal.new("1")
```

```Elixir
iex> Decimal.abs(Decimal.new("NaN"))
Decimal.new("NaN")
```

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

### Basic Decimal Operations in IEx

Source: https://hexdocs.pm/decimal/index.html

Perform basic arithmetic operations like addition and division using the Decimal module after aliasing it.

```Elixir
iex> alias Decimal, as: D
iex> D.add(6, 7)
Decimal.new("13")
iex> D.div(1, 3)
Decimal.new("0.3333333333333333333333333333")
iex> D.new("0.33")
Decimal.new("0.33")
```

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

### Compare Decimal Values

Source: https://hexdocs.pm/decimal/index.html

Use comparison functions like `compare/2` and `equal?/2` for accurate comparisons, as standard operators may be unreliable with multiple decimal places.

```Elixir
iex> D.compare(-1, 0)
:lt
iex> D.compare(0, -1)
:gt
iex> D.compare(0, 0)
:eq

iex> D.equal?(-1, 0)
false
iex> D.equal?(0, "0.0")
true
```

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

### Convert Decimal to String

Source: https://hexdocs.pm/decimal/Decimal.html

Shows how to convert a Decimal value to its string representation using the String.Chars protocol.

```elixir
iex> to_string(Decimal.new("1.00"))
"1.00"copy
```

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

### Decimal Greater Than or Equal To Comparison

Source: https://hexdocs.pm/decimal_arithmetic/DecimalArithmetic.html

Compares decimal numbers using the greater than or equal to operator (`>=`). Examples include comparing a number to a Decimal, a Decimal to a number, and two Decimals.

```elixir
iex> 3 >= ~m(2)
true
iex> ~m(3) >= 3
true
iex> ~m(2.20) >= ~m(2.21)
false
```

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

### Decimal Operation with Context and Type Casting

Source: https://hexdocs.pm/decimal_env/index.html

Shows how to specify precision, rounding, and the output type for a decimal operation. The result is cast to an integer.

```elixir
iex(1)> import DecimalEnv
iex(2)> decimal context: [precision: 2, rounding: :ceiling], as: :integer do
...(2)>   21.1 + 20
...(2)> end
42
```

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

### Inspect Decimal Value

Source: https://hexdocs.pm/decimal/Decimal.html

Demonstrates how to inspect a Decimal value using the Inspect protocol.

```elixir
iex> inspect(Decimal.new("1.00"))
"Decimal.new(\"1.00\")"copy
```

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

### new(sign, coef, exp)

Source: https://hexdocs.pm/decimal/Decimal.html

Creates a new decimal number from its sign, coefficient, and exponent.

```APIDOC
## new(sign, coef, exp)

### Description
Creates a new decimal number from the sign, coefficient and exponent such that the number will be: `sign * coefficient * 10 ^ exponent`.

### Parameters
#### Path Parameters
- **sign** (Integer) - The sign of the number (-1 or 1).
- **coef** (Integer) - The coefficient.
- **exp** (Integer) - The exponent.
```

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

### Get Scale of Decimal

Source: https://hexdocs.pm/decimal/Decimal.html

Returns the scale of a Decimal number, which is the count of digits after the decimal point, including trailing zeros. Use `normalize/1` to remove trailing zeros before checking the scale.

```Elixir
iex> Decimal.scale(Decimal.new("42"))
0

iex> Decimal.scale(Decimal.new(1, 2, 26))
0

iex> Decimal.scale(Decimal.new("99.12345"))
5

iex> Decimal.scale(Decimal.new("1.50"))
2
```

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

### Run Block with Decimal Environment

Source: https://hexdocs.pm/decimal_env/DecimalEnv.html

Encapsulates a block of code to run under the Decimal environment. All numeric values within the block are converted to Decimal. Supports specifying output type and Decimal context.

```Elixir
import DecimalEnv
decimal do: 42.42
```

```Elixir
import DecimalEnv
decimal do: 84.0 - 21 - "21"
```

```Elixir
import DecimalEnv
decimal as: :scientific do
  "0.0000000002" + 0.000000004
end
```

```Elixir
import DecimalEnv
decimal context: [precision: 2, rounding: :ceiling], as: :integer do
  21.1 + 20
end
```

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

### Set Context and Observe Flags

Source: https://hexdocs.pm/decimal/index.html

Sets the context to floor rounding and precision 2, then performs a division. Observes the flags and rounded result. This is useful for understanding how inexact and rounded flags are signaled when precision is limited.

```iex
iex> D.Context.set(%D.Context{D.Context.get() | rounding: :floor, precision: 2})
:ok

iex> D.Context.get().traps
[:invalid_operation, :division_by_zero]

iex> D.Context.get().flags
[]

iex> D.div(31, 2)
Decimal.new("15")

iex> D.Context.get().flags
[:inexact, :rounded]
```

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

### Adding DecimalEnv Dependency

Source: https://hexdocs.pm/decimal_env/index.html

Specifies how to add the DecimalEnv library as a dependency in a Mix project's mix.exs file.

```elixir
def deps do
  [{:decimal_env, "~> 1.0"}]
end
```

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

### Create Decimal from Sign, Coefficient, and Exponent

Source: https://hexdocs.pm/decimal/Decimal.html

Creates a new decimal number using the formula: `sign * coefficient * 10 ^ exponent`. The number is created exactly as specified without rounding.

```Elixir
iex> Decimal.new(1, 42, 0)
Decimal.new("42")
```

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

### Add Decimal Dependency

Source: https://hexdocs.pm/decimal/index.html

Add the Decimal library as a dependency in your `mix.exs` file to use it in your Elixir project.

```Elixir
def deps do
  [{:decimal, "~> 2.0"}]
end
```

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

### Temporarily Set Decimal Context

Source: https://hexdocs.pm/decimal/index.html

Use `Decimal.Context.with/2` to temporarily set a specific context for a block of code and inspect it.

```Elixir
iex> D.Context.with(%D.Context{precision: 2}, fn -> IO.inspect D.Context.get() end)
%Decimal.Context{
  precision: 2,
  rounding: :half_up,
  emax: :infinity,
  emin: :infinity,
  flags: [],
  traps: [:invalid_operation, :division_by_zero]
}
%Decimal.Context{
  precision: 2,
  rounding: :half_up,
  emax: :infinity,
  emin: :infinity,
  flags: [],
  traps: [:invalid_operation, :division_by_zero]
}
```

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

### Create Decimal from Float

Source: https://hexdocs.pm/decimal/Decimal.html

Converts a floating-point number to a decimal. Note potential inaccuracies due to binary representation; prefer `new/1` for precision.

```Elixir
iex> Decimal.from_float(3.14)
Decimal.new("3.14")
```

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

### parse(binary, opts)

Source: https://hexdocs.pm/decimal/Decimal.html

Parses a binary representation into a decimal number with explicit limits.

```APIDOC
## parse(binary, opts)

### Description
Parses a binary into a decimal with explicit limits.

### Parameters
#### Path Parameters
- **binary** (Binary) - The binary string to parse.
- **opts** (KeywordList) - Options for parsing limits.
```

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

### Bounded Decimal Output

Source: https://hexdocs.pm/decimal/index.html

Use bounded output formatting to control the representation of decimals, especially when rendering to formats that might expand exponents.

```Elixir
Decimal.to_string(decimal, :normal, max_digits: 1000)
Decimal.to_string(decimal, :xsd, max_digits: 1000)
```

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

### apply_context

Source: https://hexdocs.pm/decimal/Decimal.html

Applies the context to a given decimal number, rounding it to the specified precision. Available since version 1.9.0.

```APIDOC
## apply_context(num)

### Description
Applies the context to the given number rounding it to specified precision.

### Function Signature
```
@spec apply_context(t()) :: t()
```

### Version
(since 1.9.0)
```

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

### apply_context(num)

Source: https://hexdocs.pm/decimal/Decimal.html

Applies the context to the given number, rounding it to the specified precision.

```APIDOC
## apply_context(num)

### Description
Applies the context to the given number rounding it to specified precision.

### Parameters
#### Path Parameters
- **num** (Decimal) - The number to apply context to.
```

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

### Decimal Division

Source: https://hexdocs.pm/decimal_arithmetic/DecimalArithmetic.html

Demonstrates dividing a Decimal by a standard number, resulting in a Decimal. Also shows division between two standard numbers.

```elixir
iex> ~m(3) / 4
#Decimal<0.75>
iex> 3 / 4
0.75
```

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

### Decimal Addition

Source: https://hexdocs.pm/decimal_arithmetic/DecimalArithmetic.html

Illustrates adding a standard number to a Decimal, resulting in a Decimal. Also shows addition between two standard numbers.

```elixir
iex> ~m(1) + 3.1415
#Decimal<4.1415>
iex> 1 + 3
4
```

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

### new(num)

Source: https://hexdocs.pm/decimal/Decimal.html

Creates a new decimal number from an integer or a string representation.

```APIDOC
## new(num)

### Description
Creates a new decimal number from an integer or a string representation.

### Parameters
#### Path Parameters
- **num** (Integer | String) - The value to create a Decimal from.
```

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

### add

Source: https://hexdocs.pm/decimal/Decimal.html

Adds two decimal numbers together. Handles potential exceptional conditions like adding infinities.

```APIDOC
## add(num1, num2)

### Description
Adds two numbers together.

### Function Signature
```
@spec add(decimal(), decimal()) :: t()
```

### Exceptional conditions
* If one number is -Infinity and the other +Infinity, `:invalid_operation` will be signalled.

### Examples
```
iex> Decimal.add(1, "1.1")
Decimal.new("2.1")

iex> Decimal.add(1, "Inf")
Decimal.new("Infinity")
```
```

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

### Bounded Decimal Parsing and Casting

Source: https://hexdocs.pm/decimal/index.html

Use bounded parsing and casting for untrusted input to prevent excessive memory or CPU usage from large exponents.

```Elixir
Decimal.parse(input, max_digits: 100, max_exponent: 1000)
Decimal.cast(input, max_digits: 100, max_exponent: 1000)
```

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

### Convert Decimal to String (Raw Format)

Source: https://hexdocs.pm/decimal/Decimal.html

Converts a Decimal to its raw, internal string format. The output is bounded by default.

```elixir
iex> Decimal.to_string(Decimal.new("4321.768"), :raw)
"4321768E-3"copy
```

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

### to_string (with type and opts)

Source: https://hexdocs.pm/decimal/Decimal.html

Converts a Decimal number to its string representation with explicit limits using the `:max_digits` option. This allows for fine-grained control over the output length.

```APIDOC
## to_string(num, type, opts)

### Description
Converts the given number to its string representation with explicit limits.

### Method
`Decimal.to_string/3`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
* **num** (Decimal.t()) - The Decimal number to convert.
* **type** (:scientific | :normal | :xsd | :raw) - The format for the string representation.
* **opts** ([to_string_option()]) - A list of options to control the conversion.
  * `:max_digits` - Maximum number of digit characters in the output. Defaults to `6178`. Pass `:infinity` to disable.

### Request Example
```elixir
# Example with max_digits
Decimal.to_string(Decimal.new("123456789"), :normal, max_digits: 5)
```

### Response
#### Success Response
- **String.t()** - The string representation of the decimal.

#### Response Example
```elixir
# Example response (assuming input allows for it)
"12345"
```

ERROR HANDLING:
- **ArgumentError**: Raised when the configured limit would be exceeded.
```

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

### Calculating Mean with DecimalEnv

Source: https://hexdocs.pm/decimal_env/index.html

Calculates the mean of a list of numbers, outputting the result as a float. Imports DecimalEnv and uses the decimal macro for the calculation.

```elixir
iex(1)> import DecimalEnv
iex(2)> decimal as: :float do
...(2)>   values = [1,2,3,4]
...(2)>   amount = length(values)
...(2)>
...(2)>   Enum.reduce(values, 0, &(&1 + &2)) / amount
...(2)> end
2.5
```

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

### to_string (with type)

Source: https://hexdocs.pm/decimal/Decimal.html

Converts a Decimal number to its string representation using a specified type. Supports :scientific, :normal, :xsd, and :raw formats. Output is bounded by default, with :normal and :xsd potentially raising an error if the limit is exceeded.

```APIDOC
## to_string(num, type)

### Description
Converts the given number to its string representation based on the specified type.

### Method
`Decimal.to_string/2`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
* **num** (Decimal.t()) - The Decimal number to convert.
* **type** (:scientific | :normal | :xsd | :raw) - The format for the string representation.
  * `:scientific` - Number converted to scientific notation.
  * `:normal` - Number converted without an exponent.
  * `:xsd` - Number converted to the canonical XSD representation.
  * `:raw` - Number converted to its raw, internal format.

### Request Example
```elixir
Decimal.to_string(Decimal.new("1.00"))
Decimal.to_string(Decimal.new("123e1"), :scientific)
Decimal.to_string(Decimal.new("42.42"), :normal)
Decimal.to_string(Decimal.new("1.00"), :xsd)
Decimal.to_string(Decimal.new("4321.768"), :raw)
```

### Response
#### Success Response
- **String.t()** - The string representation of the decimal.

#### Response Example
```elixir
"1.00"
"1.23E+3"
"42.42"
"1.0"
"4321768E-3"
```

ERROR HANDLING:
- **ArgumentError**: Raised by `:normal` and `:xsd` types if the output exceeds the default digit limit.
```

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

### Decimal Comparison: Less Than or Equal To

Source: https://hexdocs.pm/decimal_env/DecimalEnv.Operators.html

Compares two numbers to check if the first is less than or equal to the second. Supports strings, integers, and floats.

```elixir
iex> use DecimalEnv.Operators
iex> "41" <= "42"
true
iex> 41 <= 42
true
iex> 41.0 <= 42.0
true
iex> 41.0 <= "42.0"
true
iex> 42 <= 42
true
iex> 42 <= 41
false
```

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

### Convert Decimal to String (Normal Notation)

Source: https://hexdocs.pm/decimal/Decimal.html

Converts a Decimal to its string representation without an exponent. The output is bounded by default.

```elixir
iex> Decimal.to_string(Decimal.new("42.42"), :normal)
"42.42"
```

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

### Apply Context to Decimal

Source: https://hexdocs.pm/decimal/Decimal.html

Applies the current context to a decimal number, rounding it to the specified precision. Available since version 1.9.0.

```Elixir
@spec apply_context(t()) :: t()
```

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

### min(a, b)

Source: https://hexdocs.pm/decimal_env/DecimalEnv.Operators.html

Compares two values numerically and returns the minimum of the two.

```APIDOC
## min(a, b)

### Description
Compares two values numerically and returns the minimum of the two.

### Method
`min` (Function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Response
#### Success Response
- `Decimal.t()`: The minimum of the two input numbers.

### Examples
```elixir
iex> use DecimalEnv.Operators
iex> min(Decimal.new("10.5"), Decimal.new("5.2")) == Decimal.new("5.2")
true
iex> min(10.5, 5.2) == Decimal.new("5.2")
true
```
```

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

### Create Decimal from Integer or String

Source: https://hexdocs.pm/decimal/Decimal.html

Creates a new decimal number from an integer or its string representation. The number is created exactly as specified without rounding. The BNF grammar for valid numeric strings is provided.

```Elixir
iex> Decimal.new(1)
Decimal.new("1")

iex> Decimal.new("3.14")
Decimal.new("3.14")

iex> Decimal.new("1.79769313486231581e308")
Decimal.new("1.79769313486231581e308")

iex> Decimal.new("2.22507385850720139e-308")
Decimal.new("2.22507385850720139e-308")

iex> Decimal.new("1.01234567890123457890123457890123456789", max_digits: 39)
Decimal.new("1.01234567890123457890123457890123456789", max_digits: 39)
```

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

### Import Decimal Operators

Source: https://hexdocs.pm/decimal_env/DecimalEnv.Operators.html

Imports the Decimal operators, replacing the default Kernel operators. This is typically done at the beginning of a module or script that uses Decimal operations.

```elixir
iex> use DecimalEnv.Operators
```

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

### Convert Decimal to String (XSD Representation)

Source: https://hexdocs.pm/decimal/Decimal.html

Converts a Decimal to its canonical XSD string representation. The output is bounded by default.

```elixir
iex> Decimal.to_string(Decimal.new("1.00"), :xsd)
"1.0"
```

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

### Convert Decimal to String (Scientific Notation)

Source: https://hexdocs.pm/decimal/Decimal.html

Converts a Decimal to its string representation using scientific notation. The output is bounded by default.

```elixir
iex> Decimal.to_string(Decimal.new("1.00"))
"1.00"
```

```elixir
iex> Decimal.to_string(Decimal.new("123e1"), :scientific)
"1.23E+3"
```

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

### round(number, places \\ 0, strategy \\ :half_up)

Source: https://hexdocs.pm/decimal_env/DecimalEnv.Operators.html

Rounds the given number to a specified number of decimal places using a given strategy. Defaults to rounding to the nearest one with :half_up strategy.

```APIDOC
## round(number, places \\ 0, strategy \\ :half_up)

### Description
Rounds the given number to a specified number of decimal places using a given strategy. Defaults to rounding to the nearest one with :half_up strategy.

### Method
`round` (Function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Response
#### Success Response
- `Decimal.t()`: The rounded number.

### Examples
```elixir
iex> use DecimalEnv.Operators
iex> round(Decimal.new("10.55"), 1) == Decimal.new("10.6")
true
iex> round(10.55, 1) == Decimal.new("10.6")
true
iex> round(10.55, 0, :half_down) == Decimal.new("10.5")
true
iex> round(10.55, -1) == Decimal.new("0")
true
```
```

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

### compare

Source: https://hexdocs.pm/decimal/Decimal.html

Compares two decimal numbers numerically. Returns `:lt`, `:eq`, or `:gt`. Neither number can be NaN.

```APIDOC
## compare(num1, num2)

### Description
Compares two numbers numerically. If the first number is greater than the second `:gt` is returned, if less than `:lt` is returned, if both numbers are equal `:eq` is returned. Neither number can be a NaN.

### Function Signature
```
@spec compare(decimal(), decimal()) :: compare_result()
```

### Examples
```
iex> Decimal.compare("1.0", 1)
:eq

iex> Decimal.compare("Inf", -1)
:gt
```
```

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

### Decimal Subtraction

Source: https://hexdocs.pm/decimal_arithmetic/DecimalArithmetic.html

Shows subtracting a Decimal from a standard number, resulting in a Decimal. Also demonstrates subtraction between two standard numbers.

```elixir
iex> 3.19 - ~m(5.45)
#Decimal<-2.26>
iex> 3.20 - 5.45
-2.25
```

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

### Encode Decimal to JSON (Default)

Source: https://hexdocs.pm/decimal/Decimal.html

Illustrates the default JSON encoding behavior for Decimal values, which preserves precision by encoding them as strings. Requires Elixir 1.18+.

```elixir
iex> JSON.encode!(Decimal.new("1.00"))
"\"1.00\""copy
```

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

### compare(n1, n2, threshold)

Source: https://hexdocs.pm/decimal/Decimal.html

Compares two numbers numerically using a threshold for equality.

```APIDOC
## compare(n1, n2, threshold)

### Description
Compares two numbers numerically using a threshold. If the first number added to the threshold is greater than the second number, and the first number subtracted by the threshold is smaller than the second number, then the two numbers are considered equal.

### Parameters
#### Path Parameters
- **n1** (Decimal) - The first number.
- **n2** (Decimal) - The second number.
- **threshold** (Decimal) - The threshold for comparison.
```

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

### Decimal Inequality Comparison

Source: https://hexdocs.pm/decimal_arithmetic/DecimalArithmetic.html

Shows how to check if two decimal numbers are not equal using the `!=` operator. This works for comparing Decimal types with each other or with standard numbers.

```elixir
iex> 3.15 != ~m(3.15)
false
iex> 1.00001 != ~m(1.00002)
true
```

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

### Run Function with Specific Decimal Context

Source: https://hexdocs.pm/decimal/Decimal.Context.html

Executes a given function within a specified Decimal context. The context is restored after the function completes. This function is available since version 1.9.0.

```Elixir
@spec with(t(), (-> x)) :: x when x: var
```

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

### round(num, places \\ 0, mode \\ :half_up)

Source: https://hexdocs.pm/decimal/Decimal.html

Rounds the given number to specified decimal places using a given strategy.

```APIDOC
## round(num, places \\ 0, mode \\ :half_up)

### Description
Rounds the given number to specified decimal places with the given strategy (default is to round to nearest one). If places is negative, at least that many digits to the left of the decimal point will be zero.

### Parameters
#### Path Parameters
- **num** (Decimal) - The number to round.
- **places** (Integer, optional) - The number of decimal places to round to. Defaults to 0.
- **mode** (Symbol, optional) - The rounding strategy (e.g., :half_up). Defaults to :half_up.
```

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

### Equality Check with Threshold

Source: https://hexdocs.pm/decimal/Decimal.html

Compares two decimal numbers for equality within a specified threshold. Useful for approximate comparisons.

```Elixir
iex> Decimal.eq?("1.0", 1, "0")
true
```

```Elixir
iex> Decimal.eq?("1.2", 1, "0.1")
false
```

```Elixir
iex> Decimal.eq?("1.2", 1, "0.2")
true
```

```Elixir
iex> Decimal.eq?(1, -1, "0.0")
false
```

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

### parse/1

Source: https://hexdocs.pm/decimal/Decimal.html

Parses a binary string into a Decimal number. It returns a tuple containing the Decimal and the remainder of the string, or :error if parsing fails or exceeds default limits.

```APIDOC
## parse(binary)

### Description
Parses a binary string into a Decimal number. It returns a tuple containing the Decimal and the remainder of the string, or :error if parsing fails or exceeds default limits. Inputs whose digit count or exponent magnitude exceed the default limits (34 digits, 6144 absolute exponent) return :error. Use `parse/2` to override the limits.

### Function Signature
```elixir
Decimal.parse(binary()) :: {t(), binary()} | :error
```

### Examples
```elixir
iex> Decimal.parse("3.14")
{%Decimal{coef: 314, exp: -2, sign: 1}, ""}

iex> Decimal.parse("3.14.15")
{%Decimal{coef: 314, exp: -2, sign: 1}, ".15"}

iex> Decimal.parse("-1.1e3")
{%Decimal{coef: 11, exp: 2, sign: -1}, ""}

iex> Decimal.parse("bad")
:error
```
```

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

### Compare if Less Than

Source: https://hexdocs.pm/decimal/Decimal.html

Compares two numbers numerically. Returns `true` if the first number is less than the second. Returns `false` if one of the operands is a quiet NaN.

```Elixir
iex> Decimal.lt?("1.1", "1.2")
true

iex> Decimal.lt?("1.4", "1.2")
false
```

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

### Cast to Decimal with Options

Source: https://hexdocs.pm/decimal/Decimal.html

Creates a new decimal number with parsing limits using specified options. Options are the same as for parse/2. Available since version 2.4.0.

```Elixir
@spec cast(term(), [parse_option()]) :: {:ok, t()} | :error
```

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

### parse(binary)

Source: https://hexdocs.pm/decimal/Decimal.html

Parses a binary representation into a decimal number.

```APIDOC
## parse(binary)

### Description
Parses a binary into a decimal.

### Parameters
#### Path Parameters
- **binary** (Binary) - The binary string to parse.
```

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

### cast with options

Source: https://hexdocs.pm/decimal/Decimal.html

Creates a new decimal number from various types with specified parsing limits. Options are the same as `parse/2`. Available since version 2.4.0.

```APIDOC
## cast(term, opts)

### Description
Creates a new decimal number from an integer, string, float, or existing decimal number with parsing limits. Options are the same as `parse/2`.

### Function Signature
```
@spec cast(term(), [parse_option()]) :: {:ok, t()} | :error
```

### Version
(since 2.4.0)
```

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

### Calculate Ceiling Value

Source: https://hexdocs.pm/decimal_env/DecimalEnv.Operators.html

Returns the smallest number that is greater than or equal to the input number. Useful for rounding up to the nearest whole number.

```elixir
iex> use DecimalEnv.Operators
iex> ceil(42) == Decimal.new("42")
true
iex> ceil("41.1") == Decimal.new("42")
true
iex> ceil(41.1) == Decimal.new("42")
true
```

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

### a + b

Source: https://hexdocs.pm/decimal_env/DecimalEnv.Operators.html

Performs arithmetic addition between two numbers, returning the result as a Decimal.

```APIDOC
## a + b

### Description
Performs arithmetic addition between two numbers, returning the result as a Decimal.

### Method
`+` (Operator)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Response
#### Success Response
- `Decimal.t()`: The result of the addition.

### Examples
```elixir
iex> use DecimalEnv.Operators
iex> "21" + "21" == Decimal.new("42")
true
iex> 21 + 21 == Decimal.new("42")
true
iex> 21.0 + 21.0 == Decimal.new("42")
true
iex> 21.0 + "21.0" == Decimal.new("42")
true
```
```

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

### Decimal.from_float/1

Source: https://hexdocs.pm/decimal/Decimal.html

Creates a new decimal number from a floating-point number. Note that due to the nature of floating-point representation, this conversion may not be exact.

```APIDOC
## Decimal.from_float/1

### Description
Creates a new decimal number from a floating-point number. Note that due to the nature of floating-point representation, this conversion may not be exact.

### Method
`Decimal.from_float(float)`

### Parameters
* `float` (float): The floating-point number to convert.

### Examples
```
iex> Decimal.from_float(3.14)
Decimal.new("3.14")
```

### Warning
Floating point numbers use a fixed number of binary digits to represent a decimal number which has inherent inaccuracy as some decimal numbers cannot be represented exactly in limited precision binary. Floating point numbers will be converted to decimal numbers with `:io_lib_format.fwrite_g/1`. Since this conversion is not exact and because of inherent inaccuracy mentioned above, we may run into counter-intuitive results:
```
iex> Enum.reduce([0.1, 0.1, 0.1], &+/2)
0.30000000000000004

iex> Enum.reduce([Decimal.new("0.1"), Decimal.new("0.1"), Decimal.new("0.1")], &Decimal.add/2)
Decimal.new("0.3")
```
For this reason, it's recommended to build decimals with `new/1`, which is always precise, instead.
```

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

### Decimal Comparison: Equal To

Source: https://hexdocs.pm/decimal_env/DecimalEnv.Operators.html

Checks if two numbers are equal. Supports various input types including strings, integers, and floats.

```elixir
iex> use DecimalEnv.Operators
iex> "42" == "42"
true
iex> 42 == 42
true
iex> 42.0 == 42.0
true
iex> 42.0 == "42.0"
true
iex> 42 == 41
false
```

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

### Compare Two Decimals with Threshold

Source: https://hexdocs.pm/decimal/Decimal.html

Compares two numbers numerically using a threshold. Numbers are considered equal if the first plus the threshold is greater than the second, and the first minus the threshold is less than the second.

```Elixir
@spec compare(decimal :: decimal(), decimal :: decimal(), threshold :: decimal()) ::
  compare_result()
```

```Elixir
iex> Decimal.compare("1.1", 1, "0.2")
:eq
```

```Elixir
iex> Decimal.compare("1.2", 1, "0.1")
:gt
```

```Elixir
iex> Decimal.compare("1.0", "1.2", "0.1")
:lt
```

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

### from_float(float)

Source: https://hexdocs.pm/decimal/Decimal.html

Creates a new decimal number from a floating-point number.

```APIDOC
## from_float(float)

### Description
Creates a new decimal number from a floating point number.

### Parameters
#### Path Parameters
- **float** (Float) - The float to convert to a Decimal.
```

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

### Compare if Less Than or Equal To

Source: https://hexdocs.pm/decimal/Decimal.html

Compares two numbers numerically. Returns `true` if the first number is less than or equal to the second. Returns `false` if one of the operands is a quiet NaN.

```Elixir
iex> Decimal.lte?("1.1", "1.1")
true

iex> Decimal.lte?("1.1", "1.2")
true

iex> Decimal.lte?("1.4", "1.2")
false
```

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

### Decimal Multiplication

Source: https://hexdocs.pm/decimal_arithmetic/DecimalArithmetic.html

Demonstrates multiplying a standard number with a Decimal type. The result is a Decimal.

```elixir
iex> 7 * ~m(2.33)
#Decimal<16.31>
```

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

### equal?(num1, num2)

Source: https://hexdocs.pm/decimal/Decimal.html

Compares two numbers numerically for equality. Returns true if they are equal, false otherwise. Returns false if either operand is NaN.

```APIDOC
## equal?(num1, num2)

### Description
Compares two numbers numerically and returns `true` if they are equal, otherwise `false`. If one of the operands is a quiet NaN this operation will always return `false`.

### Parameters
#### Path Parameters
- **num1** (Decimal) - The first number.
- **num2** (Decimal) - The second number.

### Returns
`true` if the numbers are equal, `false` otherwise.
```

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

### Decimal Context Type Definition

Source: https://hexdocs.pm/decimal/Decimal.Context.html

Defines the structure of a Decimal context, including fields for exponent limits, flags, precision, rounding algorithm, and traps.

```Elixir
@type t() :: %Decimal.Context{
emax: integer() | :infinity,
emin: integer() | :infinity,
flags: [Decimal.signal()],
precision: pos_integer(),
rounding: Decimal.rounding(),
traps: [Decimal.signal()]
}
```

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

### Cast to Decimal

Source: https://hexdocs.pm/decimal/Decimal.html

Creates a new decimal number from an integer, string, float, or existing decimal. Returns :error for invalid input. Note: Conversion from float is inexact; use new/1 or from_float/1 for certainty.

```Elixir
@spec cast(term()) :: {:ok, t()} | :error
```

```Elixir
iex> {:ok, decimal} = Decimal.cast(3)
iex> decimal
Decimal.new("3")
```

```Elixir
iex> Decimal.cast("bad")
:error
```

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

### Parse Binary String to Decimal

Source: https://hexdocs.pm/decimal/Decimal.html

Parses a binary string into a Decimal number. Returns a tuple of the Decimal and the remainder of the string, or :error if parsing fails or exceeds default limits.

```Elixir
iex> Decimal.parse("3.14")
{%Decimal{coef: 314, exp: -2, sign: 1}, ""}

iex> Decimal.parse("3.14.15")
{%Decimal{coef: 314, exp: -2, sign: 1}, ".15"}

iex> Decimal.parse("-1.1e3")
{%Decimal{coef: 11, exp: 2, sign: -1}, ""}

iex> Decimal.parse("bad")
:error
```

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

### eq?(num1, num2, threshold)

Source: https://hexdocs.pm/decimal/Decimal.html

Compares two numbers for equality within a given threshold. Returns true if the second number is within the range [num1 - threshold, num1 + threshold].

```APIDOC
## eq?(num1, num2, threshold)

### Description
It compares the equality of two numbers. If the second number is within the range of first - threshold and first + threshold, it returns true; otherwise, it returns false.

### Parameters
#### Path Parameters
- **num1** (Decimal) - The first number.
- **num2** (Decimal) - The second number.
- **threshold** (Decimal) - The tolerance for equality.
```

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

### inf()

Source: https://hexdocs.pm/decimal_env/DecimalEnv.Operators.html

Generates an infinity value.

```APIDOC
## inf()

### Description
Generates an infinity value.

### Method
`inf` (Function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Response
#### Success Response
- `Decimal.t()`: An infinity value.

### Examples
```elixir
iex> use DecimalEnv.Operators
iex> inf()
Infinity
```
```

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

### Division Operator (/)

Source: https://hexdocs.pm/decimal_env/DecimalEnv.Operators.html

Performs arithmetic division. Accepts various input types and returns a Decimal.

```Elixir
iex> use DecimalEnv.Operators
iex> "84" / "2" == Decimal.new("42")
true
iex> 84 / 2 == Decimal.new("42")
true
iex> 84.0 / 2.0 == Decimal.new("42")
true
iex> 84.0 / "2.0" == Decimal.new("42")
true
```

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

### Addition Operator (+)

Source: https://hexdocs.pm/decimal_env/DecimalEnv.Operators.html

Performs arithmetic addition. Accepts various input types and returns a Decimal.

```Elixir
iex> use DecimalEnv.Operators
iex> "21" + "21" == Decimal.new("42")
true
iex> 21 + 21 == Decimal.new("42")
true
iex> 21.0 + 21.0 == Decimal.new("42")
true
iex> 21.0 + "21.0" == Decimal.new("42")
true
```

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

### to_float(decimal)

Source: https://hexdocs.pm/decimal/Decimal.html

Converts a decimal number to a floating-point number.

```APIDOC
## to_float(decimal)

### Description
Returns the decimal converted to a float.

### Parameters
#### Path Parameters
- **decimal** (Decimal) - The decimal number to convert.
```

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

### Decimal.eq?/3

Source: https://hexdocs.pm/decimal/Decimal.html

Compares two decimal numbers for equality within a given threshold. Returns `true` if the second number is within the range of the first number plus or minus the threshold, `false` otherwise.

```APIDOC
## Decimal.eq?/3

### Description
Compares two decimal numbers for equality within a given threshold. Returns `true` if the second number is within the range of the first number plus or minus the threshold, `false` otherwise.

### Method
`Decimal.eq?(decimal, decimal, threshold)`

### Parameters
* `decimal` (decimal): The first number.
* `decimal` (decimal): The second number.
* `threshold` (decimal): The tolerance for equality.

### Request Example
```
iex> Decimal.eq?("1.0", 1, "0")
true

iex> Decimal.eq?("1.2", 1, "0.1")
false

iex> Decimal.eq?("1.2", 1, "0.2")
true

iex> Decimal.eq?(1, -1, "0.0")
false
```
```

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

### Enable Inexact Trap and Observe Error

Source: https://hexdocs.pm/decimal/index.html

Enables the :inexact trap enabler and performs a division that results in an inexact value. This demonstrates how Decimal.Error is raised when an inexact signal's trap enabler is set.

```iex
iex> D.Context.set(%D.Context{D.Context.get() | traps: D.Context.get().traps ++ [:inexact]})
:ok

iex> D.div(31, 2)
** (Decimal.Error)
```

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

### compare(num1, num2)

Source: https://hexdocs.pm/decimal/Decimal.html

Compares two numbers numerically. Returns :gt, :lt, or :eq based on their relationship.

```APIDOC
## compare(num1, num2)

### Description
Compares two numbers numerically. If the first number is greater than the second `:gt` is returned, if less than `:lt` is returned, if both numbers are equal `:eq` is returned.

### Parameters
#### Path Parameters
- **num1** (Decimal) - The first number.
- **num2** (Decimal) - The second number.

### Returns
- `:gt` if num1 > num2
- `:lt` if num1 < num2
- `:eq` if num1 == num2
```
Tokens:
Raw