PRBMath provides adjacent value types that act as abstractions over lower bit-width integers. These are useful for saving gas when used in structs. Note that these types do not have mathematical functionality; you must unwrap them to a simple integer and then cast them to SD59x18 or UD60x18 to perform math.

| Value Type | Underlying Type |
| ---------- | --------------- |
| `SD1x18`   | int64           |
| `SD21x18`  | int128          |
| `UD2x18`   | uint64          |
| `UD21x18`  | uint128         |

PRBMath's performance relative to ABDKMath depends on the specific mathematical function used.

When to use PRBMath for efficiency: PRBMath is faster than ABDKMath for the following functions:

• abs
• exp
• exp2
• gm
• inv
• ln
• log2

When ABDKMath might be more efficient: ABDKMath is faster for:

• avg
• div
• mul
• powu
• sqrt

Technical Note on Performance: PRBMath's mul and div functions are generally slower than ABDKMath's because PRBMath operates with 256-bit word sizes to account for potential intermediary overflows, whereas ABDKMath operates with 128-bit word sizes.

PRBMath is a collection of free functions rather than a standard Solidity library. It is highly recommended to import specific symbols rather than entire files to avoid duplicate definition errors and issues with static analyzers like Slither. Note that PRBMath requires Solidity v0.8.19 or higher.

pragma solidity >=0.8.19;

// Recommended: Import specific symbols
import { SD59x18 } from "@prb/math/src/SD59x18.sol";
import { UD60x18 } from "@prb/math/src/UD60x18.sol";

// To use helper functions like 'sd' or 'ud', import them explicitly
import { SD59x18, sd } from "@prb/math/src/SD59x18.sol";
import { UD60x18, ud } from "@prb/math/src/UD60x18.sol";

Install PRBMath using your preferred package manager. If you are using Foundry, you must update your remappings.txt file to include the package path.

# Install with Bun
bun add @prb/math

Add to remappings.txt

@prb/math/=node_modules/@prb/math/

PRBMath includes typed assertions designed for use with PRBTest. You can inherit from Assertions to perform equality checks and other assertions directly on SD59x18 or UD60x18 types.

// SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.8.19;

import { UD60x18, ud } from "@prb/math/src/UD60x18.sol";
import { Assertions as PRBMathAssertions } from "@prb/math/test/Assertions.sol";
import { PRBTest } from "@prb/math/src/test/PRBTest.sol";

contract MyTest is PRBTest, PRBMathAssertions {
  function testAdd() external {
    UD60x18 x = ud(1e18);
    UD60x18 y = ud(2e18);
    UD60x18 z = ud(3e18);
    assertEq(x.add(y), z);
  }
}

To contribute to PRBMath, you need to clone the repository with its submodules and install the Node.js dependencies using bun.

Prerequisites:

• Git
• Foundry
• Node.js
• Bun
• Familiarity with Solidity

Steps:

1. Clone the repository including submodules:

   git clone --recurse-submodules -j8 git@github.com:PaulRBerg/prb-math.git

2. Navigate to the project directory and install dependencies:

   bun install

$ git clone --recurse-submodules -j8 git@github.com:PaulRBerg/prb-math.git
$ bun install

Use this method if you prefer Git submodules over Node.js package managers. Use Forge to install the specific release branch and update your remappings.txt.

# Install the submodule using Forge
forge install  PaulRBerg/prb-math@release-v4

Add to remappings.txt

@prb/math/=lib/prb-math/

The UD60x18 type is used for unsigned fixed-point numbers with 18 decimal places. It is more gas-efficient than SD59x18 if negative numbers are not required. Use the ud() function to wrap values.

// SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.8.19;

import { UD60x18, ud } from "@prb/math/src/UD60x18.sol";

contract UnsignedConsumer {
  /// @notice Calculates 5% of the given unsigned number.
  function unsignedPercentage(UD60x18 x) external pure returns (UD60x18 result) {
    UD60x18 fivePercent = ud(0.05e18);
    result = x.mul(fivePercent);
  }

  /// @notice Calculates the binary logarithm of the given unsigned number.
  function unsignedLog2(UD60x18 x) external pure returns (UD60x18 result) {
    result = x.log2();
  }
}

The SD59x18 type is used for signed fixed-point numbers with 18 decimal places. It uses the sd() function to wrap values. It supports advanced mathematical operations like mul, log2, etc.

// SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.8.19;

import { SD59x18, sd } from "@prb/math/src/SD59x18.sol";

contract SignedConsumer {
  /// @notice Calculates 5% of the given signed number.
  function signedPercentage(SD59x18 x) external pure returns (SD59x18 result) {
    SD59x18 fivePercent = sd(0.05e18);
    result = x.mul(fivePercent);
  }

  /// @notice Calculates the binary logarithm of the given signed number.
  function signedLog2(SD59x18 x) external pure returns (SD59x18 result) {
    result = x.log2();
  }
}