# Fixed Point 64

A library to perform math operations over an unsigned integer with 64-bit precision. Any operation that results in a number larger than the maximum unsigned 128 bit, will be considered an overflow and throw.

## Structs

### <mark style="color:blue;">**FixedPoint64**</mark>

```rust
struct FixedPoint64 has copy, drop, store { value: u128 }
```

* **value** - The number.

## Interface

### <mark style="color:blue;">value</mark>

**It returns the raw u128 value.**

```rust
public fun value(self: FixedPoint64): u128
```

* **@param self:** A FixedPoint64
* **@return u128.** The raw u128 value.

### <mark style="color:blue;">from</mark>

**Creates a FixedPoint64 from a u128 number. It scales the number.**

```rust
public fun from(value: u128): FixedPoint64
```

* **@param value:** A u128 number.
* **@return A FixedPoint64.** calculated by right shifting - `value` << 64.

**Aborts**

* The left-shifted `value` is larger than `MAX_U128`.

### <mark style="color:blue;">from\_raw\_value</mark>

**Creates a FixedPoint64 from a u128 `value`. It does not scale the `value`.**

```rust
public fun from_raw_value(value: u128): FixedPoint64
```

* **@param value:** A u128 number.
* **@return FixedPoint64.** It wraps the u128.

### <mark style="color:blue;">from\_rational</mark>

**Creates a FixedPoint64 from a rational number specified by a `numerator` and`denominator`.**

{% hint style="warning" %}
0.0125 will round down to 0.012 instead of up to 0.013.
{% endhint %}

```rust
public fun from_rational(numerator: u128, denominator: u128): FixedPoint64
```

* **@param numerator:** The numerator of the rational number.
* **@param denominator:** The denominator of the rational number.
* **@return FixedPoint64.** A FixedPoint64 from (`numerator` << 64) / `denominator.`

**Aborts**

* if the denominator is zero
* if the numerator / denominator is zero
* if the numerator is nonzero and the ratio is not in the range 2^-64 .. 2^64-1

### <mark style="color:blue;">to\_u128</mark>

**Converts a FixedPoint64 into a u128 number to the closest integer.**

```rust
public fun to_u128(self: FixedPoint64): u128
```

* **@param self.** A FixedPoint64.
* **@return u128.**

### <mark style="color:blue;">to\_u128\_down</mark>

**Converts a FixedPoint64 into a u128 number rounding down.**

```rust
public fun to_u128_down(self: FixedPoint64): u128
```

* **@param self.** A FixedPoint64.
* **@return u128.**

### <mark style="color:blue;">to\_u128\_up</mark>

**Converts a FixedPoint64 into a u128 number rounding up.**

```rust
public fun to_u128_up(self: FixedPoint64): u128
```

* **@param self.** A FixedPoint64.
* **@return u128.**

### <mark style="color:blue;">is\_zero</mark>

**Checks if `self` is zero.**

```rust
public fun is_zero(self: FixedPoint64): bool
```

* **@param self.** A FixedPoint64.
* **@return bool.** If the `self.value` is zero.

### <mark style="color:blue;">eq</mark>

**Checks if `x` is equal to `y`.**

```rust
public fun eq(x: FixedPoint64, y: FixedPoint64): bool
```

* **@param x:** A FixedPoint64.
* **@param y:** A FixedPoint64.
* **@return bool**. If the values are equal.

### <mark style="color:blue;">lt</mark>

**Checks if `x` is smaller or equal to `y`.**

```rust
public fun lt(x: FixedPoint64, y: FixedPoint64): bool
```

* **@param x:** A FixedPoint64.
* **@param y:** A FixedPoint64.
* **@return bool.** If `x` is smaller than `y`.

### <mark style="color:blue;">gt</mark>

**Checks if `x` is bigger than `y`.**

```rust
public fun gt(x: FixedPoint64, y: FixedPoint64): bool
```

* **@param x:** A FixedPoint64.
* **@param y:** A FixedPoint64.
* **@return bool.** If `x` is bigger or equal to `y`.

### <mark style="color:blue;">lte</mark>

**Checks if `x` is smaller or equal to `y`.**

```rust
public fun lte(x: FixedPoint64, y: FixedPoint64): bool
```

* **@param x:** A FixedPoint64.
* **@param y:** A FixedPoint64.
* **@return bool.** If `x` is smaller or equal to `y`.

### <mark style="color:blue;">gte</mark>

**Checks if `x` is bigger or equal to `y`.**

```rust
public fun gte(x: FixedPoint64, y: FixedPoint64): bool
```

* **@param x:** A FixedPoint64.
* **@param y:** A FixedPoint64.
* **@return bool.** If `x` is bigger or equal to `y`.

### <mark style="color:blue;">max</mark>

**It returns the larger of the two arguments.**

```rust
public fun max(x: FixedPoint64, y: FixedPoint64): FixedPoint64
```

* **@param x:** The first operand.
* **@param y:** The second operand.
* **@return FixedPoint64**. The larger argument.

### <mark style="color:blue;">min</mark>

**It returns the smaller of the two arguments.**

```rust
public fun min(x: FixedPoint64, y: FixedPoint64): FixedPoint64
```

* **@param x:** The first operand.
* **@param y:** The second operand.
* **@return FixedPoint64**. The smaller argument.

### <mark style="color:blue;">sub</mark>

**It returns `x` - `y`.**

```rust
public fun sub(x: FixedPoint64, y: FixedPoint64): FixedPoint64
```

* **@param x:** The first operand.
* **@param y:** The second operand.
* **@return FixedPoint64**. The result of `x` - `y`.

**Aborts**

* `y` > `x`

### <mark style="color:blue;">add</mark>

**It returns `x` + `y`.**

```rust
public fun add(x: FixedPoint64, y: FixedPoint64): FixedPoint64
```

* **@param x:** The first operand.
* **@param y:** The second operand.
* **@return FixedPoint64**. The result of `x` + `y`.

**Aborts**

* `y` + `x` >= `MAX_U128`

### <mark style="color:blue;">mul</mark>

**It returns `x` \* `y`.**

{% hint style="warning" %}
Use {mul\_128} if you think the values can overflow.
{% endhint %}

```rust
public fun mul(x: FixedPoint64, y: FixedPoint64): FixedPoint64
```

* **@param x:** The first operand.
* **@param y:** The second operand.
* **@return FixedPoint64**. The result of `x` \* `y`.

**Aborts**

* inner values overflow.

### <mark style="color:blue;">div</mark>

**It returns `x` / `y`.**

```rust
public fun div(x: FixedPoint64, y: FixedPoint64): FixedPoint64
```

* **@param x:** The first operand.
* **@param y:** The second operand.
* **@return FixedPoint64**. The result of `x` / `y`.

**Aborts**

* if `y` is zero.

### <mark style="color:blue;">mul\_div</mark>

**Specialized function for `x` \* `y` / `z` that omits intermediate shifting.**

```rust
public fun mul_div(x: FixedPoint64, y: FixedPoint64, z: FixedPoint64): FixedPoint64
```

* **@param x:** A FixedPoint64.
* **@param y:** A FixedPoint64.
* **@param z:** The third operand.
* **@return FixedPoint64**. The result of `x` \* `y` / `z`.

**Aborts**

* if z is zero.

### <mark style="color:blue;">mul\_u128</mark>

It returns `x` \* `y.`It multiplies a u128 number with a FixedPoint64. **It truncates the fractional part of the product. E.g. - 9 \* 0.333 = 2.**

```rust
public fun mul_u128(x: u128, y: FixedPoint64): u128
```

* **@param x:** A FixedPoint64.
* **@param y:** A FixedPoint64.
* **@return u128.** The result of `x` \* `y` without the 64-bit precision.

**Aborts**

* if the result is larger or equal to `MAX_U128`.

### <mark style="color:blue;">div\_down\_u128</mark>

**It returns `numerator` / `denominator` rounded down. It divides a FixedPoint64 by a u128 number.**

```rust
public fun div_down_u128(numerator: u128, denominator: FixedPoint64): u128
```

* **@param numerator:** The first operand, a u128 number.
* **@param denominator:** The first operand, a u128 number.
* **@return u128.** The result of `numerator` / `denominator` without the 64-bit precision.

**Aborts**

* if the result is larger or equal to `MAX_U128`.
* if the `denominator` is zero.

### <mark style="color:blue;">div\_up\_u128</mark>

**It returns `numerator` / `denominator` rounded up. It divides a FixedPoint64 by a u128 number.**

```rust
public fun div_up_u128(numerator: u128, denominator: FixedPoint64): u128
```

* **@param numerator:** The first operand, a u128 number.
* **@param denominator:** The first operand, a u128 number.
* **@return u128.** The result of `numerator` / `denominator` without the 64-bit precision.

**Aborts**

* if the result is larger or equal to `MAX_U128`.
* if the `denominator` is zero.

### <mark style="color:blue;">pow</mark>

**It returns `base` \*\* `exponent`.**

```rust
public fun pow(base: FixedPoint64, exponent: u64): FixedPoint64
```

* **@param base**: The base.
* **@param exponent:** The exponent.
* **@return FixedPoint64.** The result of `base` \*\* `exponent`.

**Aborts**

* if the end result is higher than `MAX_U128`.

### <mark style="color:blue;">sqrt</mark>

**Square root of `x`.**

```rust
public fun sqrt(x: FixedPoint64): FixedPoint64
```

* **@param x:** The operand.
* **@return FixedPoint64.** The result of the square root.

### <mark style="color:blue;">exp</mark>

**It performs e^x. Exponent function with a precision of 9 digits.**

```rust
public fun exp(x: FixedPoint64): FixedPoint64
```

* **@param x:** The operand.
* **@return FixedPoint64.** The result of e^x.