# Exponential

Exp is a struct which stores decimals with a fixed precision of 18 decimal places.\
Thus, if we wanted to store the 5.1, mantissa would store 5.1e18. That is:`Exp({mantissa: 5100000000000000000})`.

*Legacy contract for compatibility reasons with existing contracts that still use MathError*

## getExp

```solidity
function getExp(uint256 num, uint256 denom) internal pure returns (enum CarefulMath.MathError, struct ExponentialNoError.Exp)
```

*Creates an exponential from numerator and denominator values.*\
*Note: Returns an error if (`num` \* 10e18) > MAX\_INT,*\
*or if `denom` is zero.*

## addExp

```solidity
function addExp(struct ExponentialNoError.Exp a, struct ExponentialNoError.Exp b) internal pure returns (enum CarefulMath.MathError, struct ExponentialNoError.Exp)
```

*Adds two exponentials, returning a new exponential.*

## subExp

```solidity
function subExp(struct ExponentialNoError.Exp a, struct ExponentialNoError.Exp b) internal pure returns (enum CarefulMath.MathError, struct ExponentialNoError.Exp)
```

*Subtracts two exponentials, returning a new exponential.*

## mulScalar

```solidity
function mulScalar(struct ExponentialNoError.Exp a, uint256 scalar) internal pure returns (enum CarefulMath.MathError, struct ExponentialNoError.Exp)
```

*Multiply an Exp by a scalar, returning a new Exp.*

## mulScalarTruncate

```solidity
function mulScalarTruncate(struct ExponentialNoError.Exp a, uint256 scalar) internal pure returns (enum CarefulMath.MathError, uint256)
```

*Multiply an Exp by a scalar, then truncate to return an unsigned integer.*

## mulScalarTruncateAddUInt

```solidity
function mulScalarTruncateAddUInt(struct ExponentialNoError.Exp a, uint256 scalar, uint256 addend) internal pure returns (enum CarefulMath.MathError, uint256)
```

*Multiply an Exp by a scalar, truncate, then add an to an unsigned integer, returning an unsigned integer.*

## divScalar

```solidity
function divScalar(struct ExponentialNoError.Exp a, uint256 scalar) internal pure returns (enum CarefulMath.MathError, struct ExponentialNoError.Exp)
```

*Divide an Exp by a scalar, returning a new Exp.*

## divScalarByExp

```solidity
function divScalarByExp(uint256 scalar, struct ExponentialNoError.Exp divisor) internal pure returns (enum CarefulMath.MathError, struct ExponentialNoError.Exp)
```

*Divide a scalar by an Exp, returning a new Exp.*

## divScalarByExpTruncate

```solidity
function divScalarByExpTruncate(uint256 scalar, struct ExponentialNoError.Exp divisor) internal pure returns (enum CarefulMath.MathError, uint256)
```

*Divide a scalar by an Exp, then truncate to return an unsigned integer.*

## mulExp

```solidity
function mulExp(struct ExponentialNoError.Exp a, struct ExponentialNoError.Exp b) internal pure returns (enum CarefulMath.MathError, struct ExponentialNoError.Exp)
```

*Multiplies two exponentials, returning a new exponential.*

## mulExp

```solidity
function mulExp(uint256 a, uint256 b) internal pure returns (enum CarefulMath.MathError, struct ExponentialNoError.Exp)
```

*Multiplies two exponentials given their mantissas, returning a new exponential.*

## mulExp3

```solidity
function mulExp3(struct ExponentialNoError.Exp a, struct ExponentialNoError.Exp b, struct ExponentialNoError.Exp c) internal pure returns (enum CarefulMath.MathError, struct ExponentialNoError.Exp)
```

*Multiplies three exponentials, returning a new exponential.*

## divExp

```solidity
function divExp(struct ExponentialNoError.Exp a, struct ExponentialNoError.Exp b) internal pure returns (enum CarefulMath.MathError, struct ExponentialNoError.Exp)
```

*Divides two exponentials, returning a new exponential.*\
*(a/scale) / (b/scale) = (a/scale) \* (scale/b) = a/b,*\
*which we can scale as an Exp by calling getExp(a.mantissa, b.mantissa)*


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.mangrove.exchange/dev/strat-lib/technical-references/api-preferences/strats/src/strategies/vendor/compound/exponential.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.