Showing preview only (478K chars total). Download the full file or copy to clipboard to get everything.
Repository: hifi-finance/prb-math
Branch: main
Commit: 82e5ed5561d0
Files: 157
Total size: 428.4 KB
Directory structure:
gitextract_hgsxn60y/
├── .editorconfig
├── .github/
│ ├── FUNDING.yml
│ ├── ISSUE_TEMPLATE/
│ │ ├── 1-bug-report.yml
│ │ ├── 2-feature-request.yml
│ │ └── config.yml
│ └── workflows/
│ ├── ci-multibuild.yml
│ ├── ci.yml
│ └── release.yml
├── .gitignore
├── .prettierignore
├── .prettierrc.yml
├── .solhint.json
├── .vscode/
│ └── settings.json
├── CHANGELOG.md
├── CLAUDE.md
├── LICENSE.md
├── README.md
├── SECURITY.md
├── foundry.toml
├── funding.json
├── justfile
├── package.json
├── src/
│ ├── Common.sol
│ ├── SD1x18.sol
│ ├── SD21x18.sol
│ ├── SD59x18.sol
│ ├── UD21x18.sol
│ ├── UD2x18.sol
│ ├── UD60x18.sol
│ ├── casting/
│ │ ├── Uint128.sol
│ │ ├── Uint256.sol
│ │ └── Uint40.sol
│ ├── sd1x18/
│ │ ├── Casting.sol
│ │ ├── Constants.sol
│ │ ├── Errors.sol
│ │ └── ValueType.sol
│ ├── sd21x18/
│ │ ├── Casting.sol
│ │ ├── Constants.sol
│ │ ├── Errors.sol
│ │ └── ValueType.sol
│ ├── sd59x18/
│ │ ├── Casting.sol
│ │ ├── Constants.sol
│ │ ├── Conversions.sol
│ │ ├── Errors.sol
│ │ ├── Helpers.sol
│ │ ├── Math.sol
│ │ └── ValueType.sol
│ ├── ud21x18/
│ │ ├── Casting.sol
│ │ ├── Constants.sol
│ │ ├── Errors.sol
│ │ └── ValueType.sol
│ ├── ud2x18/
│ │ ├── Casting.sol
│ │ ├── Constants.sol
│ │ ├── Errors.sol
│ │ └── ValueType.sol
│ └── ud60x18/
│ ├── Casting.sol
│ ├── Constants.sol
│ ├── Conversions.sol
│ ├── Errors.sol
│ ├── Helpers.sol
│ ├── Math.sol
│ └── ValueType.sol
└── test/
├── .solhint.json
├── Base.t.sol
├── fuzz/
│ ├── casting/
│ │ ├── Uint128.t.sol
│ │ ├── Uint256.t.sol
│ │ └── Uint40.t.sol
│ ├── common/
│ │ ├── msb.t.sol
│ │ └── sqrt.t.sol
│ ├── sd1x18/
│ │ └── casting/
│ │ └── Casting.t.sol
│ ├── sd21x18/
│ │ └── casting/
│ │ └── Casting.t.sol
│ ├── sd59x18/
│ │ ├── casting/
│ │ │ └── Casting.t.sol
│ │ ├── helpers/
│ │ │ └── Helpers.t.sol
│ │ └── math/
│ │ └── pow/
│ │ └── pow.t.sol
│ ├── ud21x18/
│ │ └── casting/
│ │ └── Casting.t.sol
│ ├── ud2x18/
│ │ └── casting/
│ │ └── Casting.t.sol
│ └── ud60x18/
│ ├── casting/
│ │ └── Casting.t.sol
│ ├── helpers/
│ │ └── Helpers.t.sol
│ └── math/
│ └── pow/
│ └── pow.t.sol
├── unit/
│ ├── sd59x18/
│ │ ├── SD59x18.t.sol
│ │ ├── conversion/
│ │ │ ├── convert-from/
│ │ │ │ ├── convertFrom.t.sol
│ │ │ │ └── convertFrom.tree
│ │ │ └── convert-to/
│ │ │ ├── convertTo.t.sol
│ │ │ └── convertTo.tree
│ │ └── math/
│ │ ├── abs/
│ │ │ ├── abs.t.sol
│ │ │ └── abs.tree
│ │ ├── avg/
│ │ │ ├── avg.t.sol
│ │ │ └── avg.tree
│ │ ├── ceil/
│ │ │ ├── ceil.t.sol
│ │ │ └── ceil.tree
│ │ ├── div/
│ │ │ ├── div.t.sol
│ │ │ └── div.tree
│ │ ├── exp/
│ │ │ ├── exp.t.sol
│ │ │ └── exp.tree
│ │ ├── exp2/
│ │ │ ├── exp2.t.sol
│ │ │ └── exp2.tree
│ │ ├── floor/
│ │ │ ├── floor.t.sol
│ │ │ └── floor.tree
│ │ ├── frac/
│ │ │ ├── frac.t.sol
│ │ │ └── frac.tree
│ │ ├── gm/
│ │ │ ├── gm.t.sol
│ │ │ └── gm.tree
│ │ ├── inv/
│ │ │ ├── inv.t.sol
│ │ │ └── inv.tree
│ │ ├── ln/
│ │ │ ├── ln.t.sol
│ │ │ └── ln.tree
│ │ ├── log10/
│ │ │ ├── log10.t.sol
│ │ │ └── log10.tree
│ │ ├── log2/
│ │ │ ├── log2.t.sol
│ │ │ └── log2.tree
│ │ ├── mul/
│ │ │ ├── mul.t.sol
│ │ │ └── mul.tree
│ │ ├── pow/
│ │ │ ├── pow.t.sol
│ │ │ └── pow.tree
│ │ ├── powu/
│ │ │ ├── powu.t.sol
│ │ │ └── powu.tree
│ │ └── sqrt/
│ │ ├── sqrt.t.sol
│ │ └── sqrt.tree
│ └── ud60x18/
│ ├── UD60x18.t.sol
│ ├── conversion/
│ │ ├── convert-from/
│ │ │ ├── convertFrom.t.sol
│ │ │ └── convertFrom.tree
│ │ └── convert-to/
│ │ ├── convertTo.t.sol
│ │ └── convertTo.tree
│ └── math/
│ ├── avg/
│ │ ├── avg.t.sol
│ │ └── avg.tree
│ ├── ceil/
│ │ ├── ceil.t.sol
│ │ └── ceil.tree
│ ├── div/
│ │ ├── div.t.sol
│ │ └── div.tree
│ ├── exp/
│ │ ├── exp.t.sol
│ │ └── exp.tree
│ ├── exp2/
│ │ ├── exp2.t.sol
│ │ └── exp2.tree
│ ├── floor/
│ │ ├── floor.t.sol
│ │ └── floor.tree
│ ├── frac/
│ │ ├── frac.t.sol
│ │ └── frac.tree
│ ├── gm/
│ │ ├── gm.t.sol
│ │ └── gm.tree
│ ├── inv/
│ │ ├── inv.t.sol
│ │ └── inv.tree
│ ├── ln/
│ │ ├── ln.t.sol
│ │ └── ln.tree
│ ├── log10/
│ │ ├── log10.t.sol
│ │ └── log10.tree
│ ├── log2/
│ │ ├── log2.t.sol
│ │ └── log2.tree
│ ├── mul/
│ │ ├── mul.t.sol
│ │ └── mul.tree
│ ├── pow/
│ │ ├── pow.t.sol
│ │ └── pow.tree
│ ├── powu/
│ │ ├── powu.t.sol
│ │ └── powu.tree
│ └── sqrt/
│ ├── sqrt.t.sol
│ └── sqrt.tree
└── utils/
├── Assertions.sol
└── Utils.sol
================================================
FILE CONTENTS
================================================
================================================
FILE: .editorconfig
================================================
# EditorConfig http://EditorConfig.org
# top-most EditorConfig file
root = true
# All files
[*]
charset = utf-8
end_of_line = lf
indent_size = 2
indent_style = space
insert_final_newline = true
trim_trailing_whitespace = true
[*.sol]
indent_size = 4
[*.tree]
indent_size = 1
================================================
FILE: .github/FUNDING.yml
================================================
custom: "https://3cities.xyz/#/pay?c=CAESFAKY9DMuOFdjE4Wzl2YyUFipPiSfIgICATICCAJaFURvbmF0aW9uIHRvIFBhdWwgQmVyZw"
github: "PaulRBerg"
================================================
FILE: .github/ISSUE_TEMPLATE/1-bug-report.yml
================================================
name: "🐛 Bug report"
description: "File a bug report"
labels: ["bug"]
body:
- type: markdown
attributes:
value: |
Please ensure that the bug has not already been filed in the issue tracker.
Thanks for taking the time to report this bug!
- type: input
attributes:
description: "Version tag or commit hash"
label: "What version of PRBMath are you using?"
validations:
required: true
- type: input
attributes:
label: "What version of Solidity are you using?"
validations:
required: true
- type: textarea
attributes:
label: "Describe the bug"
description: "Please include relevant Solidity snippets as well if relevant."
validations:
required: true
================================================
FILE: .github/ISSUE_TEMPLATE/2-feature-request.yml
================================================
description: "Suggest an idea for this project"
labels:
- "feature"
name: "🚀 Feature request"
body:
- type: "textarea"
attributes:
label: "Describe the feature you would like"
description: "Please also describe what the feature is aiming to solve, if relevant."
validations:
required: true
- type: "textarea"
attributes:
label: "Additional context"
description: "Add any other context to the feature (like screenshots, resources)"
================================================
FILE: .github/ISSUE_TEMPLATE/config.yml
================================================
blank_issues_enabled: true
contact_links:
- name: "🙋 Ask a question"
url: "https://github.com/PaulRBerg/prb-math/discussions/new/choose"
about: "Ask questions and discuss with other community members"
================================================
FILE: .github/workflows/ci-multibuild.yml
================================================
name: CI Multibuild
on:
workflow_dispatch:
schedule:
- cron: "0 3 * * 0" # at 3:00am UTC every Sunday
jobs:
multibuild:
runs-on: ubuntu-latest
steps:
- name: Check out the repo
uses: actions/checkout@v5
- name: Install Bun
uses: oven-sh/setup-bun@v2
- name: Install the Node.js dependencies
run: bun install
- name: Check that PRBMath can be built with multiple Solidity versions
uses: PaulRBerg/foundry-multibuild@v1
with:
min: "0.8.19"
max: "0.8.30"
skip-test: "true"
================================================
FILE: .github/workflows/ci.yml
================================================
name: CI
concurrency:
cancel-in-progress: true
group: ${{github.workflow}}-${{github.ref}}
env:
FOUNDRY_PROFILE: ci
on:
workflow_dispatch:
pull_request:
push:
branches:
- main
- staging
jobs:
check:
runs-on: ubuntu-latest
steps:
- name: Check out the repo
uses: actions/checkout@v5
- name: Install Foundry
uses: foundry-rs/foundry-toolchain@v1
- name: Install Bun
uses: oven-sh/setup-bun@v2
- name: Install the Node.js dependencies
run: bun install
- name: Install Just
uses: extractions/setup-just@v3
- name: Run the full checks
run: just full-check
- name: Add check summary
run: | # shell
echo "## Check result" >> $GITHUB_STEP_SUMMARY
echo "✅ Passed" >> $GITHUB_STEP_SUMMARY
build:
runs-on: ubuntu-latest
steps:
- name: Check out the repo
uses: actions/checkout@v5
- name: Install Bun
uses: oven-sh/setup-bun@v2
- name: Install the Node.js dependencies
run: bun install
- name: Install Foundry
uses: foundry-rs/foundry-toolchain@v1
- name: Build the Solidity code
run: forge build
- name: Add build summary
run: | # shell
echo "## Build result" >> $GITHUB_STEP_SUMMARY
echo "✅ Passed" >> $GITHUB_STEP_SUMMARY
test:
needs: [check, build]
runs-on: ubuntu-latest
steps:
- name: Check out the repo
uses: actions/checkout@v5
- name: Install Foundry
uses: foundry-rs/foundry-toolchain@v1
- name: Install Bun
uses: oven-sh/setup-bun@v2
- name: Install the Node.js dependencies
run: bun install
- name: Run the tests
run: forge test --summary
- name: Add test summary
run: | # shell
echo "## Tests result" >> $GITHUB_STEP_SUMMARY
echo "✅ Passed" >> $GITHUB_STEP_SUMMARY
================================================
FILE: .github/workflows/release.yml
================================================
# Creates GitHub releases automatically when version tags (e.g. v1.0.0) are pushed.
# Also syncs version branches (e.g. v4.2.0 -> v4 and release-v4).
name: Release
on:
push:
tags:
- "v[0-9]+.[0-9]+.[0-9]+"
jobs:
release:
runs-on: ubuntu-latest
steps:
- name: Check out the repo
uses: actions/checkout@v5
- name: Create Github release
uses: docker://antonyurchenko/git-release:v5
env:
GITHUB_TOKEN: ${{ github.token }}
- name: Sync version branches with release tag
run: | #shell
# Extract major version from tag (e.g., v4.2.0 -> v4)
TAG_NAME="${{ github.ref_name }}"
MAJOR_VERSION=$(echo "$TAG_NAME" | cut -d. -f1)
git config user.name "github-actions[bot]"
git config user.email "github-actions[bot]@users.noreply.github.com"
# Sync both branch patterns: v4 and release-v4
for BRANCH in "$MAJOR_VERSION" "release-$MAJOR_VERSION"; do
echo "Syncing branch '$BRANCH' with tag '$TAG_NAME'"
git fetch origin "$BRANCH" || true
git checkout -B "$BRANCH"
git push origin "$BRANCH" --force
done
================================================
FILE: .gitignore
================================================
# directories
cache
node_modules
out
# files
*.env
*.log
.DS_Store
.pnp.*
package-lock.json
pnpm-lock.yaml
yarn.lock
================================================
FILE: .prettierignore
================================================
# directories
cache
node_modules
out
# files
.pnp.*
package-lock.json
pnpm-lock.yaml
================================================
FILE: .prettierrc.yml
================================================
printWidth: 120
trailingComma: "all"
overrides:
- files: "*.md"
options:
printWidth: 150
proseWrap: "always"
================================================
FILE: .solhint.json
================================================
{
"extends": "solhint:recommended",
"rules": {
"compiler-version": ["error", ">=0.8.19"],
"function-max-lines": "off",
"gas-strict-inequalities": "off",
"max-line-length": ["error", 132],
"no-global-import": "off",
"no-inline-assembly": "off",
"use-natspec": "off",
"var-name-mixedcase": "off"
}
}
================================================
FILE: .vscode/settings.json
================================================
{
"solidity.formatter": "forge",
"[json][jsonc][yaml]": { "editor.defaultFormatter": "esbenp.prettier-vscode" },
"[solidity]": { "editor.defaultFormatter": "NomicFoundation.hardhat-solidity" },
"[toml]": { "editor.defaultFormatter": "tamasfe.even-better-toml" }
}
================================================
FILE: CHANGELOG.md
================================================
# Changelog
All notable changes to this project will be documented in this file.
The format is based on [Common Changelog](https://common-changelog.org/), and this project adheres to
[Semantic Versioning](https://semver.org/spec/v2.0.0.html).
[4.1.1]: https://github.com/PaulRBerg/prb-math/compare/v4.1.0...v4.1.1
[4.1.0]: https://github.com/PaulRBerg/prb-math/compare/v4.0.3...v4.1.0
[4.0.3]: https://github.com/PaulRBerg/prb-math/compare/v4.0.2...v4.0.3
[4.0.2]: https://github.com/PaulRBerg/prb-math/compare/v4.0.1...v4.0.2
[4.0.1]: https://github.com/PaulRBerg/prb-math/compare/v4.0.0...v4.0.1
[4.0.0]: https://github.com/PaulRBerg/prb-math/compare/v3.3.2...v4.0.0
[3.3.2]: https://github.com/PaulRBerg/prb-math/compare/v3.3.1...v3.3.2
[3.3.1]: https://github.com/PaulRBerg/prb-math/compare/v3.3.0...v3.3.1
[3.3.0]: https://github.com/PaulRBerg/prb-math/compare/v3.2.0...v3.3.0
[3.2.0]: https://github.com/PaulRBerg/prb-math/compare/v3.1.0...v3.2.0
[3.1.0]: https://github.com/PaulRBerg/prb-math/compare/v3.0.0...v3.1.0
[3.0.0]: https://github.com/PaulRBerg/prb-math/compare/v2.5.0...v3.0.0
[2.5.0]: https://github.com/PaulRBerg/prb-math/compare/v2.4.3...v2.5.0
[2.4.3]: https://github.com/PaulRBerg/prb-math/compare/v2.4.2...v2.4.3
[2.4.2]: https://github.com/PaulRBerg/prb-math/compare/v2.4.1...v2.4.2
[2.4.1]: https://github.com/PaulRBerg/prb-math/compare/v2.4.0...v2.4.1
[2.4.0]: https://github.com/PaulRBerg/prb-math/compare/v2.3.0...v2.4.0
[2.3.0]: https://github.com/PaulRBerg/prb-math/compare/v2.2.0...v2.3.0
[2.2.0]: https://github.com/PaulRBerg/prb-math/compare/v2.1.0...v2.2.0
[2.1.0]: https://github.com/PaulRBerg/prb-math/compare/v2.0.1...v2.1.0
[2.0.1]: https://github.com/PaulRBerg/prb-math/compare/v2.0.0...v2.0.1
[2.0.0]: https://github.com/PaulRBerg/prb-math/compare/v1.1.0...v2.0.0
[1.1.0]: https://github.com/PaulRBerg/prb-math/compare/v1.0.5...v1.1.0
[1.0.5]: https://github.com/PaulRBerg/prb-math/compare/v1.0.4...v1.0.5
[1.0.4]: https://github.com/PaulRBerg/prb-math/compare/v1.0.3...v1.0.4
[1.0.3]: https://github.com/PaulRBerg/prb-math/compare/v1.0.2...v1.0.3
[1.0.2]: https://github.com/PaulRBerg/prb-math/compare/v1.0.1...v1.0.2
[1.0.1]: https://github.com/PaulRBerg/prb-math/compare/v1.0.0...v1.0.1
[1.0.0]: https://github.com/PaulRBerg/prb-math/releases/tag/v1.0.0
## [4.1.1] - 2026-02-11
### Changed
- Rename `DOUBLE_UNIT` local variable to `doubleUnit` in `SD59x18.log2` and `UD60x18.log2` ([#261](https://github.com/PaulRBerg/prb-math/pull/261))
- Add LaTeX property specifications for `msb` and `sqrt` in `Common.sol` ([#267](https://github.com/PaulRBerg/prb-math/pull/267))
### Fixed
- Fix typos and grammar errors in NatSpec comments ([#270](https://github.com/PaulRBerg/prb-math/pull/270),
[#271](https://github.com/PaulRBerg/prb-math/pull/271), [#275](https://github.com/PaulRBerg/prb-math/pull/275))
## [4.1.0] - 2024-10-21
### Changed
- Make domain bound specs more visually descriptive ([#239](https://github.com/PaulRBerg/prb-math/pull/239)) (@PaulRBerg)
- Update requirement spec in `UD60x18.log2` ([#239](https://github.com/PaulRBerg/prb-math/pull/239)) (@PaulRBerg)
- Use return instead of param for return parameter NatSpec documentation ([#241](https://github.com/PaulRBerg/prb-math/pull/241)) (@ericglau)
### Added
- Add UD21x18 and SD21x18 types ([#212](https://github.com/PaulRBerg/prb-math/pull/212)) (@andreivladbrg, @PaulRBerg)
### Removed
- Remove adjacent castings ([#237](https://github.com/PaulRBerg/prb-math/pull/237)) (@PaulRBerg)
## [4.0.3] - 2024-06-14
### Changed
- Change visibility of `bound` ([#216](https://github.com/PaulRBerg/prb-math/pull/216)) (@PaulRBerg)
- Switch to Bun for dependency management ([#218](https://github.com/PaulRBerg/prb-math/pull/218)) (@PaulRBerg)
### Removed
- Remove dependency on `prb-test` ([#222](https://github.com/PaulRBerg/prb-math/pull/222)) (@smol-ninja)
### Fixed
- Fix types for `uUNIT` ([970aa90](https://github.com/PaulRBerg/prb-math/commit/970aa902098af46191d3b38f94bd30e7496078ae)) (@PaulRBerg)
- Return zero for very small inputs passed to `exp` ([#229](https://github.com/PaulRBerg/prb-math/pull/229)) (@0x2me)
## [4.0.2] - 2023-12-04
### Changed
- Enable `cbor_metadata` by removing the setting ([abdf0b](https://github.com/PaulRBerg/prb-math/commit/abdf0b28909fb2fb149c56cf841ef4d94f916e1e))
(@PaulRBerg)
- Install `prb-test` and `forge-std` as Node.js packages ([#211](https://github.com/PaulRBerg/prb-math/pull/211)) (@andreivladbrg, @PaulRBerg)
- Update import paths to include `src` ([#210](https://github.com/PaulRBerg/prb-math/pull/210)) (@PaulRBerg)
- Update NatSpec for `UD60x18.avg` function ([#213](https://github.com/PaulRBerg/prb-math/pull/213)) (@ericglau)
- Update NatSpec for `PRBMath_SD59x18_Powu_Overflow` custom error ([#194](https://github.com/PaulRBerg/prb-math/pull/194)) (@DaniPopes)
- Make Node.js the default installation option (@PaulRBerg)
### Added
- Include `test/utils` in Node.js package ([#211](https://github.com/PaulRBerg/prb-math/pull/211)) (@andreivladbrg, @PaulRBerg)
### Removed
- Remove git submodules ([#211](https://github.com/PaulRBerg/prb-math/pull/211)) (@andreivladbrg, @PaulRBerg)
- Remove the dummy re-exports in `src/test` ([#211](https://github.com/PaulRBerg/prb-math/pull/211)) (@andreivladbrg)
## [4.0.1] - 2023-05-28
### Changed
- Bump submodules (@PaulRBerg)
- Clarify rounding modes (@PaulRBerg)
- Move test utils from `src/test` to `test/utils` (@PaulRBerg)
- Improve documentation (@PaulRBerg)
### Added
- Provide silent `bound` utils (@PaulRBerg)
## [4.0.0] - 2023-04-13
### Changed
- **Breaking**: Rename `fromSD590x18`, `fromUD60x18`, `toSD59x18`, and `toUD60x18` to `convert` (@PaulRBerg)
- **Breaking**: Rename `Core.sol` to `Common.sol` (@PaulRBerg)
- **Breaking:** Set minimum compiler pragma to `>=0.8.19` (@PaulRBerg)
- Bump Node.js dependencies (@PaulRBerg)
- Bump submodules (@PaulRBerg)
- Clarify rounding modes ([6bb53ea](https://github.com/PaulRBerg/prb-math/tree/6bb53ea)) (@PaulRBerg)
- Clarify that `mulDiv` rounds toward zero ([cda291](https://github.com/PaulRBerg/prb-math/tree/cda291)) (@PaulRBerg)
- Fix typo in code snippet in README ([#180](https://github.com/PaulRBerg/prb-math/pull/180)) (@cygaar)
- Format contracts with Forge Formatter (@PaulRBerg)
- Improve writing and formatting in documentation (@PaulRBerg)
- Make a distinction between `lpotdod` and its flipped counterpart in `Common.mulDiv` (@PaulRBerg)
- Open pragma in test assertions and utils (@PaulRBerg)
- Reorder statements in `Common.mulDiv18` (@PaulRBerg)
- Rename `Common.prbExp2` to `Common.exp2` (@PaulRBerg)
- Rename `Common.prbSqrt` to `Common.sqrt` (@PaulRBerg)
- Rename `Assertions` to `PRBMathAssertions` (@PaulRBerg)
- Return base when exponent is unit in `pow` ([#182](https://github.com/PaulRBerg/prb-math/pull/182)) (@PaulRBerg)
- Return unit when base is unit in `pow` ([#182](https://github.com/PaulRBerg/prb-math/pull/182)) (@PaulRBerg)
- Switch to Pnpm for Node.js package management (@PaulRBerg)
- Use bound `unwrap` instead of imported `unwrap` (@PaulRBerg)
- Use long names in named imports (@PaulRBerg)
### Added
- Add `EXP_MAX_INPUT` and `EXP2_MAX_INPUT` constants, and use them in `exp` and `exp2` (@PaulRBerg)
- Add `UNIT_SQUARED` and use it instead of the hard-coded value (@PaulRBerg)
- Add user-defined operators ([#168](https://github.com/PaulRBerg/prb-math/pull/168)) (@Amxx,@PaulRBerg)
- Add unary operator ([#173](https://github.com/PaulRBerg/prb-math/pull/173)) (@Lumyo,@PaulRBerg)
- Expand domain of `pow` in `UD60x18` by allowing inputs lower than `UNIT` ([#182](https://github.com/PaulRBerg/prb-math/pull/182)) (@PaulRBerg)
### Removed
- Remove development-related Node.js dependencies (@PaulRBerg)
- Remove "memory-safe" annotation in test assertions (@PaulRBerg)
- Remove problematic src/=src/ remapping (#41) (@PaulRBerg)
- Remove superfluous threshold check in `SD59x19.exp` (@PaulRBerg)
### Fixed
- Fix bit mask in `Common.exp2` ([#179](https://github.com/PaulRBerg/prb-math/pull/179)) (@andreivladbrg)
## [3.3.2] - 2023-03-19
### Changed
- Use `ValueType.wrap` directly in casting functions (@PaulRBerg)
## [3.3.1] - 2023-03-17
### Changed
- Bump submodules (@PaulRBerg)
## [3.3.0] - 2023-02-06
### Changed
- Improve documentation (@PaulRBerg)
- Improve names of custom errors and functions (@PaulRBerg)
- Optimize assembly usage by annotating assembly blocks with the "memory-safe" dialect (@PaulRBerg)
- Modularize code by splitting it into multiple categories: casting, constants, conversions, errors, helpers, math, and value types (@PaulRBerg)
- Rename `Assertions` to `PRBMathAssertions` in a backward-compatible way (@PaulRBerg)
- Upgrade Node.js package dependencies (@PaulRBerg)
### Added
- Add casting utilities for PRBMath types and `uint128` and `uint40` (@PaulRBerg)
- Add more constants in `SD1x18` and `UD2x18` (@PaulRBerg)
- Add `PRBMathUtils` contract with test utils (@PaulRBerg)
- Add test assertions overloads with `err` param (@PaulRBerg)
- Add typed versions of `bound` test util (@PaulRBerg)
- Add `wrap` and `unwrap` in `SD1x18` and `UD2x18` (@PaulRBerg)
- Expose `unwrap` via `using for ... global` (@PaulRBerg)
## [3.2.0] - 2022-12-13
### Added
- Add assertions for array comparisons (@PaulRBerg)
### Removed
- Delete assertions that have an "err" argument (@PaulRBerg)
### Fixed
- Match types for `SD1x18` and `UD2x18` assertions (@PaulRBerg)
## [3.1.0] - 2022-12-13
### Added
- Add value types `SD1x18` and `UD2x18` (@PaulRBerg)
## [3.0.0] - 2022-11-29
[1b82ea]: https://github.com/PaulRBerg/prb-math/commit/1b82ea
[a69b4b]: https://github.com/PaulRBerg/prb-math/commit/a69b4b
### Changed
- **Breaking:** Refactor the libraries into free functions and user defined value types ([`a69b4b`][a69b4b]) (@PaulRBerg)
- **Breaking:** Set minimum compiler pragma to `>=0.8.13` ([`a69b4b`][a69b4b]) (@PaulRBerg)
- **Breaking:** Rename `SCALE` to `UNIT` ([`4d3658`](https://github.com/PaulRBerg/prb-math/commit/4d3658)) (@PaulRBerg)
- Always truncate instead of rounding up in multiplication functions ([21fb32](https://github.com/PaulRBerg/prb-math/commit/21fb32)) (@PaulRBerg)
- Change license to MIT (@PaulRBerg)
- Check if `y` is zero in `gm` ([`5b585c`](https://github.com/PaulRBerg/prb-math/commit/5b585c)) (@PaulRBerg)
- Optimize `avg` by using the SWAR technique ([#89](https://github.com/PaulRBerg/prb-math/pull/89)) (@PaulRBerg)
- Optimize `div` and `mulDivSigned` by wrapping unary operations in unchecked blocks ([`a69b4b`][a69b4b]) (@PaulRBerg)
- Optimize `exp2` by batching bit checks ([#77](https://github.com/PaulRBerg/prb-math/pull/77)) (@k06a)
- Optimize `msb` by using assembly ([#135](https://github.com/PaulRBerg/prb-math/pull/135)) (@t4sk, @PaulRBerg)
- Optimize result assignment in `powu` ([673802](https://github.com/PaulRBerg/prb-math/commit/673802)) (@PaulRBerg)
- Rename `fromInt` to `toSD59x18` and `toInt` to `fromSD59x18` ([`a69b4b`][a69b4b]) (@PaulRBerg)
- Rename `fromUint` to `toUD60x18` and `toUint` to `fromUD60x18` ([`a69b4b`][a69b4b]) (@PaulRBerg)
- Rename `mostSignificantBit` to `msb` ([`a69b4b`][a69b4b]) (@PaulRBerg)
- Rename `mulDivFixedPoint` to `mulDiv18` ([`4c5430`](https://github.com/PaulRBerg/prb-math/commit/4c5430)) (@PaulRBerg)
- Rename `PRBMath.sol` to `Core.sol` ([`1b82ea`][1b82ea]) (@PaulRBerg)
- Rename shared `sqrt` in `prbSqrt` ([`1b82ea`][1b82ea]) (@PaulRBerg)
- Rename shared `exp2` in `prbExp2` ([`1b82ea`][1b82ea]) (@PaulRBerg)
- Revert with inputs instead of computed value custom errors (@PaulRBerg)
- Return base if exponent is one in `pow` ([`977d43`](https://github.com/PaulRBerg/prb-math/commit/977d43)) (@PaulRBerg)
- Format mathematical expressions using LaTeX (@PaulRBerg)
- Improve wording and formatting in comments, NatSpec documentation, and README (@PaulRBerg)
### Added
- Add constants for E and PI ([`422d87`](https://github.com/PaulRBerg/prb-math/commit/422d87)) (@PaulRBerg)
- Add simple PRBTest-based typed assertions for testing in Foundry ([`ddb084`](https://github.com/PaulRBerg/prb-math/commit/ddb084)) (@PaulRBerg)
- Add user defined value types `SD59x18` and `UD60x18` (@PaulRBerg)
- Implement conversion and helper functions for the user defined value types (@PaulRBerg)
### Removed
- **Breaking:** Delete the `e` and `pi` functions ([422d87](https://github.com/PaulRBerg/prb-math/commit/422d87)) (@PaulRBerg)
- **Breaking:** Remove JavaScript SDK and all paraphernalia ([`1b82ea`][1b82ea]) (@PaulRBerg)
### Fixed
- Fix incorrect hard-coded value in `sqrt` ([#91](https://github.com/PaulRBerg/prb-math/pull/91)) (@Amxx, @nonergodic)
- Fix upper boundary specified in `exp` NatSpec comments ([#119](https://github.com/PaulRBerg/prb-math/discussions/119)) (@PaulRBerg)
## [2.5.0] - 2022-03-08
### Changed
- Change the package name from `prb-math` to `@prb/math` (@PaulRBerg)
- Update links to repository (@PaulRBerg)
- Upgrade to `mathjs` v10.4.0 (@PaulRBerg)
## [2.4.3] - 2022-02-02
### Fixed
- Peer dependency version for `mathjs` (@PaulRBerg)
## [2.4.2] - 2022-02-02
### Changed
- Upgrade to `mathjs` v10.1.1 (@PaulRBerg)
### Fixed
- Fix typo in comment in `sqrt` ([#67](https://github.com/PaulRBerg/prb-math/pull/67) (@transmissions11)
## [2.4.1] - 2021-10-27
### Changed
- Upgrade to `@ethersproject/bignumber` v5.5.0 (@PaulRBerg)
### Fixed
- Set peer dependencies (@PaulRBerg)
## [2.4.0] - 2021-10-20
### Added
- `@ethersproject/bignumber`, `decimal.js`, `evm-bn`, and `mathjs` as normal deps (@PaulRBerg)
- Ship JavaScript source maps with the npm package (@PaulRBerg)
### Changed
- Americanize spellings in NatSpec comments (@PaulRBerg)
- Move everything from the `prb-math.js` package to `prb-math` (@PaulRBerg)
- Polish NatSpec comments in `avg` function (@PaulRBerg)
- Use underscores in number literals (@PaulRBerg)
### Fixed
- Fix bug in the `powu` function of the `PRBMathSD59x18` contract, which caused the result to be positive even if the base was negative (@PaulRBerg)
- Fix minor bug in the `avg` function of the `PRBMathSD59x18` contract, which rounded down the result instead of up when the intermediary sum was
negative (@PaulRBerg)
## [2.3.0] - 2021-09-18
### Added
- The CHANGELOG file in the npm package bundle (@PaulRBerg)
### Changed
- License from "WTFPL" to "Unlicense" (@PaulRBerg)
- Polish README (@PaulRBerg)
### Fixed
- Typos in comments (@PaulRBerg)
### Removed
- Remove stale "resolutions" field in `package.json` (@PaulRBerg)
## [2.2.0] - 2021-06-27
### Changed
- Add contract name prefix to custom errors (@PaulRBerg)
### Removed
- Remove `@param` tags in custom errors' NatSpec (@PaulRBerg)
## [2.1.0] - 2021-06-27
### Changed
- Define the upper limit as `MAX_UD60x18 / SCALE` in the `sqrt` function (@PaulRBerg)
- Define `xValue` var to avoid reading `x.value` multiple times (@PaulRBerg)
- Move `SCALE > prod1` check at the top of the `mulDivFixedPoint` function (@PaulRBerg)
- Refer to `add` function operands as summands (@PaulRBerg)
- Refer to `sub` function operands as minuend and subtrahend (@PaulRBerg)
- Rename `rUnsigned` var to `rAbs` (@PaulRBerg)
- Set minimum compiler pragma to `>=0.8.4` (@PaulRBerg)
- Use `MIN_SD59x18` instead of `type(int256).min` where appropriate (@PaulRBerg)
### Added
- Add Solidity v0.8.4 custom errors (@PaulRBerg)
### Removed
- Remove stale `hardhat/console.sol` import (@PaulRBerg)
- Remove stale caveat in the NatSpec for `sqrt` (@PaulRBerg)
## [2.0.1] - 2021-06-16
### Changed
- Mention the new typed flavors in the README (@PaulRBerg)
### Fixed
- Code snippet for the UD60x18Typed consumer in the README (@PaulRBerg)
- English typos in NatSpec comments ([#40](https://github.com/PaulRBerg/prb-math/pull/40)) (@ggviana)
- Minor bug in `log10` in `PRBMathUD60x18Typed.sol` which made the result inaccurate when the input was a multiple of 10 (@PaulRBerg)
## [2.0.0] - 2021-06-14
### Changed
- **Breaking**: Rename `PRBMathCommon.sol` to `PRBMath.sol` (@PaulRBerg)
- Increase the accuracy of `exp2` by using the 192.64-bit format instead of 128.128-bit (@PaulRBerg)
- Set named parameter instead of returning result in `pow` functions (@PaulRBerg)
- Update gas estimates for `exp` and `exp2` (@PaulRBerg)
### Added
- Add `add` and `sub` functions in the typed libraries (@PaulRBerg)
- Add types flavors of the library: `PRBMathSD59x18Typed.sol` and `PRBMathUD60x18Typed.sol` (@PaulRBerg)
- Document gas estimates for `fromInt`, `fromUint`, `pow`, `toInt` and `toUInt` (@PaulRBerg)
- Structs `PRBMath.SD59x18` and `PRBMath.UD60x18`, simple wrappers to indicate that the variables are fixed-point numbers (@PaulRBerg)
### Fixed
- Bug in `log10` which made the result incorrect when the input was not a multiple of 10 (@PaulRBerg)
- Typos in NatSpec comments (@PaulRBerg)
## [1.1.0] - 2021-05-07
_This release was yanked because it was accidentally published with the wrong version number._
### Changed
- Rename the previous `pow` function to `powu` (@PaulRBerg)
- Speed up `exp2` by simplifying the integer part calculations (@PaulRBerg)
- Use the fixed-point format in NatSpec comments (@PaulRBerg)
### Added
- Add new converter functions `fromInt` and `toInt` in `PRBMathSD59x18.sol` (@PaulRBerg)
- Add new converter functions `fromUint` and `toUint` in `PRBMathUD60x18.sol` (@PaulRBerg)
- Add new function `mulDivSigned` in `PRBMathCommon.sol` (@PaulRBerg)
- Add new function `pow` in `PRBMathSD59x18.sol` and `PRBMathUD60x18.sol` (@PaulRBerg)
### Fixed
- Fix minor typos in NatSpec comments (@PaulRBerg)
## [1.0.5] - 2021-04-24
### Changed
- Speed up the `exp2` function in PRBMathCommon.sol by simplifying the integer part calculation (@PaulRBerg))
- Use `SCALE` instead of the 1e18 literal in `PRBMathCommon.sol` (@PaulRBerg)
### Added
- Add link to StackExchange answer in `exp2` NatSpec comments (@PaulRBerg)
## [1.0.4] - 2021-04-20
### Changed
- Optimize the `pow` function in `PRBMathUD60x18` by calling `mulDivFixedPoint` directly (@PaulRBerg)
## [1.0.3] - 2021-04-20
### Fixed
- Fix typos in NatSpec comments (@PaulRBerg)
- Fix typo in example in README (@PaulRBerg)
### Removed
- Remove `SCALE_LPOTD` and `SCALE_INVERSE` constants in `PRBMathSD59x18` (@PaulRBerg)
## [1.0.2] - 2021-04-19
### Removed
- Remove stale `SCALE_LPOTD` and `SCALE_INVERSE` constants in `PRBMathUD60x18` (@PaulRBerg)
## [1.0.1] - 2021-04-19
### Changed
- Change in the README (@PaulRBerg)
## [1.0.0] - 2021-04-19
### Added
- First release of the library (@PaulRBerg)
================================================
FILE: CLAUDE.md
================================================
# PRBMath
Solidity library for advanced fixed-point math with signed (SD59x18) and unsigned (UD60x18) 18-decimal types.
## Stack
- Solidity 0.8.30
- Foundry (forge build, forge test, forge fmt)
- Bun for package management
- Prettier, Solhint for formatting/linting
## Structure
```
src/
Common.sol # Shared utilities (mulDiv, exp2, log2, pow, sqrt)
SD59x18.sol # Signed 59.18 fixed-point type
UD60x18.sol # Unsigned 60.18 fixed-point type
SD1x18.sol # Signed 1.18 (compact)
UD2x18.sol # Unsigned 2.18 (compact)
SD21x18.sol # Signed 21.18 (medium)
UD21x18.sol # Unsigned 21.18 (medium)
sd59x18/ # SD59x18 operations (math, conversions, helpers)
ud60x18/ # UD60x18 operations (math, conversions, helpers)
casting/ # Type casting between formats
test/
unit/ # Unit tests
fuzz/ # Fuzz tests
utils/ # Test utilities
```
## Commands
- `bun run build` - Build with Forge
- `bun run test` - Run tests (`forge test`)
- `bun run full-check` - Prettier + Solhint + Forge format check
- `bun run full-write` - Auto-fix all formatting issues
## Development
After generating or updating code:
1. Run `bun run full-check` to verify
2. If errors, run `bun run full-write` to auto-fix
3. Fix remaining issues manually
Install dependencies: `bun install` or `bun install -d <pkg>` for dev deps.
## Code Style
- Use user-defined value types (SD59x18, UD60x18) for type safety
- Free functions over library pattern
- Custom errors over require strings
- NatSpec comments on public functions
- Line length: 132 chars
- 4-space tabs
- Bracket spacing enabled
## Fixed-Point Formats
| Type | Signed | Integer Digits | Decimals |
| ------- | ------ | -------------- | -------- |
| SD59x18 | Yes | 59 | 18 |
| UD60x18 | No | 60 | 18 |
| SD1x18 | Yes | 1 | 18 |
| UD2x18 | No | 2 | 18 |
| SD21x18 | Yes | 21 | 18 |
| UD21x18 | No | 21 | 18 |
## Testing
```bash
forge test # Run all tests
forge test --match-test testFoo # Run specific test
forge test --match-contract Exp2 # Run tests in contract
FOUNDRY_PROFILE=ci forge test # CI profile with more fuzz runs
```
================================================
FILE: LICENSE.md
================================================
MIT License
Copyright (c) 2023-present Paul Razvan Berg
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to
deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
IN THE SOFTWARE.
================================================
FILE: README.md
================================================
# PRBMath [![GitHub Actions][gha-badge]][gha] [![Foundry][foundry-badge]][foundry] [![License: MIT][license-badge]][license]
[gha]: https://github.com/PaulRBerg/prb-math/actions
[gha-badge]: https://github.com/PaulRBerg/prb-math/actions/workflows/ci.yml/badge.svg
[foundry]: https://getfoundry.sh/
[foundry-badge]: https://img.shields.io/badge/Built%20with-Foundry-FFDB1C.svg
[license]: https://opensource.org/licenses/MIT
[license-badge]: https://img.shields.io/badge/License-MIT-blue.svg
<div align="center">
<img src="./assets/logo.png" alt="PRBMath Logo" width="250">
</div>
**Solidity library for advanced fixed-point math** that operates with signed 59.18-decimal fixed-point and unsigned 60.18-decimal fixed-point numbers.
The name of the number format comes from the integer part having up to 59 digits for signed numbers and 60 digits for unsigned numbers, while the
fractional part has up to 18 decimals. The numbers are bound by the minimum and the maximum values permitted by the Solidity types int256 and uint256.
- Operates with signed and unsigned denary fixed-point numbers, with 18 trailing decimals
- Offers advanced math functions like logarithms, exponentials, powers and square roots
- Provides type safety via user-defined value types
- Gas efficient, but still user-friendly
- Ergonomic developer experience thanks to using free functions instead of libraries
- Bakes in overflow-safe multiplication and division via `mulDiv`
- Reverts with custom errors instead of reason strings
- Well-documented with NatSpec comments
- Built and tested with Foundry
> [!NOTE]
>
> PRBMath is a fixed-point math library that is at the same time intuitive, efficient and safe.
> [ABDKMath64x64](https://github.com/abdk-consulting/abdk-libraries-solidity) is fast, but uses binary numbers, which are counter-intuitive.
> [Solmate](https://github.com/transmissions11/solmate) is fast and intuitive, but lacks type safety.
## 📦 Install
### 🟢 Node.js
This is the recommended approach.
Install PRBMath using your favorite package manager, e.g., with Bun:
```shell
bun add @prb/math
```
Then, if you are using Foundry, you need to add this to your `remappings.txt` file:
```text
@prb/math/=node_modules/@prb/math/
```
### 🔗 Git Submodules
This installation method is not recommended, but it is available for those who prefer it.
First, install the submodule using Forge:
```shell
forge install PaulRBerg/prb-math@release-v4
```
Your `.gitmodules` file should now contain the following entry:
```toml
[submodule "lib/prb-math"]
branch = "release-v4"
path = "lib/prb-math"
url = "https://github.com/PaulRBerg/prb-math"
```
Finally, add this to your `remappings.txt` file:
```text
@prb/math/=lib/prb-math/
```
## 🚀 Usage
There are two user-defined value types:
1. SD59x18 (signed)
2. UD60x18 (unsigned)
If you don't know what a user-defined value type is, check out this [blog post](https://blog.soliditylang.org/2021/09/27/user-defined-value-types/).
If you don't need negative numbers, there's no point in using the signed flavor `SD59x18`. The unsigned flavor `UD60x18` is more gas efficient.
Note that PRBMath is not a library in the Solidity [sense](https://docs.soliditylang.org/en/v0.8.17/contracts.html#libraries). It's just a collection
of free functions.
### 📥 Importing
It is recommended that you import PRBMath using specific symbols. Importing full files can result in Solidity complaining about duplicate definitions
and static analyzers like Slither erroring, especially as repos grow and have more dependencies with overlapping names.
```solidity
pragma solidity >=0.8.19;
import { SD59x18 } from "@prb/math/src/SD59x18.sol";
import { UD60x18 } from "@prb/math/src/UD60x18.sol";
```
Any function that is not available in the types directly has to be imported explicitly. Here's an example for the `sd` and the `ud` functions:
```solidity
pragma solidity >=0.8.19;
import { SD59x18, sd } from "@prb/math/src/SD59x18.sol";
import { UD60x18, ud } from "@prb/math/src/UD60x18.sol";
```
Note that PRBMath can only be used in Solidity v0.8.19 and above.
### ➕ SD59x18
```solidity
// 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.
/// @dev Try this with x = 400e18.
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.
/// @dev Try this with x = 128e18.
function signedLog2(SD59x18 x) external pure returns (SD59x18 result) {
result = x.log2();
}
}
```
### ➕ UD60x18
```solidity
// 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.
/// @dev Try this with x = 400e18.
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.
/// @dev Try this with x = 128e18.
function unsignedLog2(UD60x18 x) external pure returns (UD60x18 result) {
result = x.log2();
}
}
```
## ✨ Features
Because there's significant overlap between the features available in SD59x18 and UD60x18, there is only one table per section. If in doubt, refer to
the source code, which is well-documented with NatSpec comments.
### 🔢 Mathematical Functions
| Name | Operator | Description |
| ------- | -------- | ------------------------------------------------ |
| `abs` | N/A | Absolute value |
| `avg` | N/A | Arithmetic average |
| `ceil` | N/A | Smallest whole number greater than or equal to x |
| `div` | `/` | Fixed-point division |
| `exp` | N/A | Natural exponential e^x |
| `exp2` | N/A | Binary exponential 2^x |
| `floor` | N/A | Greatest whole number less than or equal to x |
| `frac` | N/A | Fractional part |
| `gm` | N/A | Geometric mean |
| `inv` | N/A | Inverse 1÷x |
| `ln` | N/A | Natural logarithm ln(x) |
| `log10` | N/A | Common logarithm log10(x) |
| `log2` | N/A | Binary logarithm log2(x) |
| `mul` | `*` | Fixed-point multiplication |
| `pow` | N/A | Power function x^y |
| `powu` | N/A | Power function x^y with y simple integer |
| `sqrt` | N/A | Square root |
### 🔗 Adjacent Value Types
PRBMath provides adjacent value types that serve as abstractions over other vanilla types:
| Value Type | Underlying Type |
| ---------- | --------------- |
| `SD1x18` | int64 |
| `SD21x18` | int128 |
| `UD2x18` | uint64 |
| `UD21x18` | uint128 |
These are useful if you want to save gas by using a lower bit width integer, e.g., in a struct.
Note that these types don't have any mathematical functionality. To do math with them, you will have to unwrap them into a simple integer and then to
the core types `SD59x18` and `UD60x18`.
### 🔄 Casting Functions
All PRBMath types have casting functions to and from all other types, including a few basic types like `uint128` and `uint40`.
| Name | Description |
| ------------- | ------------------------- |
| `intoSD1x18` | Casts a number to SD1x18 |
| `intoSD59x18` | Casts a number to SD59x18 |
| `intoUD2x18` | Casts a number to UD2x18 |
| `intoUD60x18` | Casts a number to UD60x18 |
| `intoUint256` | Casts a number to uint256 |
| `intoUint128` | Casts a number to uint128 |
| `intoUint40` | Casts a number to uint40 |
| `sd1x18` | Alias for `SD1x18.wrap` |
| `sd59x18` | Alias for `SD59x18.wrap` |
| `ud2x18` | Alias for `UD2x18.wrap` |
| `ud60x18` | Alias for `UD60x18.wrap` |
### ⚡ Conversion Functions
The difference between "conversion" and "casting" is that conversion functions multiply or divide the inputs, whereas casting functions simply cast
them.
| Name | Description |
| ------------------ | --------------------------------------------------------------------- |
| `convert(SD59x18)` | Converts an SD59x18 number to a simple integer by dividing it by 1e18 |
| `convert(UD60x18)` | Converts a UD60x18 number to a simple integer by dividing it by 1e18 |
| `convert(int256)` | Converts a simple integer to SD59x18 by multiplying it by 1e18 |
| `convert(uint256)` | Converts a simple integer to UD60x18 type by multiplying it by 1e18 |
### 🛠️ Helper Functions
In addition to offering mathematical, casting, and conversion functions, PRBMath provides numerous helper functions for user-defined value types:
| Name | Operator | Description |
| -------------- | -------- | ------------------------- |
| `add` | `+` | Checked addition |
| `and` | `&` | Logical AND |
| `eq` | `==` | Equality |
| `gt` | `>` | Greater than operator |
| `gte` | `>=` | Greater than or equal to |
| `isZero` | N/A | Check if a number is zero |
| `lshift` | N/A | Bitwise left shift |
| `lt` | `<` | Less than |
| `lte` | `<=` | Less than or equal to |
| `mod` | `%` | Modulo |
| `neq` | `!=` | Not equal operator |
| `not` | `~` | Negation operator |
| `or` | `\|` | Logical OR |
| `rshift` | N/A | Bitwise right shift |
| `sub` | `-` | Checked subtraction |
| `unary` | `-` | Checked unary |
| `uncheckedAdd` | N/A | Unchecked addition |
| `uncheckedSub` | N/A | Unchecked subtraction |
| `xor` | `^` | Exclusive or (XOR) |
These helpers are designed to streamline basic operations such as addition and equality checks, eliminating the need to constantly unwrap and re-wrap
variables. However, it is important to be aware that utilizing these functions may result in increased gas costs compared to unwrapping and directly
using the vanilla types.
```solidity
// SPDX-License-Identifier: UNLICENSED
pragma solidity >=0.8.19;
import { UD60x18, ud } from "@prb/math/src/UD60x18.sol";
function addRshiftEq() pure returns (bool result) {
UD60x18 x = ud(1e18);
UD60x18 y = ud(3e18);
y = y.add(x); // also: y = y + x
y = y.rshift(2);
result = x.eq(y); // also: y == x
}
```
### ✅ Assertions
PRBMath comes with typed assertions that you can use for writing tests with [PRBTest](https://github.com/PaulRBerg/prb-test), which is based on
Foundry. This is useful if, for example, you would like to assert that two UD60x18 numbers are equal.
```solidity
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);
}
}
```
## ⚡ Gas Efficiency
PRBMath is faster than ABDKMath for `abs`, `exp`, `exp2`, `gm`, `inv`, `ln`, `log2`, but it is slower than ABDKMath for `avg`, `div`, `mul`, `powu`
and `sqrt`.
The main reason why PRBMath lags behind ABDKMath's `mul` and `div` functions is that it operates with 256-bit word sizes, and so it has to account for
possible intermediary overflow. ABDKMath, on the other hand, operates with 128-bit word sizes.
**Note**: I did not find a good way to automatically generate gas reports for PRBMath. See the
[#134](https://github.com/PaulRBerg/prb-math/discussions/134) discussion for more details about this issue.
### PRBMath
Gas estimations based on the [v2.0.1](https://github.com/PaulRBerg/prb-math/releases/tag/v2.0.1) and the
[v3.0.0](https://github.com/PaulRBerg/prb-math/releases/tag/v3.0.0) releases.
| SD59x18 | Min | Max | Avg | | UD60x18 | Min | Max | Avg |
| ------- | --- | ----- | ---- | --- | ------- | ---- | ----- | ---- |
| abs | 68 | 72 | 70 | | n/a | n/a | n/a | n/a |
| avg | 95 | 105 | 100 | | avg | 57 | 57 | 57 |
| ceil | 82 | 117 | 101 | | ceil | 78 | 78 | 78 |
| div | 431 | 483 | 451 | | div | 205 | 205 | 205 |
| exp | 38 | 2797 | 2263 | | exp | 1874 | 2742 | 2244 |
| exp2 | 63 | 2678 | 2104 | | exp2 | 1784 | 2652 | 2156 |
| floor | 82 | 117 | 101 | | floor | 43 | 43 | 43 |
| frac | 23 | 23 | 23 | | frac | 23 | 23 | 23 |
| gm | 26 | 892 | 690 | | gm | 26 | 893 | 691 |
| inv | 40 | 40 | 40 | | inv | 40 | 40 | 40 |
| ln | 463 | 7306 | 4724 | | ln | 419 | 6902 | 3814 |
| log10 | 104 | 9074 | 4337 | | log10 | 503 | 8695 | 4571 |
| log2 | 377 | 7241 | 4243 | | log2 | 330 | 6825 | 3426 |
| mul | 455 | 463 | 459 | | mul | 219 | 275 | 247 |
| pow | 64 | 11338 | 8518 | | pow | 64 | 10637 | 6635 |
| powu | 293 | 24745 | 5681 | | powu | 83 | 24535 | 5471 |
| sqrt | 140 | 839 | 716 | | sqrt | 114 | 846 | 710 |
### ABDKMath64x64
Gas estimations based on the v3.0 release of ABDKMath. See my [abdk-gas-estimations](https://github.com/PaulRBerg/abdk-gas-estimations) repo.
| Method | Min | Max | Avg |
| ------ | ---- | ---- | ---- |
| abs | 88 | 92 | 90 |
| avg | 41 | 41 | 41 |
| div | 168 | 168 | 168 |
| exp | 77 | 3780 | 2687 |
| exp2 | 77 | 3600 | 2746 |
| gavg | 166 | 875 | 719 |
| inv | 157 | 157 | 157 |
| ln | 7074 | 7164 | 7126 |
| log2 | 6972 | 7062 | 7024 |
| mul | 111 | 111 | 111 |
| pow | 303 | 4740 | 1792 |
| sqrt | 129 | 809 | 699 |
## 🤝 Contributing
Feel free to dive in! [Open](https://github.com/PaulRBerg/prb-math/issues/new) an issue,
[start](https://github.com/PaulRBerg/prb-math/discussions/new) a discussion or submit a PR.
### 📋 Pre Requisites
You will need the following software on your machine:
- [Git](https://git-scm.com/downloads)
- [Foundry](https://github.com/foundry-rs/foundry)
- [Node.Js](https://nodejs.org/en/download/)
- [Bun](https://bun.sh)
In addition, familiarity with [Solidity](https://soliditylang.org/) is requisite.
### ⚙️ Set Up
Clone this repository including submodules:
```sh
$ git clone --recurse-submodules -j8 git@github.com:PaulRBerg/prb-math.git
```
Then, inside the project's directory, run this to install the Node.js dependencies:
```sh
$ bun install
```
Now you can start making changes.
### 🎨 Syntax Highlighting
You will need the following VSCode extensions:
- [hardhat-solidity](https://marketplace.visualstudio.com/items?itemName=NomicFoundation.hardhat-solidity)
- [vscode-tree-language](https://marketplace.visualstudio.com/items?itemName=CTC.vscode-tree-extension)
## 🔒 Security
The codebase has undergone audits by leading security experts from Cantina and Certora. For a comprehensive list of all audits conducted, see the
[SECURITY](./SECURITY.md) file.
### ⚠️ Caveat Emptor
This is experimental software and is provided on an "as is" and "as available" basis. I do not give any warranties and will not be liable for any
loss, direct or indirect through continued use of this codebase.
### 📞 Contact
If you discover any bugs or security issues, please report them via [Telegram](https://t.me/PaulRBerg).
## 🙏 Acknowledgments
- Mikhail Vladimirov for the insights he shared in the [Math in Solidity](https://medium.com/coinmonks/math-in-solidity-part-1-numbers-384c8377f26d)
article series.
- Remco Bloemen for his work on [overflow-safe multiplication and division](https://xn--2-umb.com/21/muldiv/), and for responding to the questions I
asked him while developing the library.
- Everyone who has contributed a PR to this repository.
<h2>
<img src="./assets/op.png"
alt="Optimism logo"
width="23" />
Retro Funding
</h2>
A big shoutout and thank you to the [Optimism](https://optimism.io) team for funding the development of this library via the
[Retro Funding](https://atlas.optimism.io/project/0x7e917a2d0718401c9fe2a82f43ea558f5128f251b1e658c76dc7ff9a5e9fd993) program.
## 📄 License
This project is licensed under MIT.
================================================
FILE: SECURITY.md
================================================
# Security
The PRBMath codebase has undergone audits by leading security experts from Cantina and Certora.
| :warning: | Audits are not a guarantee of correctness. Some parts of the code base were modified after they were audited. |
| --------- | :------------------------------------------------------------------------------------------------------------ |
All issues have been timely addressed and are fixed in the latest version of PRBMath.
| Auditor | Type | Initial Commit | Report |
| :------ | :--- | :------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------- |
| Certora | Firm | [prb-math@v4.0.0](https://github.com/PaulRBerg/prb-math/tree/v4.0.0) | [2023-07-12](https://medium.com/certora/problems-in-solidity-fixed-point-libraries-certora-bug-disclosure-987f504daca4) |
| Cantina | Firm | [prb-math@v3.3.3](https://github.com/PaulRBerg/prb-math/tree/v3.3.2) | [2023-06-08](https://github.com/sablier-labs/audits/blob/6567df3fa42b90663e3e694b1e776c6db337a3f2/v2-core/cantina-2023-06-08.pdf) |
## Cantina Review
Cantina performed an audit of [Sablier Lockup](https://github.com/sablier-labs/v2-core) in June 2023, which included `prb-math@v3.3.3` in scope. Their
report included a finding in PRBMath:
> 3.2.3 PRBMath pow() function can return inconsistent values
The issue has been fixed in this PR: https://github.com/PaulRBerg/prb-math/pull/179
## Certora Review
The rounding modes were not explicitly documented. This issue was fixed in [v4.0.1](https://github.com/PaulRBerg/prb-math/releases/tag/v4.0.1).
================================================
FILE: foundry.toml
================================================
# Full reference: https://github.com/foundry-rs/foundry/tree/master/crates/config
[profile.default]
allow_internal_expect_revert = true
auto_detect_solc = false
bytecode_hash = "ipfs"
evm_version = "shanghai" # needed for greater coverage of EVM chains
fuzz = { runs = 256 }
optimizer = true
optimizer_runs = 10_000
out = "out"
solc = "0.8.30"
src = "src"
test = "test"
[profile.ci]
fuzz = { runs = 10_000, max_test_rejects = 100_000 }
verbosity = 3
[fmt]
bracket_spacing = true
int_types = "long"
line_length = 132
multiline_func_header = "all"
number_underscore = "preserve"
quote_style = "double"
tab_width = 4
wrap_comments = true
================================================
FILE: funding.json
================================================
{
"opRetro": {
"projectId": "0x7e917a2d0718401c9fe2a82f43ea558f5128f251b1e658c76dc7ff9a5e9fd993"
}
}
================================================
FILE: justfile
================================================
set allow-duplicate-variables
set allow-duplicate-recipes
set shell := ["bash", "-euo", "pipefail", "-c"]
set unstable
# ---------------------------------------------------------------------------- #
# DEPENDENCIES #
# ---------------------------------------------------------------------------- #
# Bun: https://bun.sh
bun := require("bun")
# Foundry: https://book.getfoundry.sh
forge := require("forge")
# ---------------------------------------------------------------------------- #
# CONSTANTS #
# ---------------------------------------------------------------------------- #
GLOBS_PRETTIER := "\"**/*.{json,md,yml}\""
GLOBS_SOLHINT := "\"{src,test}/**/*.sol\""
# ---------------------------------------------------------------------------- #
# COMMANDS #
# ---------------------------------------------------------------------------- #
# Show available commands
default:
@just --list
# Build the project
[group("commands")]
@build:
forge build
alias b := build
# Clean build artifacts
[group("commands")]
@clean:
bunx del-cli cache out
alias c := clean
# Run tests
[group("commands")]
@test *args:
forge test {{ args }}
alias t := test
# ---------------------------------------------------------------------------- #
# CHECKS #
# ---------------------------------------------------------------------------- #
# Run all code checks
[group("checks")]
@full-check:
just _run-with-status prettier-check
just _run-with-status solhint-check
just _run-with-status forge-check
echo ""
echo -e '{{ GREEN }}All code checks passed!{{ NORMAL }}'
alias fc := full-check
# Run all code fixes
[group("checks")]
@full-write:
just _run-with-status prettier-write
just _run-with-status solhint-write
just _run-with-status forge-write
echo ""
echo -e '{{ GREEN }}All code fixes applied!{{ NORMAL }}'
alias fw := full-write
# Check Forge formatting
[group("checks")]
@forge-check:
forge fmt --check
alias fgc := forge-check
# Format with Forge
[group("checks")]
@forge-write:
forge fmt
alias fgw := forge-write
# Check Prettier formatting
[group("checks")]
@prettier-check +globs=GLOBS_PRETTIER:
bun prettier --check --cache {{ globs }}
alias pc := prettier-check
# Format with Prettier
[group("checks")]
@prettier-write +globs=GLOBS_PRETTIER:
bun prettier --write --cache {{ globs }}
alias pw := prettier-write
# Check Solhint linting
[group("checks")]
@solhint-check +globs=GLOBS_SOLHINT:
bun solhint {{ globs }}
alias shc := solhint-check
# Fix Solhint issues
[group("checks")]
@solhint-write +globs=GLOBS_SOLHINT:
bun solhint --fix {{ globs }}
alias shw := solhint-write
# ---------------------------------------------------------------------------- #
# UTILITIES #
# ---------------------------------------------------------------------------- #
# Private recipe to run a check with formatted output
@_run-with-status recipe:
echo ""
echo -e '{{ CYAN }}→ Running {{ recipe }}...{{ NORMAL }}'
just {{ recipe }}
echo -e '{{ GREEN }}✓ {{ recipe }} completed{{ NORMAL }}'
alias rws := _run-with-status
================================================
FILE: package.json
================================================
{
"name": "@prb/math",
"description": "Solidity library for advanced fixed-point math",
"version": "4.1.1",
"author": {
"name": "Paul Razvan Berg",
"url": "https://github.com/PaulRBerg"
},
"bugs": {
"url": "https://github.com/PaulRBerg/prb-math/issues"
},
"devDependencies": {
"forge-std": "github:foundry-rs/forge-std#v1.9.7",
"prettier": "^3.7.4",
"solhint": "^6.0.2"
},
"files": [
"src",
"test/utils",
"CHANGELOG.md"
],
"homepage": "https://github.com/PaulRBerg/prb-math#readme",
"keywords": [
"arithmetic",
"blockchain",
"ethereum",
"fixed-point",
"fixed-point-math",
"library",
"math",
"smart-contracts",
"solidity"
],
"license": "MIT",
"publishConfig": {
"access": "public"
},
"repository": {
"type": "git",
"url": "git+https://github.com/PaulRBerg/prb-math.git"
}
}
================================================
FILE: src/Common.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
// Common.sol
//
// Common mathematical functions used in both SD59x18 and UD60x18. Note that these global functions do not
// always operate with SD59x18 and UD60x18 numbers.
/*//////////////////////////////////////////////////////////////////////////
CUSTOM ERRORS
//////////////////////////////////////////////////////////////////////////*/
/// @notice Thrown when the resultant value in {mulDiv} overflows uint256.
error PRBMath_MulDiv_Overflow(uint256 x, uint256 y, uint256 denominator);
/// @notice Thrown when the resultant value in {mulDiv18} overflows uint256.
error PRBMath_MulDiv18_Overflow(uint256 x, uint256 y);
/// @notice Thrown when one of the inputs passed to {mulDivSigned} is `type(int256).min`.
error PRBMath_MulDivSigned_InputTooSmall();
/// @notice Thrown when the resultant value in {mulDivSigned} overflows int256.
error PRBMath_MulDivSigned_Overflow(int256 x, int256 y);
/*//////////////////////////////////////////////////////////////////////////
CONSTANTS
//////////////////////////////////////////////////////////////////////////*/
/// @dev The maximum value a uint128 number can have.
uint128 constant MAX_UINT128 = type(uint128).max;
/// @dev The maximum value a uint40 number can have.
uint40 constant MAX_UINT40 = type(uint40).max;
/// @dev The maximum value a uint64 number can have.
uint64 constant MAX_UINT64 = type(uint64).max;
/// @dev The unit number, which is the decimal precision of the fixed-point types.
uint256 constant UNIT = 1e18;
/// @dev The unit number inverted mod 2^256.
uint256 constant UNIT_INVERSE = 78156646155174841979727994598816262306175212592076161876661_508869554232690281;
/// @dev The largest power of two that divides the decimal value of `UNIT`. The logarithm of this value is the least significant
/// bit in the binary representation of `UNIT`.
uint256 constant UNIT_LPOTD = 262144;
/*//////////////////////////////////////////////////////////////////////////
FUNCTIONS
//////////////////////////////////////////////////////////////////////////*/
/// @notice Calculates the binary exponent of x using the binary fraction method.
/// @dev Has to use 192.64-bit fixed-point numbers. See https://ethereum.stackexchange.com/a/96594/24693.
/// @param x The exponent as an unsigned 192.64-bit fixed-point number.
/// @return result The result as an unsigned 60.18-decimal fixed-point number.
/// @custom:smtchecker abstract-function-nondet
function exp2(uint256 x) pure returns (uint256 result) {
unchecked {
// Start from 0.5 in the 192.64-bit fixed-point format.
result = 0x800000000000000000000000000000000000000000000000;
// The following logic multiplies the result by $\sqrt{2^{-i}}$ when the bit at position i is 1. Key points:
//
// 1. Intermediate results will not overflow, as the starting point is 2^191 and all magic factors are under 2^65.
// 2. The rationale for organizing the if statements into groups of 8 is gas savings. If the result of performing
// a bitwise AND operation between x and any value in the array [0x80; 0x40; 0x20; 0x10; 0x08; 0x04; 0x02; 0x01] is 1,
// we know that `x & 0xFF` is also 1.
if (x & 0xFF00000000000000 > 0) {
if (x & 0x8000000000000000 > 0) {
result = (result * 0x16A09E667F3BCC909) >> 64;
}
if (x & 0x4000000000000000 > 0) {
result = (result * 0x1306FE0A31B7152DF) >> 64;
}
if (x & 0x2000000000000000 > 0) {
result = (result * 0x1172B83C7D517ADCE) >> 64;
}
if (x & 0x1000000000000000 > 0) {
result = (result * 0x10B5586CF9890F62A) >> 64;
}
if (x & 0x800000000000000 > 0) {
result = (result * 0x1059B0D31585743AE) >> 64;
}
if (x & 0x400000000000000 > 0) {
result = (result * 0x102C9A3E778060EE7) >> 64;
}
if (x & 0x200000000000000 > 0) {
result = (result * 0x10163DA9FB33356D8) >> 64;
}
if (x & 0x100000000000000 > 0) {
result = (result * 0x100B1AFA5ABCBED61) >> 64;
}
}
if (x & 0xFF000000000000 > 0) {
if (x & 0x80000000000000 > 0) {
result = (result * 0x10058C86DA1C09EA2) >> 64;
}
if (x & 0x40000000000000 > 0) {
result = (result * 0x1002C605E2E8CEC50) >> 64;
}
if (x & 0x20000000000000 > 0) {
result = (result * 0x100162F3904051FA1) >> 64;
}
if (x & 0x10000000000000 > 0) {
result = (result * 0x1000B175EFFDC76BA) >> 64;
}
if (x & 0x8000000000000 > 0) {
result = (result * 0x100058BA01FB9F96D) >> 64;
}
if (x & 0x4000000000000 > 0) {
result = (result * 0x10002C5CC37DA9492) >> 64;
}
if (x & 0x2000000000000 > 0) {
result = (result * 0x1000162E525EE0547) >> 64;
}
if (x & 0x1000000000000 > 0) {
result = (result * 0x10000B17255775C04) >> 64;
}
}
if (x & 0xFF0000000000 > 0) {
if (x & 0x800000000000 > 0) {
result = (result * 0x1000058B91B5BC9AE) >> 64;
}
if (x & 0x400000000000 > 0) {
result = (result * 0x100002C5C89D5EC6D) >> 64;
}
if (x & 0x200000000000 > 0) {
result = (result * 0x10000162E43F4F831) >> 64;
}
if (x & 0x100000000000 > 0) {
result = (result * 0x100000B1721BCFC9A) >> 64;
}
if (x & 0x80000000000 > 0) {
result = (result * 0x10000058B90CF1E6E) >> 64;
}
if (x & 0x40000000000 > 0) {
result = (result * 0x1000002C5C863B73F) >> 64;
}
if (x & 0x20000000000 > 0) {
result = (result * 0x100000162E430E5A2) >> 64;
}
if (x & 0x10000000000 > 0) {
result = (result * 0x1000000B172183551) >> 64;
}
}
if (x & 0xFF00000000 > 0) {
if (x & 0x8000000000 > 0) {
result = (result * 0x100000058B90C0B49) >> 64;
}
if (x & 0x4000000000 > 0) {
result = (result * 0x10000002C5C8601CC) >> 64;
}
if (x & 0x2000000000 > 0) {
result = (result * 0x1000000162E42FFF0) >> 64;
}
if (x & 0x1000000000 > 0) {
result = (result * 0x10000000B17217FBB) >> 64;
}
if (x & 0x800000000 > 0) {
result = (result * 0x1000000058B90BFCE) >> 64;
}
if (x & 0x400000000 > 0) {
result = (result * 0x100000002C5C85FE3) >> 64;
}
if (x & 0x200000000 > 0) {
result = (result * 0x10000000162E42FF1) >> 64;
}
if (x & 0x100000000 > 0) {
result = (result * 0x100000000B17217F8) >> 64;
}
}
if (x & 0xFF000000 > 0) {
if (x & 0x80000000 > 0) {
result = (result * 0x10000000058B90BFC) >> 64;
}
if (x & 0x40000000 > 0) {
result = (result * 0x1000000002C5C85FE) >> 64;
}
if (x & 0x20000000 > 0) {
result = (result * 0x100000000162E42FF) >> 64;
}
if (x & 0x10000000 > 0) {
result = (result * 0x1000000000B17217F) >> 64;
}
if (x & 0x8000000 > 0) {
result = (result * 0x100000000058B90C0) >> 64;
}
if (x & 0x4000000 > 0) {
result = (result * 0x10000000002C5C860) >> 64;
}
if (x & 0x2000000 > 0) {
result = (result * 0x1000000000162E430) >> 64;
}
if (x & 0x1000000 > 0) {
result = (result * 0x10000000000B17218) >> 64;
}
}
if (x & 0xFF0000 > 0) {
if (x & 0x800000 > 0) {
result = (result * 0x1000000000058B90C) >> 64;
}
if (x & 0x400000 > 0) {
result = (result * 0x100000000002C5C86) >> 64;
}
if (x & 0x200000 > 0) {
result = (result * 0x10000000000162E43) >> 64;
}
if (x & 0x100000 > 0) {
result = (result * 0x100000000000B1721) >> 64;
}
if (x & 0x80000 > 0) {
result = (result * 0x10000000000058B91) >> 64;
}
if (x & 0x40000 > 0) {
result = (result * 0x1000000000002C5C8) >> 64;
}
if (x & 0x20000 > 0) {
result = (result * 0x100000000000162E4) >> 64;
}
if (x & 0x10000 > 0) {
result = (result * 0x1000000000000B172) >> 64;
}
}
if (x & 0xFF00 > 0) {
if (x & 0x8000 > 0) {
result = (result * 0x100000000000058B9) >> 64;
}
if (x & 0x4000 > 0) {
result = (result * 0x10000000000002C5D) >> 64;
}
if (x & 0x2000 > 0) {
result = (result * 0x1000000000000162E) >> 64;
}
if (x & 0x1000 > 0) {
result = (result * 0x10000000000000B17) >> 64;
}
if (x & 0x800 > 0) {
result = (result * 0x1000000000000058C) >> 64;
}
if (x & 0x400 > 0) {
result = (result * 0x100000000000002C6) >> 64;
}
if (x & 0x200 > 0) {
result = (result * 0x10000000000000163) >> 64;
}
if (x & 0x100 > 0) {
result = (result * 0x100000000000000B1) >> 64;
}
}
if (x & 0xFF > 0) {
if (x & 0x80 > 0) {
result = (result * 0x10000000000000059) >> 64;
}
if (x & 0x40 > 0) {
result = (result * 0x1000000000000002C) >> 64;
}
if (x & 0x20 > 0) {
result = (result * 0x10000000000000016) >> 64;
}
if (x & 0x10 > 0) {
result = (result * 0x1000000000000000B) >> 64;
}
if (x & 0x8 > 0) {
result = (result * 0x10000000000000006) >> 64;
}
if (x & 0x4 > 0) {
result = (result * 0x10000000000000003) >> 64;
}
if (x & 0x2 > 0) {
result = (result * 0x10000000000000001) >> 64;
}
if (x & 0x1 > 0) {
result = (result * 0x10000000000000001) >> 64;
}
}
// In the code snippet below, two operations are executed simultaneously:
//
// 1. The result is multiplied by $(2^n + 1)$, where $2^n$ represents the integer part, and the additional 1
// accounts for the initial guess of 0.5. This is achieved by subtracting from 191 instead of 192.
// 2. The result is then converted to an unsigned 60.18-decimal fixed-point format.
//
// The underlying logic is based on the relationship $2^{191-ip} = 2^{ip} / 2^{191}$, where $ip$ denotes the
// integer part, $2^n$.
result *= UNIT;
result >>= (191 - (x >> 64));
}
}
/// @notice Finds the zero-based index of the first 1 in the binary representation of x.
///
/// @dev See the note on "msb" in this Wikipedia article: https://en.wikipedia.org/wiki/Find_first_set
///
/// The implementation satisfies these properties:
///
/// $$
/// \begin{cases}
/// x = 0 \implies \text{msb}(x) = 0 \\
/// x > 0 \implies x \gg \text{msb}(x) = 1
/// \end{cases}
/// $$
///
/// Each step below is equivalent to this high-level code:
///
/// ```solidity
/// if (x >= 2 ** 128) {
/// x >>= 128;
/// result += 128;
/// }
/// ```
///
/// Where 128 is replaced with each respective power of two factor. The Yul instructions used below are:
///
/// - "gt" is "greater than"
/// - "or" is the OR bitwise operator
/// - "shl" is "shift left"
/// - "shr" is "shift right"
///
/// See the full high-level implementation here:
/// https://gist.github.com/PaulRBerg/f932f8693f2733e30c4d479e8e980948
///
/// @param x The uint256 number for which to find the index of the most significant bit.
/// @return result The index of the most significant bit as a uint256.
/// @custom:smtchecker abstract-function-nondet
function msb(uint256 x) pure returns (uint256 result) {
// 2^128
assembly ("memory-safe") {
let factor := shl(7, gt(x, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF))
x := shr(factor, x)
result := or(result, factor)
}
// 2^64
assembly ("memory-safe") {
let factor := shl(6, gt(x, 0xFFFFFFFFFFFFFFFF))
x := shr(factor, x)
result := or(result, factor)
}
// 2^32
assembly ("memory-safe") {
let factor := shl(5, gt(x, 0xFFFFFFFF))
x := shr(factor, x)
result := or(result, factor)
}
// 2^16
assembly ("memory-safe") {
let factor := shl(4, gt(x, 0xFFFF))
x := shr(factor, x)
result := or(result, factor)
}
// 2^8
assembly ("memory-safe") {
let factor := shl(3, gt(x, 0xFF))
x := shr(factor, x)
result := or(result, factor)
}
// 2^4
assembly ("memory-safe") {
let factor := shl(2, gt(x, 0xF))
x := shr(factor, x)
result := or(result, factor)
}
// 2^2
assembly ("memory-safe") {
let factor := shl(1, gt(x, 0x3))
x := shr(factor, x)
result := or(result, factor)
}
// 2^1
// No need to shift x any more.
assembly ("memory-safe") {
let factor := gt(x, 0x1)
result := or(result, factor)
}
}
/// @notice Calculates x*y÷denominator with 512-bit precision.
///
/// @dev Credits to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv.
///
/// Notes:
/// - The result is rounded toward zero.
///
/// Requirements:
/// - The denominator must not be zero.
/// - The result must fit in uint256.
///
/// @param x The multiplicand as a uint256.
/// @param y The multiplier as a uint256.
/// @param denominator The divisor as a uint256.
/// @return result The result as a uint256.
/// @custom:smtchecker abstract-function-nondet
function mulDiv(uint256 x, uint256 y, uint256 denominator) pure returns (uint256 result) {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// use the Chinese Remainder Theorem to reconstruct the 512-bit result. The result is stored in two 256
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly ("memory-safe") {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
unchecked {
return prod0 / denominator;
}
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
if (prod1 >= denominator) {
revert PRBMath_MulDiv_Overflow(x, y, denominator);
}
////////////////////////////////////////////////////////////////////////////
// 512 by 256 division
////////////////////////////////////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly ("memory-safe") {
// Compute remainder using the mulmod Yul instruction.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512-bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
unchecked {
// Calculate the largest power of two divisor of the denominator using the unary operator ~. This operation cannot overflow
// because the denominator cannot be zero at this point in the function execution. The result is always >= 1.
// For more detail, see https://cs.stackexchange.com/q/138556/92363.
uint256 lpotdod = denominator & (~denominator + 1);
uint256 flippedLpotdod;
assembly ("memory-safe") {
// Factor powers of two out of denominator.
denominator := div(denominator, lpotdod)
// Divide [prod1 prod0] by lpotdod.
prod0 := div(prod0, lpotdod)
// Get the flipped value `2^256 / lpotdod`. If the `lpotdod` is zero, the flipped value is one.
// `sub(0, lpotdod)` produces the two's complement version of `lpotdod`, which is equivalent to flipping all the bits.
// However, `div` interprets this value as an unsigned value: https://ethereum.stackexchange.com/q/147168/24693
flippedLpotdod := add(div(sub(0, lpotdod), lpotdod), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * flippedLpotdod;
// Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
// that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
// in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
// This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
// less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
// is no longer required.
result = prod0 * inverse;
}
}
/// @notice Calculates x*y÷1e18 with 512-bit precision.
///
/// @dev A variant of {mulDiv} with constant folding, i.e. in which the denominator is hard coded to 1e18.
///
/// Notes:
/// - The body is purposely left uncommented; to understand how this works, see the documentation in {mulDiv}.
/// - The result is rounded toward zero.
/// - We take as an axiom that the result cannot be `MAX_UINT256` when x and y solve the following system of equations:
///
/// $$
/// \begin{cases}
/// x * y = {MAX\_UINT256} * {UNIT} \\
/// (x * y) \% {UNIT} \geq \frac{UNIT}{2}
/// \end{cases}
/// $$
///
/// Requirements:
/// - Refer to the requirements in {mulDiv}.
/// - The result must fit in uint256.
///
/// @param x The multiplicand as an unsigned 60.18-decimal fixed-point number.
/// @param y The multiplier as an unsigned 60.18-decimal fixed-point number.
/// @return result The result as an unsigned 60.18-decimal fixed-point number.
/// @custom:smtchecker abstract-function-nondet
function mulDiv18(uint256 x, uint256 y) pure returns (uint256 result) {
uint256 prod0;
uint256 prod1;
assembly ("memory-safe") {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
unchecked {
return prod0 / UNIT;
}
}
if (prod1 >= UNIT) {
revert PRBMath_MulDiv18_Overflow(x, y);
}
uint256 remainder;
assembly ("memory-safe") {
remainder := mulmod(x, y, UNIT)
result := mul(
or(
div(sub(prod0, remainder), UNIT_LPOTD),
mul(sub(prod1, gt(remainder, prod0)), add(div(sub(0, UNIT_LPOTD), UNIT_LPOTD), 1))
),
UNIT_INVERSE
)
}
}
/// @notice Calculates x*y÷denominator with 512-bit precision.
///
/// @dev This is an extension of {mulDiv} for signed numbers, which works by computing the signs and the absolute values separately.
///
/// Notes:
/// - The result is rounded toward zero.
///
/// Requirements:
/// - Refer to the requirements in {mulDiv}.
/// - None of the inputs can be `type(int256).min`.
/// - The result must fit in int256.
///
/// @param x The multiplicand as an int256.
/// @param y The multiplier as an int256.
/// @param denominator The divisor as an int256.
/// @return result The result as an int256.
/// @custom:smtchecker abstract-function-nondet
function mulDivSigned(int256 x, int256 y, int256 denominator) pure returns (int256 result) {
if (x == type(int256).min || y == type(int256).min || denominator == type(int256).min) {
revert PRBMath_MulDivSigned_InputTooSmall();
}
// Get hold of the absolute values of x, y and the denominator.
uint256 xAbs;
uint256 yAbs;
uint256 dAbs;
unchecked {
xAbs = x < 0 ? uint256(-x) : uint256(x);
yAbs = y < 0 ? uint256(-y) : uint256(y);
dAbs = denominator < 0 ? uint256(-denominator) : uint256(denominator);
}
// Compute the absolute value of x*y÷denominator. The result must fit in int256.
uint256 resultAbs = mulDiv(xAbs, yAbs, dAbs);
if (resultAbs > uint256(type(int256).max)) {
revert PRBMath_MulDivSigned_Overflow(x, y);
}
// Get the signs of x, y and the denominator.
uint256 sx;
uint256 sy;
uint256 sd;
assembly ("memory-safe") {
// "sgt" is the "signed greater than" assembly instruction and "sub(0,1)" is -1 in two's complement.
sx := sgt(x, sub(0, 1))
sy := sgt(y, sub(0, 1))
sd := sgt(denominator, sub(0, 1))
}
// XOR over sx, sy and sd. What this does is to check whether there are 1 or 3 negative signs in the inputs.
// If there are, the result should be negative. Otherwise, it should be positive.
unchecked {
result = sx ^ sy ^ sd == 0 ? -int256(resultAbs) : int256(resultAbs);
}
}
/// @notice Calculates the square root of x using the Babylonian method.
///
/// @dev See https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method.
///
/// The implementation satisfies these properties:
///
/// $$
/// \begin{cases}
/// \lfloor\sqrt{x}\rfloor \leq \sqrt{x} < \lfloor\sqrt{x}\rfloor + 1 \\[0.5em]
/// \lfloor\sqrt{x}\rfloor^2 \leq x < (\lfloor\sqrt{x}\rfloor + 1)^2
/// \end{cases}
/// $$
///
/// Notes:
/// - If x is not a perfect square, the result is rounded down.
/// - Credits to OpenZeppelin for the explanations in comments below.
///
/// @param x The uint256 number for which to calculate the square root.
/// @return result The result as a uint256.
/// @custom:smtchecker abstract-function-nondet
function sqrt(uint256 x) pure returns (uint256 result) {
if (x == 0) {
return 0;
}
// For our first guess, we calculate the biggest power of 2 which is smaller than the square root of x.
//
// We know that the "msb" (most significant bit) of x is a power of 2 such that we have:
//
// $$
// msb(x) <= x <= 2*msb(x)
// $$
//
// We write $msb(x)$ as $2^k$, and we get:
//
// $$
// k = log_2(x)
// $$
//
// Thus, we can write the initial inequality as:
//
// $$
// 2^{log_2(x)} <= x <= 2*2^{log_2(x)+1} \\
// sqrt(2^k) <= sqrt(x) < sqrt(2^{k+1}) \\
// 2^{k/2} <= sqrt(x) < 2^{(k+1)/2} <= 2^{(k/2)+1}
// $$
//
// Consequently, $2^{log_2(x) / 2}$ is a good first approximation of sqrt(x) with at least one correct bit.
uint256 xAux = uint256(x);
result = 1;
if (xAux >= 2 ** 128) {
xAux >>= 128;
result <<= 64;
}
if (xAux >= 2 ** 64) {
xAux >>= 64;
result <<= 32;
}
if (xAux >= 2 ** 32) {
xAux >>= 32;
result <<= 16;
}
if (xAux >= 2 ** 16) {
xAux >>= 16;
result <<= 8;
}
if (xAux >= 2 ** 8) {
xAux >>= 8;
result <<= 4;
}
if (xAux >= 2 ** 4) {
xAux >>= 4;
result <<= 2;
}
if (xAux >= 2 ** 2) {
result <<= 1;
}
// At this point, `result` is an estimation with at least one bit of precision. We know the true value has at
// most 128 bits, since it is the square root of a uint256. Newton's method converges quadratically (precision
// doubles at every iteration). We thus need at most 7 iterations to turn our partial result with one bit of
// precision into the expected uint128 result.
unchecked {
result = (result + x / result) >> 1;
result = (result + x / result) >> 1;
result = (result + x / result) >> 1;
result = (result + x / result) >> 1;
result = (result + x / result) >> 1;
result = (result + x / result) >> 1;
result = (result + x / result) >> 1;
// If x is not a perfect square, round the result toward zero.
uint256 roundedResult = x / result;
if (result >= roundedResult) {
result = roundedResult;
}
}
}
================================================
FILE: src/SD1x18.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
/*
██████╗ ██████╗ ██████╗ ███╗ ███╗ █████╗ ████████╗██╗ ██╗
██╔══██╗██╔══██╗██╔══██╗████╗ ████║██╔══██╗╚══██╔══╝██║ ██║
██████╔╝██████╔╝██████╔╝██╔████╔██║███████║ ██║ ███████║
██╔═══╝ ██╔══██╗██╔══██╗██║╚██╔╝██║██╔══██║ ██║ ██╔══██║
██║ ██║ ██║██████╔╝██║ ╚═╝ ██║██║ ██║ ██║ ██║ ██║
╚═╝ ╚═╝ ╚═╝╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝
███████╗██████╗ ██╗██╗ ██╗ ██╗ █████╗
██╔════╝██╔══██╗███║╚██╗██╔╝███║██╔══██╗
███████╗██║ ██║╚██║ ╚███╔╝ ╚██║╚█████╔╝
╚════██║██║ ██║ ██║ ██╔██╗ ██║██╔══██╗
███████║██████╔╝ ██║██╔╝ ██╗ ██║╚█████╔╝
╚══════╝╚═════╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚════╝
*/
import "./sd1x18/Casting.sol";
import "./sd1x18/Constants.sol";
import "./sd1x18/Errors.sol";
import "./sd1x18/ValueType.sol";
================================================
FILE: src/SD21x18.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
/*
██████╗ ██████╗ ██████╗ ███╗ ███╗ █████╗ ████████╗██╗ ██╗
██╔══██╗██╔══██╗██╔══██╗████╗ ████║██╔══██╗╚══██╔══╝██║ ██║
██████╔╝██████╔╝██████╔╝██╔████╔██║███████║ ██║ ███████║
██╔═══╝ ██╔══██╗██╔══██╗██║╚██╔╝██║██╔══██║ ██║ ██╔══██║
██║ ██║ ██║██████╔╝██║ ╚═╝ ██║██║ ██║ ██║ ██║ ██║
╚═╝ ╚═╝ ╚═╝╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝
███████╗██████╗ ██████╗ ██╗██╗ ██╗ ██╗ █████╗
██╔════╝██╔══██╗╚════██╗███║╚██╗██╔╝███║██╔══██╗
███████╗██║ ██║ █████╔╝╚██║ ╚███╔╝ ╚██║╚█████╔╝
╚════██║██║ ██║██╔═══╝ ██║ ██╔██╗ ██║██╔══██╗
███████║██████╔╝███████╗ ██║██╔╝ ██╗ ██║╚█████╔╝
╚══════╝╚═════╝ ╚══════╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚════╝
*/
import "./sd21x18/Casting.sol";
import "./sd21x18/Constants.sol";
import "./sd21x18/Errors.sol";
import "./sd21x18/ValueType.sol";
================================================
FILE: src/SD59x18.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
/*
██████╗ ██████╗ ██████╗ ███╗ ███╗ █████╗ ████████╗██╗ ██╗
██╔══██╗██╔══██╗██╔══██╗████╗ ████║██╔══██╗╚══██╔══╝██║ ██║
██████╔╝██████╔╝██████╔╝██╔████╔██║███████║ ██║ ███████║
██╔═══╝ ██╔══██╗██╔══██╗██║╚██╔╝██║██╔══██║ ██║ ██╔══██║
██║ ██║ ██║██████╔╝██║ ╚═╝ ██║██║ ██║ ██║ ██║ ██║
╚═╝ ╚═╝ ╚═╝╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝
███████╗██████╗ ███████╗ █████╗ ██╗ ██╗ ██╗ █████╗
██╔════╝██╔══██╗██╔════╝██╔══██╗╚██╗██╔╝███║██╔══██╗
███████╗██║ ██║███████╗╚██████║ ╚███╔╝ ╚██║╚█████╔╝
╚════██║██║ ██║╚════██║ ╚═══██║ ██╔██╗ ██║██╔══██╗
███████║██████╔╝███████║ █████╔╝██╔╝ ██╗ ██║╚█████╔╝
╚══════╝╚═════╝ ╚══════╝ ╚════╝ ╚═╝ ╚═╝ ╚═╝ ╚════╝
*/
import "./sd59x18/Casting.sol";
import "./sd59x18/Constants.sol";
import "./sd59x18/Conversions.sol";
import "./sd59x18/Errors.sol";
import "./sd59x18/Helpers.sol";
import "./sd59x18/Math.sol";
import "./sd59x18/ValueType.sol";
================================================
FILE: src/UD21x18.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
/*
██████╗ ██████╗ ██████╗ ███╗ ███╗ █████╗ ████████╗██╗ ██╗
██╔══██╗██╔══██╗██╔══██╗████╗ ████║██╔══██╗╚══██╔══╝██║ ██║
██████╔╝██████╔╝██████╔╝██╔████╔██║███████║ ██║ ███████║
██╔═══╝ ██╔══██╗██╔══██╗██║╚██╔╝██║██╔══██║ ██║ ██╔══██║
██║ ██║ ██║██████╔╝██║ ╚═╝ ██║██║ ██║ ██║ ██║ ██║
╚═╝ ╚═╝ ╚═╝╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝
██╗ ██╗██████╗ ██████╗ ██╗██╗ ██╗ ██╗ █████╗
██║ ██║██╔══██╗╚════██╗███║╚██╗██╔╝███║██╔══██╗
██║ ██║██║ ██║ █████╔╝╚██║ ╚███╔╝ ╚██║╚█████╔╝
██║ ██║██║ ██║██╔═══╝ ██║ ██╔██╗ ██║██╔══██╗
╚██████╔╝██████╔╝███████╗ ██║██╔╝ ██╗ ██║╚█████╔╝
╚═════╝ ╚═════╝ ╚══════╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚════╝
*/
import "./ud21x18/Casting.sol";
import "./ud21x18/Constants.sol";
import "./ud21x18/Errors.sol";
import "./ud21x18/ValueType.sol";
================================================
FILE: src/UD2x18.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
/*
██████╗ ██████╗ ██████╗ ███╗ ███╗ █████╗ ████████╗██╗ ██╗
██╔══██╗██╔══██╗██╔══██╗████╗ ████║██╔══██╗╚══██╔══╝██║ ██║
██████╔╝██████╔╝██████╔╝██╔████╔██║███████║ ██║ ███████║
██╔═══╝ ██╔══██╗██╔══██╗██║╚██╔╝██║██╔══██║ ██║ ██╔══██║
██║ ██║ ██║██████╔╝██║ ╚═╝ ██║██║ ██║ ██║ ██║ ██║
╚═╝ ╚═╝ ╚═╝╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝
██╗ ██╗██████╗ ██████╗ ██╗ ██╗ ██╗ █████╗
██║ ██║██╔══██╗╚════██╗╚██╗██╔╝███║██╔══██╗
██║ ██║██║ ██║ █████╔╝ ╚███╔╝ ╚██║╚█████╔╝
██║ ██║██║ ██║██╔═══╝ ██╔██╗ ██║██╔══██╗
╚██████╔╝██████╔╝███████╗██╔╝ ██╗ ██║╚█████╔╝
╚═════╝ ╚═════╝ ╚══════╝╚═╝ ╚═╝ ╚═╝ ╚════╝
*/
import "./ud2x18/Casting.sol";
import "./ud2x18/Constants.sol";
import "./ud2x18/Errors.sol";
import "./ud2x18/ValueType.sol";
================================================
FILE: src/UD60x18.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
/*
██████╗ ██████╗ ██████╗ ███╗ ███╗ █████╗ ████████╗██╗ ██╗
██╔══██╗██╔══██╗██╔══██╗████╗ ████║██╔══██╗╚══██╔══╝██║ ██║
██████╔╝██████╔╝██████╔╝██╔████╔██║███████║ ██║ ███████║
██╔═══╝ ██╔══██╗██╔══██╗██║╚██╔╝██║██╔══██║ ██║ ██╔══██║
██║ ██║ ██║██████╔╝██║ ╚═╝ ██║██║ ██║ ██║ ██║ ██║
╚═╝ ╚═╝ ╚═╝╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝
██╗ ██╗██████╗ ██████╗ ██████╗ ██╗ ██╗ ██╗ █████╗
██║ ██║██╔══██╗██╔════╝ ██╔═████╗╚██╗██╔╝███║██╔══██╗
██║ ██║██║ ██║███████╗ ██║██╔██║ ╚███╔╝ ╚██║╚█████╔╝
██║ ██║██║ ██║██╔═══██╗████╔╝██║ ██╔██╗ ██║██╔══██╗
╚██████╔╝██████╔╝╚██████╔╝╚██████╔╝██╔╝ ██╗ ██║╚█████╔╝
╚═════╝ ╚═════╝ ╚═════╝ ╚═════╝ ╚═╝ ╚═╝ ╚═╝ ╚════╝
*/
import "./ud60x18/Casting.sol";
import "./ud60x18/Constants.sol";
import "./ud60x18/Conversions.sol";
import "./ud60x18/Errors.sol";
import "./ud60x18/Helpers.sol";
import "./ud60x18/Math.sol";
import "./ud60x18/ValueType.sol";
================================================
FILE: src/casting/Uint128.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { uMAX_SD1x18 } from "../sd1x18/Constants.sol";
import { SD1x18 } from "../sd1x18/ValueType.sol";
import { uMAX_SD21x18 } from "../sd21x18/Constants.sol";
import { SD21x18 } from "../sd21x18/ValueType.sol";
import { SD59x18 } from "../sd59x18/ValueType.sol";
import { uMAX_UD2x18 } from "../ud2x18/Constants.sol";
import { UD2x18 } from "../ud2x18/ValueType.sol";
import { UD21x18 } from "../ud21x18/ValueType.sol";
import { UD60x18 } from "../ud60x18/ValueType.sol";
/// @notice Thrown when trying to cast a uint128 that doesn't fit in SD1x18.
error PRBMath_IntoSD1x18_Overflow(uint128 x);
/// @notice Thrown when trying to cast a uint128 that doesn't fit in SD21x18.
error PRBMath_IntoSD21x18_Overflow(uint128 x);
/// @notice Thrown when trying to cast a uint128 that doesn't fit in UD2x18.
error PRBMath_IntoUD2x18_Overflow(uint128 x);
/// @title PRBMathCastingUint128
/// @notice Casting utilities for uint128.
library PRBMathCastingUint128 {
/// @notice Casts a uint128 number to SD1x18.
/// @dev Requirements:
/// - x ≤ uMAX_SD1x18
function intoSD1x18(uint128 x) internal pure returns (SD1x18 result) {
if (x > uint256(int256(uMAX_SD1x18))) {
revert PRBMath_IntoSD1x18_Overflow(x);
}
result = SD1x18.wrap(int64(uint64(x)));
}
/// @notice Casts a uint128 number to SD21x18.
/// @dev Requirements:
/// - x ≤ uMAX_SD21x18
function intoSD21x18(uint128 x) internal pure returns (SD21x18 result) {
if (x > uint256(int256(uMAX_SD21x18))) {
revert PRBMath_IntoSD21x18_Overflow(x);
}
result = SD21x18.wrap(int128(x));
}
/// @notice Casts a uint128 number to SD59x18.
/// @dev There is no overflow check because uint128 ⊆ SD59x18.
function intoSD59x18(uint128 x) internal pure returns (SD59x18 result) {
result = SD59x18.wrap(int256(uint256(x)));
}
/// @notice Casts a uint128 number to UD2x18.
/// @dev Requirements:
/// - x ≤ uMAX_UD2x18
function intoUD2x18(uint128 x) internal pure returns (UD2x18 result) {
if (x > uint64(uMAX_UD2x18)) {
revert PRBMath_IntoUD2x18_Overflow(x);
}
result = UD2x18.wrap(uint64(x));
}
/// @notice Casts a uint128 number to UD21x18.
function intoUD21x18(uint128 x) internal pure returns (UD21x18 result) {
result = UD21x18.wrap(x);
}
/// @notice Casts a uint128 number to UD60x18.
/// @dev There is no overflow check because uint128 ⊆ UD60x18.
function intoUD60x18(uint128 x) internal pure returns (UD60x18 result) {
result = UD60x18.wrap(x);
}
}
================================================
FILE: src/casting/Uint256.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { uMAX_SD1x18 } from "../sd1x18/Constants.sol";
import { SD1x18 } from "../sd1x18/ValueType.sol";
import { uMAX_SD21x18 } from "../sd21x18/Constants.sol";
import { SD21x18 } from "../sd21x18/ValueType.sol";
import { uMAX_SD59x18 } from "../sd59x18/Constants.sol";
import { SD59x18 } from "../sd59x18/ValueType.sol";
import { uMAX_UD2x18 } from "../ud2x18/Constants.sol";
import { UD2x18 } from "../ud2x18/ValueType.sol";
import { uMAX_UD21x18 } from "../ud21x18/Constants.sol";
import { UD21x18 } from "../ud21x18/ValueType.sol";
import { UD60x18 } from "../ud60x18/ValueType.sol";
/// @notice Thrown when trying to cast a uint256 that doesn't fit in SD1x18.
error PRBMath_IntoSD1x18_Overflow(uint256 x);
/// @notice Thrown when trying to cast a uint256 that doesn't fit in SD21x18.
error PRBMath_IntoSD21x18_Overflow(uint256 x);
/// @notice Thrown when trying to cast a uint256 that doesn't fit in SD59x18.
error PRBMath_IntoSD59x18_Overflow(uint256 x);
/// @notice Thrown when trying to cast a uint256 that doesn't fit in UD2x18.
error PRBMath_IntoUD2x18_Overflow(uint256 x);
/// @notice Thrown when trying to cast a uint256 that doesn't fit in UD21x18.
error PRBMath_IntoUD21x18_Overflow(uint256 x);
/// @title PRBMathCastingUint256
/// @notice Casting utilities for uint256.
library PRBMathCastingUint256 {
/// @notice Casts a uint256 number to SD1x18.
/// @dev Requirements:
/// - x ≤ uMAX_SD1x18
function intoSD1x18(uint256 x) internal pure returns (SD1x18 result) {
if (x > uint256(int256(uMAX_SD1x18))) {
revert PRBMath_IntoSD1x18_Overflow(x);
}
result = SD1x18.wrap(int64(int256(x)));
}
/// @notice Casts a uint256 number to SD21x18.
/// @dev Requirements:
/// - x ≤ uMAX_SD21x18
function intoSD21x18(uint256 x) internal pure returns (SD21x18 result) {
if (x > uint256(int256(uMAX_SD21x18))) {
revert PRBMath_IntoSD21x18_Overflow(x);
}
result = SD21x18.wrap(int128(int256(x)));
}
/// @notice Casts a uint256 number to SD59x18.
/// @dev Requirements:
/// - x ≤ uMAX_SD59x18
function intoSD59x18(uint256 x) internal pure returns (SD59x18 result) {
if (x > uint256(uMAX_SD59x18)) {
revert PRBMath_IntoSD59x18_Overflow(x);
}
result = SD59x18.wrap(int256(x));
}
/// @notice Casts a uint256 number to UD2x18.
/// @dev Requirements:
/// - x ≤ uMAX_UD2x18
function intoUD2x18(uint256 x) internal pure returns (UD2x18 result) {
if (x > uint256(uMAX_UD2x18)) {
revert PRBMath_IntoUD2x18_Overflow(x);
}
result = UD2x18.wrap(uint64(x));
}
/// @notice Casts a uint256 number to UD2x18.
/// @dev Requirements:
/// - x ≤ uMAX_UD21x18
function intoUD21x18(uint256 x) internal pure returns (UD21x18 result) {
if (x > uint256(uMAX_UD21x18)) {
revert PRBMath_IntoUD21x18_Overflow(x);
}
result = UD21x18.wrap(uint128(x));
}
/// @notice Casts a uint256 number to UD60x18.
function intoUD60x18(uint256 x) internal pure returns (UD60x18 result) {
result = UD60x18.wrap(x);
}
}
================================================
FILE: src/casting/Uint40.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { SD1x18 } from "../sd1x18/ValueType.sol";
import { SD21x18 } from "../sd21x18/ValueType.sol";
import { SD59x18 } from "../sd59x18/ValueType.sol";
import { UD2x18 } from "../ud2x18/ValueType.sol";
import { UD21x18 } from "../ud21x18/ValueType.sol";
import { UD60x18 } from "../ud60x18/ValueType.sol";
/// @title PRBMathCastingUint40
/// @notice Casting utilities for uint40.
library PRBMathCastingUint40 {
/// @notice Casts a uint40 number into SD1x18.
/// @dev There is no overflow check because uint40 ⊆ SD1x18.
function intoSD1x18(uint40 x) internal pure returns (SD1x18 result) {
result = SD1x18.wrap(int64(uint64(x)));
}
/// @notice Casts a uint40 number into SD21x18.
/// @dev There is no overflow check because uint40 ⊆ SD21x18.
function intoSD21x18(uint40 x) internal pure returns (SD21x18 result) {
result = SD21x18.wrap(int128(uint128(x)));
}
/// @notice Casts a uint40 number into SD59x18.
/// @dev There is no overflow check because uint40 ⊆ SD59x18.
function intoSD59x18(uint40 x) internal pure returns (SD59x18 result) {
result = SD59x18.wrap(int256(uint256(x)));
}
/// @notice Casts a uint40 number into UD2x18.
/// @dev There is no overflow check because uint40 ⊆ UD2x18.
function intoUD2x18(uint40 x) internal pure returns (UD2x18 result) {
result = UD2x18.wrap(x);
}
/// @notice Casts a uint40 number into UD21x18.
/// @dev There is no overflow check because uint40 ⊆ UD21x18.
function intoUD21x18(uint40 x) internal pure returns (UD21x18 result) {
result = UD21x18.wrap((x));
}
/// @notice Casts a uint40 number into UD60x18.
/// @dev There is no overflow check because uint40 ⊆ UD60x18.
function intoUD60x18(uint40 x) internal pure returns (UD60x18 result) {
result = UD60x18.wrap(x);
}
}
================================================
FILE: src/sd1x18/Casting.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import "../Common.sol" as Common;
import "./Errors.sol" as CastingErrors;
import { SD59x18 } from "../sd59x18/ValueType.sol";
import { UD60x18 } from "../ud60x18/ValueType.sol";
import { SD1x18 } from "./ValueType.sol";
/// @notice Casts an SD1x18 number into SD59x18.
/// @dev There is no overflow check because SD1x18 ⊆ SD59x18.
function intoSD59x18(SD1x18 x) pure returns (SD59x18 result) {
result = SD59x18.wrap(int256(SD1x18.unwrap(x)));
}
/// @notice Casts an SD1x18 number into UD60x18.
/// @dev Requirements:
/// - x ≥ 0
function intoUD60x18(SD1x18 x) pure returns (UD60x18 result) {
int64 xInt = SD1x18.unwrap(x);
if (xInt < 0) {
revert CastingErrors.PRBMath_SD1x18_ToUD60x18_Underflow(x);
}
result = UD60x18.wrap(uint64(xInt));
}
/// @notice Casts an SD1x18 number into uint128.
/// @dev Requirements:
/// - x ≥ 0
function intoUint128(SD1x18 x) pure returns (uint128 result) {
int64 xInt = SD1x18.unwrap(x);
if (xInt < 0) {
revert CastingErrors.PRBMath_SD1x18_ToUint128_Underflow(x);
}
result = uint128(uint64(xInt));
}
/// @notice Casts an SD1x18 number into uint256.
/// @dev Requirements:
/// - x ≥ 0
function intoUint256(SD1x18 x) pure returns (uint256 result) {
int64 xInt = SD1x18.unwrap(x);
if (xInt < 0) {
revert CastingErrors.PRBMath_SD1x18_ToUint256_Underflow(x);
}
result = uint256(uint64(xInt));
}
/// @notice Casts an SD1x18 number into uint40.
/// @dev Requirements:
/// - x ≥ 0
/// - x ≤ MAX_UINT40
function intoUint40(SD1x18 x) pure returns (uint40 result) {
int64 xInt = SD1x18.unwrap(x);
if (xInt < 0) {
revert CastingErrors.PRBMath_SD1x18_ToUint40_Underflow(x);
}
if (xInt > int64(uint64(Common.MAX_UINT40))) {
revert CastingErrors.PRBMath_SD1x18_ToUint40_Overflow(x);
}
result = uint40(uint64(xInt));
}
/// @notice Alias for {wrap}.
function sd1x18(int64 x) pure returns (SD1x18 result) {
result = SD1x18.wrap(x);
}
/// @notice Unwraps an SD1x18 number into int64.
function unwrap(SD1x18 x) pure returns (int64 result) {
result = SD1x18.unwrap(x);
}
/// @notice Wraps an int64 number into SD1x18.
function wrap(int64 x) pure returns (SD1x18 result) {
result = SD1x18.wrap(x);
}
================================================
FILE: src/sd1x18/Constants.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { SD1x18 } from "./ValueType.sol";
/// @dev Euler's number as an SD1x18 number.
SD1x18 constant E = SD1x18.wrap(2_718281828459045235);
/// @dev The maximum value an SD1x18 number can have.
int64 constant uMAX_SD1x18 = 9_223372036854775807;
SD1x18 constant MAX_SD1x18 = SD1x18.wrap(uMAX_SD1x18);
/// @dev The minimum value an SD1x18 number can have.
int64 constant uMIN_SD1x18 = -9_223372036854775808;
SD1x18 constant MIN_SD1x18 = SD1x18.wrap(uMIN_SD1x18);
/// @dev PI as an SD1x18 number.
SD1x18 constant PI = SD1x18.wrap(3_141592653589793238);
/// @dev The unit number, which gives the decimal precision of SD1x18.
SD1x18 constant UNIT = SD1x18.wrap(1e18);
int64 constant uUNIT = 1e18;
================================================
FILE: src/sd1x18/Errors.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { SD1x18 } from "./ValueType.sol";
/// @notice Thrown when trying to cast an SD1x18 number that doesn't fit in UD60x18.
error PRBMath_SD1x18_ToUD60x18_Underflow(SD1x18 x);
/// @notice Thrown when trying to cast an SD1x18 number that doesn't fit in uint128.
error PRBMath_SD1x18_ToUint128_Underflow(SD1x18 x);
/// @notice Thrown when trying to cast an SD1x18 number that doesn't fit in uint256.
error PRBMath_SD1x18_ToUint256_Underflow(SD1x18 x);
/// @notice Thrown when trying to cast an SD1x18 number that doesn't fit in uint40.
error PRBMath_SD1x18_ToUint40_Overflow(SD1x18 x);
/// @notice Thrown when trying to cast an SD1x18 number that doesn't fit in uint40.
error PRBMath_SD1x18_ToUint40_Underflow(SD1x18 x);
================================================
FILE: src/sd1x18/ValueType.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import "./Casting.sol" as Casting;
/// @notice The signed 1.18-decimal fixed-point number representation, which can have up to 1 digit and up to 18
/// decimals. The values of this are bound by the minimum and the maximum values permitted by the underlying Solidity
/// type int64. This is useful when end users want to use int64 to save gas, e.g. with tight variable packing in contract
/// storage.
type SD1x18 is int64;
/*//////////////////////////////////////////////////////////////////////////
CASTING
//////////////////////////////////////////////////////////////////////////*/
using {
Casting.intoSD59x18,
Casting.intoUD60x18,
Casting.intoUint128,
Casting.intoUint256,
Casting.intoUint40,
Casting.unwrap
} for SD1x18 global;
================================================
FILE: src/sd21x18/Casting.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import "../Common.sol" as Common;
import "./Errors.sol" as CastingErrors;
import { SD59x18 } from "../sd59x18/ValueType.sol";
import { UD60x18 } from "../ud60x18/ValueType.sol";
import { SD21x18 } from "./ValueType.sol";
/// @notice Casts an SD21x18 number into SD59x18.
/// @dev There is no overflow check because SD21x18 ⊆ SD59x18.
function intoSD59x18(SD21x18 x) pure returns (SD59x18 result) {
result = SD59x18.wrap(int256(SD21x18.unwrap(x)));
}
/// @notice Casts an SD21x18 number into UD60x18.
/// @dev Requirements:
/// - x ≥ 0
function intoUD60x18(SD21x18 x) pure returns (UD60x18 result) {
int128 xInt = SD21x18.unwrap(x);
if (xInt < 0) {
revert CastingErrors.PRBMath_SD21x18_ToUD60x18_Underflow(x);
}
result = UD60x18.wrap(uint128(xInt));
}
/// @notice Casts an SD21x18 number into uint128.
/// @dev Requirements:
/// - x ≥ 0
function intoUint128(SD21x18 x) pure returns (uint128 result) {
int128 xInt = SD21x18.unwrap(x);
if (xInt < 0) {
revert CastingErrors.PRBMath_SD21x18_ToUint128_Underflow(x);
}
result = uint128(xInt);
}
/// @notice Casts an SD21x18 number into uint256.
/// @dev Requirements:
/// - x ≥ 0
function intoUint256(SD21x18 x) pure returns (uint256 result) {
int128 xInt = SD21x18.unwrap(x);
if (xInt < 0) {
revert CastingErrors.PRBMath_SD21x18_ToUint256_Underflow(x);
}
result = uint256(uint128(xInt));
}
/// @notice Casts an SD21x18 number into uint40.
/// @dev Requirements:
/// - x ≥ 0
/// - x ≤ MAX_UINT40
function intoUint40(SD21x18 x) pure returns (uint40 result) {
int128 xInt = SD21x18.unwrap(x);
if (xInt < 0) {
revert CastingErrors.PRBMath_SD21x18_ToUint40_Underflow(x);
}
if (xInt > int128(uint128(Common.MAX_UINT40))) {
revert CastingErrors.PRBMath_SD21x18_ToUint40_Overflow(x);
}
result = uint40(uint128(xInt));
}
/// @notice Alias for {wrap}.
function sd21x18(int128 x) pure returns (SD21x18 result) {
result = SD21x18.wrap(x);
}
/// @notice Unwraps an SD21x18 number into int128.
function unwrap(SD21x18 x) pure returns (int128 result) {
result = SD21x18.unwrap(x);
}
/// @notice Wraps an int128 number into SD21x18.
function wrap(int128 x) pure returns (SD21x18 result) {
result = SD21x18.wrap(x);
}
================================================
FILE: src/sd21x18/Constants.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { SD21x18 } from "./ValueType.sol";
/// @dev Euler's number as an SD21x18 number.
SD21x18 constant E = SD21x18.wrap(2_718281828459045235);
/// @dev The maximum value an SD21x18 number can have.
int128 constant uMAX_SD21x18 = 170141183460469231731_687303715884105727;
SD21x18 constant MAX_SD21x18 = SD21x18.wrap(uMAX_SD21x18);
/// @dev The minimum value an SD21x18 number can have.
int128 constant uMIN_SD21x18 = -170141183460469231731_687303715884105728;
SD21x18 constant MIN_SD21x18 = SD21x18.wrap(uMIN_SD21x18);
/// @dev PI as an SD21x18 number.
SD21x18 constant PI = SD21x18.wrap(3_141592653589793238);
/// @dev The unit number, which gives the decimal precision of SD21x18.
SD21x18 constant UNIT = SD21x18.wrap(1e18);
int128 constant uUNIT = 1e18;
================================================
FILE: src/sd21x18/Errors.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { SD21x18 } from "./ValueType.sol";
/// @notice Thrown when trying to cast an SD21x18 number that doesn't fit in uint128.
error PRBMath_SD21x18_ToUint128_Underflow(SD21x18 x);
/// @notice Thrown when trying to cast an SD21x18 number that doesn't fit in UD60x18.
error PRBMath_SD21x18_ToUD60x18_Underflow(SD21x18 x);
/// @notice Thrown when trying to cast an SD21x18 number that doesn't fit in uint256.
error PRBMath_SD21x18_ToUint256_Underflow(SD21x18 x);
/// @notice Thrown when trying to cast an SD21x18 number that doesn't fit in uint40.
error PRBMath_SD21x18_ToUint40_Overflow(SD21x18 x);
/// @notice Thrown when trying to cast an SD21x18 number that doesn't fit in uint40.
error PRBMath_SD21x18_ToUint40_Underflow(SD21x18 x);
================================================
FILE: src/sd21x18/ValueType.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import "./Casting.sol" as Casting;
/// @notice The signed 21.18-decimal fixed-point number representation, which can have up to 21 digits and up to 18
/// decimals. The values of this are bound by the minimum and the maximum values permitted by the underlying Solidity
/// type int128. This is useful when end users want to use int128 to save gas, e.g. with tight variable packing in contract
/// storage.
type SD21x18 is int128;
/*//////////////////////////////////////////////////////////////////////////
CASTING
//////////////////////////////////////////////////////////////////////////*/
using {
Casting.intoSD59x18,
Casting.intoUD60x18,
Casting.intoUint128,
Casting.intoUint256,
Casting.intoUint40,
Casting.unwrap
} for SD21x18 global;
================================================
FILE: src/sd59x18/Casting.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import "./Errors.sol" as CastingErrors;
import { MAX_UINT128, MAX_UINT40 } from "../Common.sol";
import { uMAX_SD1x18, uMIN_SD1x18 } from "../sd1x18/Constants.sol";
import { SD1x18 } from "../sd1x18/ValueType.sol";
import { uMAX_SD21x18, uMIN_SD21x18 } from "../sd21x18/Constants.sol";
import { SD21x18 } from "../sd21x18/ValueType.sol";
import { uMAX_UD2x18 } from "../ud2x18/Constants.sol";
import { UD2x18 } from "../ud2x18/ValueType.sol";
import { uMAX_UD21x18 } from "../ud21x18/Constants.sol";
import { UD21x18 } from "../ud21x18/ValueType.sol";
import { UD60x18 } from "../ud60x18/ValueType.sol";
import { SD59x18 } from "./ValueType.sol";
/// @notice Casts an SD59x18 number into int256.
/// @dev This is basically a functional alias for {unwrap}.
function intoInt256(SD59x18 x) pure returns (int256 result) {
result = SD59x18.unwrap(x);
}
/// @notice Casts an SD59x18 number into SD1x18.
/// @dev Requirements:
/// - x ≥ uMIN_SD1x18
/// - x ≤ uMAX_SD1x18
function intoSD1x18(SD59x18 x) pure returns (SD1x18 result) {
int256 xInt = SD59x18.unwrap(x);
if (xInt < uMIN_SD1x18) {
revert CastingErrors.PRBMath_SD59x18_IntoSD1x18_Underflow(x);
}
if (xInt > uMAX_SD1x18) {
revert CastingErrors.PRBMath_SD59x18_IntoSD1x18_Overflow(x);
}
result = SD1x18.wrap(int64(xInt));
}
/// @notice Casts an SD59x18 number into SD21x18.
/// @dev Requirements:
/// - x ≥ uMIN_SD21x18
/// - x ≤ uMAX_SD21x18
function intoSD21x18(SD59x18 x) pure returns (SD21x18 result) {
int256 xInt = SD59x18.unwrap(x);
if (xInt < uMIN_SD21x18) {
revert CastingErrors.PRBMath_SD59x18_IntoSD21x18_Underflow(x);
}
if (xInt > uMAX_SD21x18) {
revert CastingErrors.PRBMath_SD59x18_IntoSD21x18_Overflow(x);
}
result = SD21x18.wrap(int128(xInt));
}
/// @notice Casts an SD59x18 number into UD2x18.
/// @dev Requirements:
/// - x ≥ 0
/// - x ≤ uMAX_UD2x18
function intoUD2x18(SD59x18 x) pure returns (UD2x18 result) {
int256 xInt = SD59x18.unwrap(x);
if (xInt < 0) {
revert CastingErrors.PRBMath_SD59x18_IntoUD2x18_Underflow(x);
}
if (xInt > int256(uint256(uMAX_UD2x18))) {
revert CastingErrors.PRBMath_SD59x18_IntoUD2x18_Overflow(x);
}
result = UD2x18.wrap(uint64(uint256(xInt)));
}
/// @notice Casts an SD59x18 number into UD21x18.
/// @dev Requirements:
/// - x ≥ 0
/// - x ≤ uMAX_UD21x18
function intoUD21x18(SD59x18 x) pure returns (UD21x18 result) {
int256 xInt = SD59x18.unwrap(x);
if (xInt < 0) {
revert CastingErrors.PRBMath_SD59x18_IntoUD21x18_Underflow(x);
}
if (xInt > int256(uint256(uMAX_UD21x18))) {
revert CastingErrors.PRBMath_SD59x18_IntoUD21x18_Overflow(x);
}
result = UD21x18.wrap(uint128(uint256(xInt)));
}
/// @notice Casts an SD59x18 number into UD60x18.
/// @dev Requirements:
/// - x ≥ 0
function intoUD60x18(SD59x18 x) pure returns (UD60x18 result) {
int256 xInt = SD59x18.unwrap(x);
if (xInt < 0) {
revert CastingErrors.PRBMath_SD59x18_IntoUD60x18_Underflow(x);
}
result = UD60x18.wrap(uint256(xInt));
}
/// @notice Casts an SD59x18 number into uint256.
/// @dev Requirements:
/// - x ≥ 0
function intoUint256(SD59x18 x) pure returns (uint256 result) {
int256 xInt = SD59x18.unwrap(x);
if (xInt < 0) {
revert CastingErrors.PRBMath_SD59x18_IntoUint256_Underflow(x);
}
result = uint256(xInt);
}
/// @notice Casts an SD59x18 number into uint128.
/// @dev Requirements:
/// - x ≥ 0
/// - x ≤ uMAX_UINT128
function intoUint128(SD59x18 x) pure returns (uint128 result) {
int256 xInt = SD59x18.unwrap(x);
if (xInt < 0) {
revert CastingErrors.PRBMath_SD59x18_IntoUint128_Underflow(x);
}
if (xInt > int256(uint256(MAX_UINT128))) {
revert CastingErrors.PRBMath_SD59x18_IntoUint128_Overflow(x);
}
result = uint128(uint256(xInt));
}
/// @notice Casts an SD59x18 number into uint40.
/// @dev Requirements:
/// - x ≥ 0
/// - x ≤ MAX_UINT40
function intoUint40(SD59x18 x) pure returns (uint40 result) {
int256 xInt = SD59x18.unwrap(x);
if (xInt < 0) {
revert CastingErrors.PRBMath_SD59x18_IntoUint40_Underflow(x);
}
if (xInt > int256(uint256(MAX_UINT40))) {
revert CastingErrors.PRBMath_SD59x18_IntoUint40_Overflow(x);
}
result = uint40(uint256(xInt));
}
/// @notice Alias for {wrap}.
function sd(int256 x) pure returns (SD59x18 result) {
result = SD59x18.wrap(x);
}
/// @notice Alias for {wrap}.
function sd59x18(int256 x) pure returns (SD59x18 result) {
result = SD59x18.wrap(x);
}
/// @notice Unwraps an SD59x18 number into int256.
function unwrap(SD59x18 x) pure returns (int256 result) {
result = SD59x18.unwrap(x);
}
/// @notice Wraps an int256 number into SD59x18.
function wrap(int256 x) pure returns (SD59x18 result) {
result = SD59x18.wrap(x);
}
================================================
FILE: src/sd59x18/Constants.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { SD59x18 } from "./ValueType.sol";
// NOTICE: the "u" prefix stands for "unwrapped".
/// @dev Euler's number as an SD59x18 number.
SD59x18 constant E = SD59x18.wrap(2_718281828459045235);
/// @dev The maximum input permitted in {exp}.
int256 constant uEXP_MAX_INPUT = 133_084258667509499440;
SD59x18 constant EXP_MAX_INPUT = SD59x18.wrap(uEXP_MAX_INPUT);
/// @dev Any value less than this returns 0 in {exp}.
int256 constant uEXP_MIN_THRESHOLD = -41_446531673892822322;
SD59x18 constant EXP_MIN_THRESHOLD = SD59x18.wrap(uEXP_MIN_THRESHOLD);
/// @dev The maximum input permitted in {exp2}.
int256 constant uEXP2_MAX_INPUT = 192e18 - 1;
SD59x18 constant EXP2_MAX_INPUT = SD59x18.wrap(uEXP2_MAX_INPUT);
/// @dev Any value less than this returns 0 in {exp2}.
int256 constant uEXP2_MIN_THRESHOLD = -59_794705707972522261;
SD59x18 constant EXP2_MIN_THRESHOLD = SD59x18.wrap(uEXP2_MIN_THRESHOLD);
/// @dev Half the UNIT number.
int256 constant uHALF_UNIT = 0.5e18;
SD59x18 constant HALF_UNIT = SD59x18.wrap(uHALF_UNIT);
/// @dev $log_2(10)$ as an SD59x18 number.
int256 constant uLOG2_10 = 3_321928094887362347;
SD59x18 constant LOG2_10 = SD59x18.wrap(uLOG2_10);
/// @dev $log_2(e)$ as an SD59x18 number.
int256 constant uLOG2_E = 1_442695040888963407;
SD59x18 constant LOG2_E = SD59x18.wrap(uLOG2_E);
/// @dev The maximum value an SD59x18 number can have.
int256 constant uMAX_SD59x18 = 57896044618658097711785492504343953926634992332820282019728_792003956564819967;
SD59x18 constant MAX_SD59x18 = SD59x18.wrap(uMAX_SD59x18);
/// @dev The maximum whole value an SD59x18 number can have.
int256 constant uMAX_WHOLE_SD59x18 = 57896044618658097711785492504343953926634992332820282019728_000000000000000000;
SD59x18 constant MAX_WHOLE_SD59x18 = SD59x18.wrap(uMAX_WHOLE_SD59x18);
/// @dev The minimum value an SD59x18 number can have.
int256 constant uMIN_SD59x18 = -57896044618658097711785492504343953926634992332820282019728_792003956564819968;
SD59x18 constant MIN_SD59x18 = SD59x18.wrap(uMIN_SD59x18);
/// @dev The minimum whole value an SD59x18 number can have.
int256 constant uMIN_WHOLE_SD59x18 = -57896044618658097711785492504343953926634992332820282019728_000000000000000000;
SD59x18 constant MIN_WHOLE_SD59x18 = SD59x18.wrap(uMIN_WHOLE_SD59x18);
/// @dev PI as an SD59x18 number.
SD59x18 constant PI = SD59x18.wrap(3_141592653589793238);
/// @dev The unit number, which gives the decimal precision of SD59x18.
int256 constant uUNIT = 1e18;
SD59x18 constant UNIT = SD59x18.wrap(1e18);
/// @dev The unit number squared.
int256 constant uUNIT_SQUARED = 1e36;
SD59x18 constant UNIT_SQUARED = SD59x18.wrap(uUNIT_SQUARED);
/// @dev Zero as an SD59x18 number.
SD59x18 constant ZERO = SD59x18.wrap(0);
================================================
FILE: src/sd59x18/Conversions.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { uMAX_SD59x18, uMIN_SD59x18, uUNIT } from "./Constants.sol";
import { PRBMath_SD59x18_Convert_Overflow, PRBMath_SD59x18_Convert_Underflow } from "./Errors.sol";
import { SD59x18 } from "./ValueType.sol";
/// @notice Converts a simple integer to SD59x18 by multiplying it by `UNIT`.
///
/// @dev Requirements:
/// - x ≥ `MIN_SD59x18 / UNIT`
/// - x ≤ `MAX_SD59x18 / UNIT`
///
/// @param x The basic integer to convert.
/// @return result The same number converted to SD59x18.
function convert(int256 x) pure returns (SD59x18 result) {
if (x < uMIN_SD59x18 / uUNIT) {
revert PRBMath_SD59x18_Convert_Underflow(x);
}
if (x > uMAX_SD59x18 / uUNIT) {
revert PRBMath_SD59x18_Convert_Overflow(x);
}
unchecked {
result = SD59x18.wrap(x * uUNIT);
}
}
/// @notice Converts an SD59x18 number to a simple integer by dividing it by `UNIT`.
/// @dev The result is rounded toward zero.
/// @param x The SD59x18 number to convert.
/// @return result The same number as a simple integer.
function convert(SD59x18 x) pure returns (int256 result) {
result = SD59x18.unwrap(x) / uUNIT;
}
================================================
FILE: src/sd59x18/Errors.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { SD59x18 } from "./ValueType.sol";
/// @notice Thrown when taking the absolute value of `MIN_SD59x18`.
error PRBMath_SD59x18_Abs_MinSD59x18();
/// @notice Thrown when ceiling a number overflows SD59x18.
error PRBMath_SD59x18_Ceil_Overflow(SD59x18 x);
/// @notice Thrown when converting a basic integer to the fixed-point format overflows SD59x18.
error PRBMath_SD59x18_Convert_Overflow(int256 x);
/// @notice Thrown when converting a basic integer to the fixed-point format underflows SD59x18.
error PRBMath_SD59x18_Convert_Underflow(int256 x);
/// @notice Thrown when dividing two numbers and one of them is `MIN_SD59x18`.
error PRBMath_SD59x18_Div_InputTooSmall();
/// @notice Thrown when dividing two numbers and one of the intermediary unsigned results overflows SD59x18.
error PRBMath_SD59x18_Div_Overflow(SD59x18 x, SD59x18 y);
/// @notice Thrown when taking the natural exponent of a base greater than 133_084258667509499441.
error PRBMath_SD59x18_Exp_InputTooBig(SD59x18 x);
/// @notice Thrown when taking the binary exponent of a base greater than 192e18.
error PRBMath_SD59x18_Exp2_InputTooBig(SD59x18 x);
/// @notice Thrown when flooring a number underflows SD59x18.
error PRBMath_SD59x18_Floor_Underflow(SD59x18 x);
/// @notice Thrown when taking the geometric mean of two numbers and their product is negative.
error PRBMath_SD59x18_Gm_NegativeProduct(SD59x18 x, SD59x18 y);
/// @notice Thrown when taking the geometric mean of two numbers and multiplying them overflows SD59x18.
error PRBMath_SD59x18_Gm_Overflow(SD59x18 x, SD59x18 y);
/// @notice Thrown when trying to cast an SD59x18 number that doesn't fit in SD1x18.
error PRBMath_SD59x18_IntoSD1x18_Overflow(SD59x18 x);
/// @notice Thrown when trying to cast an SD59x18 number that doesn't fit in SD1x18.
error PRBMath_SD59x18_IntoSD1x18_Underflow(SD59x18 x);
/// @notice Thrown when trying to cast an SD59x18 number that doesn't fit in SD21x18.
error PRBMath_SD59x18_IntoSD21x18_Overflow(SD59x18 x);
/// @notice Thrown when trying to cast an SD59x18 number that doesn't fit in SD21x18.
error PRBMath_SD59x18_IntoSD21x18_Underflow(SD59x18 x);
/// @notice Thrown when trying to cast an SD59x18 number that doesn't fit in UD2x18.
error PRBMath_SD59x18_IntoUD2x18_Overflow(SD59x18 x);
/// @notice Thrown when trying to cast an SD59x18 number that doesn't fit in UD2x18.
error PRBMath_SD59x18_IntoUD2x18_Underflow(SD59x18 x);
/// @notice Thrown when trying to cast an SD59x18 number that doesn't fit in UD21x18.
error PRBMath_SD59x18_IntoUD21x18_Overflow(SD59x18 x);
/// @notice Thrown when trying to cast an SD59x18 number that doesn't fit in UD21x18.
error PRBMath_SD59x18_IntoUD21x18_Underflow(SD59x18 x);
/// @notice Thrown when trying to cast an SD59x18 number that doesn't fit in UD60x18.
error PRBMath_SD59x18_IntoUD60x18_Underflow(SD59x18 x);
/// @notice Thrown when trying to cast an SD59x18 number that doesn't fit in uint128.
error PRBMath_SD59x18_IntoUint128_Overflow(SD59x18 x);
/// @notice Thrown when trying to cast an SD59x18 number that doesn't fit in uint128.
error PRBMath_SD59x18_IntoUint128_Underflow(SD59x18 x);
/// @notice Thrown when trying to cast an SD59x18 number that doesn't fit in uint256.
error PRBMath_SD59x18_IntoUint256_Underflow(SD59x18 x);
/// @notice Thrown when trying to cast an SD59x18 number that doesn't fit in uint40.
error PRBMath_SD59x18_IntoUint40_Overflow(SD59x18 x);
/// @notice Thrown when trying to cast an SD59x18 number that doesn't fit in uint40.
error PRBMath_SD59x18_IntoUint40_Underflow(SD59x18 x);
/// @notice Thrown when taking the logarithm of a number less than or equal to zero.
error PRBMath_SD59x18_Log_InputTooSmall(SD59x18 x);
/// @notice Thrown when multiplying two numbers and one of the inputs is `MIN_SD59x18`.
error PRBMath_SD59x18_Mul_InputTooSmall();
/// @notice Thrown when multiplying two numbers and the intermediary absolute result overflows SD59x18.
error PRBMath_SD59x18_Mul_Overflow(SD59x18 x, SD59x18 y);
/// @notice Thrown when raising a number to a power and the intermediary absolute result overflows SD59x18.
error PRBMath_SD59x18_Powu_Overflow(SD59x18 x, uint256 y);
/// @notice Thrown when taking the square root of a negative number.
error PRBMath_SD59x18_Sqrt_NegativeInput(SD59x18 x);
/// @notice Thrown when calculating the square root overflows SD59x18.
error PRBMath_SD59x18_Sqrt_Overflow(SD59x18 x);
================================================
FILE: src/sd59x18/Helpers.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { wrap } from "./Casting.sol";
import { SD59x18 } from "./ValueType.sol";
/// @notice Implements the checked addition operation (+) in the SD59x18 type.
function add(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) {
return wrap(x.unwrap() + y.unwrap());
}
/// @notice Implements the AND (&) bitwise operation in the SD59x18 type.
function and(SD59x18 x, int256 bits) pure returns (SD59x18 result) {
return wrap(x.unwrap() & bits);
}
/// @notice Implements the AND (&) bitwise operation in the SD59x18 type.
function and2(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) {
return wrap(x.unwrap() & y.unwrap());
}
/// @notice Implements the equal (=) operation in the SD59x18 type.
function eq(SD59x18 x, SD59x18 y) pure returns (bool result) {
result = x.unwrap() == y.unwrap();
}
/// @notice Implements the greater than operation (>) in the SD59x18 type.
function gt(SD59x18 x, SD59x18 y) pure returns (bool result) {
result = x.unwrap() > y.unwrap();
}
/// @notice Implements the greater than or equal to operation (>=) in the SD59x18 type.
function gte(SD59x18 x, SD59x18 y) pure returns (bool result) {
result = x.unwrap() >= y.unwrap();
}
/// @notice Implements a zero comparison check function in the SD59x18 type.
function isZero(SD59x18 x) pure returns (bool result) {
result = x.unwrap() == 0;
}
/// @notice Implements the left shift operation (<<) in the SD59x18 type.
function lshift(SD59x18 x, uint256 bits) pure returns (SD59x18 result) {
result = wrap(x.unwrap() << bits);
}
/// @notice Implements the lower than operation (<) in the SD59x18 type.
function lt(SD59x18 x, SD59x18 y) pure returns (bool result) {
result = x.unwrap() < y.unwrap();
}
/// @notice Implements the lower than or equal to operation (<=) in the SD59x18 type.
function lte(SD59x18 x, SD59x18 y) pure returns (bool result) {
result = x.unwrap() <= y.unwrap();
}
/// @notice Implements the unchecked modulo operation (%) in the SD59x18 type.
function mod(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) {
result = wrap(x.unwrap() % y.unwrap());
}
/// @notice Implements the not equal operation (!=) in the SD59x18 type.
function neq(SD59x18 x, SD59x18 y) pure returns (bool result) {
result = x.unwrap() != y.unwrap();
}
/// @notice Implements the NOT (~) bitwise operation in the SD59x18 type.
function not(SD59x18 x) pure returns (SD59x18 result) {
result = wrap(~x.unwrap());
}
/// @notice Implements the OR (|) bitwise operation in the SD59x18 type.
function or(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) {
result = wrap(x.unwrap() | y.unwrap());
}
/// @notice Implements the right shift operation (>>) in the SD59x18 type.
function rshift(SD59x18 x, uint256 bits) pure returns (SD59x18 result) {
result = wrap(x.unwrap() >> bits);
}
/// @notice Implements the checked subtraction operation (-) in the SD59x18 type.
function sub(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) {
result = wrap(x.unwrap() - y.unwrap());
}
/// @notice Implements the checked unary minus operation (-) in the SD59x18 type.
function unary(SD59x18 x) pure returns (SD59x18 result) {
result = wrap(-x.unwrap());
}
/// @notice Implements the unchecked addition operation (+) in the SD59x18 type.
function uncheckedAdd(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) {
unchecked {
result = wrap(x.unwrap() + y.unwrap());
}
}
/// @notice Implements the unchecked subtraction operation (-) in the SD59x18 type.
function uncheckedSub(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) {
unchecked {
result = wrap(x.unwrap() - y.unwrap());
}
}
/// @notice Implements the unchecked unary minus operation (-) in the SD59x18 type.
function uncheckedUnary(SD59x18 x) pure returns (SD59x18 result) {
unchecked {
result = wrap(-x.unwrap());
}
}
/// @notice Implements the XOR (^) bitwise operation in the SD59x18 type.
function xor(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) {
result = wrap(x.unwrap() ^ y.unwrap());
}
================================================
FILE: src/sd59x18/Math.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import "../Common.sol" as Common;
import "./Errors.sol" as Errors;
import {
uEXP_MAX_INPUT,
uEXP2_MAX_INPUT,
uEXP_MIN_THRESHOLD,
uEXP2_MIN_THRESHOLD,
uHALF_UNIT,
uLOG2_10,
uLOG2_E,
uMAX_SD59x18,
uMAX_WHOLE_SD59x18,
uMIN_SD59x18,
uMIN_WHOLE_SD59x18,
UNIT,
uUNIT,
uUNIT_SQUARED,
ZERO
} from "./Constants.sol";
import { wrap } from "./Helpers.sol";
import { SD59x18 } from "./ValueType.sol";
/// @notice Calculates the absolute value of x.
///
/// @dev Requirements:
/// - x > MIN_SD59x18.
///
/// @param x The SD59x18 number for which to calculate the absolute value.
/// @return result The absolute value of x as an SD59x18 number.
/// @custom:smtchecker abstract-function-nondet
function abs(SD59x18 x) pure returns (SD59x18 result) {
int256 xInt = x.unwrap();
if (xInt == uMIN_SD59x18) {
revert Errors.PRBMath_SD59x18_Abs_MinSD59x18();
}
result = xInt < 0 ? wrap(-xInt) : x;
}
/// @notice Calculates the arithmetic average of x and y.
///
/// @dev Notes:
/// - The result is rounded toward zero.
///
/// @param x The first operand as an SD59x18 number.
/// @param y The second operand as an SD59x18 number.
/// @return result The arithmetic average as an SD59x18 number.
/// @custom:smtchecker abstract-function-nondet
function avg(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) {
int256 xInt = x.unwrap();
int256 yInt = y.unwrap();
unchecked {
// This operation is equivalent to `x / 2 + y / 2`, and it can never overflow.
int256 sum = (xInt >> 1) + (yInt >> 1);
if (sum < 0) {
// If at least one of x and y is odd, add 1 to the result, because shifting negative numbers to the right
// rounds toward negative infinity. The right part is equivalent to `sum + (x % 2 == 1 || y % 2 == 1)`.
assembly ("memory-safe") {
result := add(sum, and(or(xInt, yInt), 1))
}
} else {
// Add 1 if both x and y are odd to account for the double 0.5 remainder truncated after shifting.
result = wrap(sum + (xInt & yInt & 1));
}
}
}
/// @notice Yields the smallest whole number greater than or equal to x.
///
/// @dev Optimized for fractional value inputs, because every whole value has (1e18 - 1) fractional counterparts.
/// See https://en.wikipedia.org/wiki/Floor_and_ceiling_functions.
///
/// Requirements:
/// - x ≤ MAX_WHOLE_SD59x18
///
/// @param x The SD59x18 number to ceil.
/// @return result The smallest whole number greater than or equal to x, as an SD59x18 number.
/// @custom:smtchecker abstract-function-nondet
function ceil(SD59x18 x) pure returns (SD59x18 result) {
int256 xInt = x.unwrap();
if (xInt > uMAX_WHOLE_SD59x18) {
revert Errors.PRBMath_SD59x18_Ceil_Overflow(x);
}
int256 remainder = xInt % uUNIT;
if (remainder == 0) {
result = x;
} else {
unchecked {
// Solidity uses C fmod style, which returns a modulus with the same sign as x.
int256 resultInt = xInt - remainder;
if (xInt > 0) {
resultInt += uUNIT;
}
result = wrap(resultInt);
}
}
}
/// @notice Divides two SD59x18 numbers, returning a new SD59x18 number.
///
/// @dev This is an extension of {Common.mulDiv} for signed numbers, which works by computing the signs and the absolute
/// values separately.
///
/// Notes:
/// - Refer to the notes in {Common.mulDiv}.
/// - The result is rounded toward zero.
///
/// Requirements:
/// - Refer to the requirements in {Common.mulDiv}.
/// - None of the inputs can be `MIN_SD59x18`.
/// - The denominator must not be zero.
/// - The result must fit in SD59x18.
///
/// @param x The numerator as an SD59x18 number.
/// @param y The denominator as an SD59x18 number.
/// @return result The quotient as an SD59x18 number.
/// @custom:smtchecker abstract-function-nondet
function div(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) {
int256 xInt = x.unwrap();
int256 yInt = y.unwrap();
if (xInt == uMIN_SD59x18 || yInt == uMIN_SD59x18) {
revert Errors.PRBMath_SD59x18_Div_InputTooSmall();
}
// Get hold of the absolute values of x and y.
uint256 xAbs;
uint256 yAbs;
unchecked {
xAbs = xInt < 0 ? uint256(-xInt) : uint256(xInt);
yAbs = yInt < 0 ? uint256(-yInt) : uint256(yInt);
}
// Compute the absolute value (x*UNIT÷y). The resulting value must fit in SD59x18.
uint256 resultAbs = Common.mulDiv(xAbs, uint256(uUNIT), yAbs);
if (resultAbs > uint256(uMAX_SD59x18)) {
revert Errors.PRBMath_SD59x18_Div_Overflow(x, y);
}
// Check if x and y have the same sign using two's complement representation. The left-most bit represents the sign (1 for
// negative, 0 for positive or zero).
bool sameSign = (xInt ^ yInt) > -1;
// If the inputs have the same sign, the result should be positive. Otherwise, it should be negative.
unchecked {
result = wrap(sameSign ? int256(resultAbs) : -int256(resultAbs));
}
}
/// @notice Calculates the natural exponent of x using the following formula:
///
/// $$
/// e^x = 2^{x * log_2{e}}
/// $$
///
/// @dev Notes:
/// - Refer to the notes in {exp2}.
///
/// Requirements:
/// - Refer to the requirements in {exp2}.
/// - x < 133_084258667509499441.
///
/// @param x The exponent as an SD59x18 number.
/// @return result The result as an SD59x18 number.
/// @custom:smtchecker abstract-function-nondet
function exp(SD59x18 x) pure returns (SD59x18 result) {
int256 xInt = x.unwrap();
// Any input less than the threshold returns zero.
// This check also prevents an overflow for very small numbers.
if (xInt < uEXP_MIN_THRESHOLD) {
return ZERO;
}
// This check prevents values greater than 192e18 from being passed to {exp2}.
if (xInt > uEXP_MAX_INPUT) {
revert Errors.PRBMath_SD59x18_Exp_InputTooBig(x);
}
unchecked {
// Inline the fixed-point multiplication to save gas.
int256 doubleUnitProduct = xInt * uLOG2_E;
result = exp2(wrap(doubleUnitProduct / uUNIT));
}
}
/// @notice Calculates the binary exponent of x using the binary fraction method using the following formula:
///
/// $$
/// 2^{-x} = \frac{1}{2^x}
/// $$
///
/// @dev See https://ethereum.stackexchange.com/q/79903/24693.
///
/// Notes:
/// - If x < -59_794705707972522261, the result is zero.
///
/// Requirements:
/// - x < 192e18.
/// - The result must fit in SD59x18.
///
/// @param x The exponent as an SD59x18 number.
/// @return result The result as an SD59x18 number.
/// @custom:smtchecker abstract-function-nondet
function exp2(SD59x18 x) pure returns (SD59x18 result) {
int256 xInt = x.unwrap();
if (xInt < 0) {
// The inverse of any number less than the threshold is truncated to zero.
if (xInt < uEXP2_MIN_THRESHOLD) {
return ZERO;
}
unchecked {
// Inline the fixed-point inversion to save gas.
result = wrap(uUNIT_SQUARED / exp2(wrap(-xInt)).unwrap());
}
} else {
// Numbers greater than or equal to 192e18 don't fit in the 192.64-bit format.
if (xInt > uEXP2_MAX_INPUT) {
revert Errors.PRBMath_SD59x18_Exp2_InputTooBig(x);
}
unchecked {
// Convert x to the 192.64-bit fixed-point format.
uint256 x_192x64 = uint256((xInt << 64) / uUNIT);
// It is safe to cast the result to int256 due to the checks above.
result = wrap(int256(Common.exp2(x_192x64)));
}
}
}
/// @notice Yields the greatest whole number less than or equal to x.
///
/// @dev Optimized for fractional value inputs, because for every whole value there are (1e18 - 1) fractional
/// counterparts. See https://en.wikipedia.org/wiki/Floor_and_ceiling_functions.
///
/// Requirements:
/// - x ≥ MIN_WHOLE_SD59x18
///
/// @param x The SD59x18 number to floor.
/// @return result The greatest whole number less than or equal to x, as an SD59x18 number.
/// @custom:smtchecker abstract-function-nondet
function floor(SD59x18 x) pure returns (SD59x18 result) {
int256 xInt = x.unwrap();
if (xInt < uMIN_WHOLE_SD59x18) {
revert Errors.PRBMath_SD59x18_Floor_Underflow(x);
}
int256 remainder = xInt % uUNIT;
if (remainder == 0) {
result = x;
} else {
unchecked {
// Solidity uses C fmod style, which returns a modulus with the same sign as x.
int256 resultInt = xInt - remainder;
if (xInt < 0) {
resultInt -= uUNIT;
}
result = wrap(resultInt);
}
}
}
/// @notice Yields the excess beyond the floor of x for positive numbers and the part of the number to the right.
/// of the radix point for negative numbers.
/// @dev Based on the odd function definition. https://en.wikipedia.org/wiki/Fractional_part
/// @param x The SD59x18 number to get the fractional part of.
/// @return result The fractional part of x as an SD59x18 number.
function frac(SD59x18 x) pure returns (SD59x18 result) {
result = wrap(x.unwrap() % uUNIT);
}
/// @notice Calculates the geometric mean of x and y, i.e. $\sqrt{x * y}$.
///
/// @dev Notes:
/// - The result is rounded toward zero.
///
/// Requirements:
/// - x * y must fit in SD59x18.
/// - x * y must not be negative, since complex numbers are not supported.
///
/// @param x The first operand as an SD59x18 number.
/// @param y The second operand as an SD59x18 number.
/// @return result The result as an SD59x18 number.
/// @custom:smtchecker abstract-function-nondet
function gm(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) {
int256 xInt = x.unwrap();
int256 yInt = y.unwrap();
if (xInt == 0 || yInt == 0) {
return ZERO;
}
unchecked {
// Equivalent to `xy / x != y`. Checking for overflow this way is faster than letting Solidity do it.
int256 xyInt = xInt * yInt;
if (xyInt / xInt != yInt) {
revert Errors.PRBMath_SD59x18_Gm_Overflow(x, y);
}
// The product must not be negative, since complex numbers are not supported.
if (xyInt < 0) {
revert Errors.PRBMath_SD59x18_Gm_NegativeProduct(x, y);
}
// We don't need to multiply the result by `UNIT` here because the x*y product picked up a factor of `UNIT`
// during multiplication. See the comments in {Common.sqrt}.
uint256 resultUint = Common.sqrt(uint256(xyInt));
result = wrap(int256(resultUint));
}
}
/// @notice Calculates the inverse of x.
///
/// @dev Notes:
/// - The result is rounded toward zero.
///
/// Requirements:
/// - x must not be zero.
///
/// @param x The SD59x18 number for which to calculate the inverse.
/// @return result The inverse as an SD59x18 number.
/// @custom:smtchecker abstract-function-nondet
function inv(SD59x18 x) pure returns (SD59x18 result) {
result = wrap(uUNIT_SQUARED / x.unwrap());
}
/// @notice Calculates the natural logarithm of x using the following formula:
///
/// $$
/// ln{x} = log_2{x} / log_2{e}
/// $$
///
/// @dev Notes:
/// - Refer to the notes in {log2}.
/// - The precision isn't sufficiently fine-grained to return exactly `UNIT` when the input is `E`.
///
/// Requirements:
/// - Refer to the requirements in {log2}.
///
/// @param x The SD59x18 number for which to calculate the natural logarithm.
/// @return result The natural logarithm as an SD59x18 number.
/// @custom:smtchecker abstract-function-nondet
function ln(SD59x18 x) pure returns (SD59x18 result) {
// Inline the fixed-point multiplication to save gas. This is overflow-safe because the maximum value that
// {log2} can return is ~195_205294292027477728.
result = wrap(log2(x).unwrap() * uUNIT / uLOG2_E);
}
/// @notice Calculates the common logarithm of x using the following formula:
///
/// $$
/// log_{10}{x} = log_2{x} / log_2{10}
/// $$
///
/// However, if x is an exact power of ten, a hard coded value is returned.
///
/// @dev Notes:
/// - Refer to the notes in {log2}.
///
/// Requirements:
/// - Refer to the requirements in {log2}.
///
/// @param x The SD59x18 number for which to calculate the common logarithm.
/// @return result The common logarithm as an SD59x18 number.
/// @custom:smtchecker abstract-function-nondet
function log10(SD59x18 x) pure returns (SD59x18 result) {
int256 xInt = x.unwrap();
if (xInt < 0) {
revert Errors.PRBMath_SD59x18_Log_InputTooSmall(x);
}
// Note that the `mul` in this block is the standard multiplication operation, not {SD59x18.mul}.
// prettier-ignore
assembly ("memory-safe") {
switch x
case 1 { result := mul(uUNIT, sub(0, 18)) }
case 10 { result := mul(uUNIT, sub(1, 18)) }
case 100 { result := mul(uUNIT, sub(2, 18)) }
case 1000 { result := mul(uUNIT, sub(3, 18)) }
case 10000 { result := mul(uUNIT, sub(4, 18)) }
case 100000 { result := mul(uUNIT, sub(5, 18)) }
case 1000000 { result := mul(uUNIT, sub(6, 18)) }
case 10000000 { result := mul(uUNIT, sub(7, 18)) }
case 100000000 { result := mul(uUNIT, sub(8, 18)) }
case 1000000000 { result := mul(uUNIT, sub(9, 18)) }
case 10000000000 { result := mul(uUNIT, sub(10, 18)) }
case 100000000000 { result := mul(uUNIT, sub(11, 18)) }
case 1000000000000 { result := mul(uUNIT, sub(12, 18)) }
case 10000000000000 { result := mul(uUNIT, sub(13, 18)) }
case 100000000000000 { result := mul(uUNIT, sub(14, 18)) }
case 1000000000000000 { result := mul(uUNIT, sub(15, 18)) }
case 10000000000000000 { result := mul(uUNIT, sub(16, 18)) }
case 100000000000000000 { result := mul(uUNIT, sub(17, 18)) }
case 1000000000000000000 { result := 0 }
case 10000000000000000000 { result := uUNIT }
case 100000000000000000000 { result := mul(uUNIT, 2) }
case 1000000000000000000000 { result := mul(uUNIT, 3) }
case 10000000000000000000000 { result := mul(uUNIT, 4) }
case 100000000000000000000000 { result := mul(uUNIT, 5) }
case 1000000000000000000000000 { result := mul(uUNIT, 6) }
case 10000000000000000000000000 { result := mul(uUNIT, 7) }
case 100000000000000000000000000 { result := mul(uUNIT, 8) }
case 1000000000000000000000000000 { result := mul(uUNIT, 9) }
case 10000000000000000000000000000 { result := mul(uUNIT, 10) }
case 100000000000000000000000000000 { result := mul(uUNIT, 11) }
case 1000000000000000000000000000000 { result := mul(uUNIT, 12) }
case 10000000000000000000000000000000 { result := mul(uUNIT, 13) }
case 100000000000000000000000000000000 { result := mul(uUNIT, 14) }
case 1000000000000000000000000000000000 { result := mul(uUNIT, 15) }
case 10000000000000000000000000000000000 { result := mul(uUNIT, 16) }
case 100000000000000000000000000000000000 { result := mul(uUNIT, 17) }
case 1000000000000000000000000000000000000 { result := mul(uUNIT, 18) }
case 10000000000000000000000000000000000000 { result := mul(uUNIT, 19) }
case 100000000000000000000000000000000000000 { result := mul(uUNIT, 20) }
case 1000000000000000000000000000000000000000 { result := mul(uUNIT, 21) }
case 10000000000000000000000000000000000000000 { result := mul(uUNIT, 22) }
case 100000000000000000000000000000000000000000 { result := mul(uUNIT, 23) }
case 1000000000000000000000000000000000000000000 { result := mul(uUNIT, 24) }
case 10000000000000000000000000000000000000000000 { result := mul(uUNIT, 25) }
case 100000000000000000000000000000000000000000000 { result := mul(uUNIT, 26) }
case 1000000000000000000000000000000000000000000000 { result := mul(uUNIT, 27) }
case 10000000000000000000000000000000000000000000000 { result := mul(uUNIT, 28) }
case 100000000000000000000000000000000000000000000000 { result := mul(uUNIT, 29) }
case 1000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 30) }
case 10000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 31) }
case 100000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 32) }
case 1000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 33) }
case 10000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 34) }
case 100000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 35) }
case 1000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 36) }
case 10000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 37) }
case 100000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 38) }
case 1000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 39) }
case 10000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 40) }
case 100000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 41) }
case 1000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 42) }
case 10000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 43) }
case 100000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 44) }
case 1000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 45) }
case 10000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 46) }
case 100000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 47) }
case 1000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 48) }
case 10000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 49) }
case 100000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 50) }
case 1000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 51) }
case 10000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 52) }
case 100000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 53) }
case 1000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 54) }
case 10000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 55) }
case 100000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 56) }
case 1000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 57) }
case 10000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 58) }
default { result := uMAX_SD59x18 }
}
if (result.unwrap() == uMAX_SD59x18) {
unchecked {
// Inline the fixed-point division to save gas.
result = wrap(log2(x).unwrap() * uUNIT / uLOG2_10);
}
}
}
/// @notice Calculates the binary logarithm of x using the iterative approximation algorithm:
///
/// $$
/// log_2{x} = n + log_2{y}, \text{ where } y = x*2^{-n}, \ y \in [1, 2)
/// $$
///
/// For $0 \leq x \lt 1$, the input is inverted:
///
/// $$
/// log_2{x} = -log_2{\frac{1}{x}}
/// $$
///
/// @dev See https://en.wikipedia.org/wiki/Binary_logarithm#Iterative_approximation.
///
/// Notes:
/// - Due to the lossy precision of the iterative approximation, the results are not perfectly accurate to the last decimal.
///
/// Requirements:
/// - x > 0
///
/// @param x The SD59x18 number for which to calculate the binary logarithm.
/// @return result The binary logarithm as an SD59x18 number.
/// @custom:smtchecker abstract-function-nondet
function log2(SD59x18 x) pure returns (SD59x18 result) {
int256 xInt = x.unwrap();
if (xInt <= 0) {
revert Errors.PRBMath_SD59x18_Log_InputTooSmall(x);
}
unchecked {
int256 sign;
if (xInt >= uUNIT) {
sign = 1;
} else {
sign = -1;
// Inline the fixed-point inversion to save gas.
xInt = uUNIT_SQUARED / xInt;
}
// Calculate the integer part of the logarithm.
uint256 n = Common.msb(uint256(xInt / uUNIT));
// This is the integer part of the logarithm as an SD59x18 number. The operation can't overflow
// because n is at most 255, `UNIT` is 1e18, and the sign is either 1 or -1.
int256 resultInt = int256(n) * uUNIT;
// Calculate $y = x * 2^{-n}$.
int256 y = xInt >> n;
// If y is the unit number, the fractional part is zero.
if (y == uUNIT) {
return wrap(resultInt * sign);
}
// Calculate the fractional part via the iterative approximation.
// The `delta >>= 1` part is equivalent to `delta /= 2`, but shifting bits is more gas efficient.
int256 doubleUnit = 2e18;
for (int256 delta = uHALF_UNIT; delta > 0; delta >>= 1) {
y = (y * y) / uUNIT;
// Is y^2 >= 2e18 and so in the range [2e18, 4e18)?
if (y >= doubleUnit) {
// Add the 2^{-m} factor to the logarithm.
resultInt = resultInt + delta;
// Halve y, which corresponds to z/2 in the Wikipedia article.
y >>= 1;
}
}
resultInt *= sign;
result = wrap(resultInt);
}
}
/// @notice Multiplies two SD59x18 numbers together, returning a new SD59x18 number.
///
/// @dev Notes:
/// - Refer to the notes in {Common.mulDiv18}.
///
/// Requirements:
/// - Refer to the requirements in {Common.mulDiv18}.
/// - None of the inputs can be `MIN_SD59x18`.
/// - The result must fit in SD59x18.
///
/// @param x The multiplicand as an SD59x18 number.
/// @param y The multiplier as an SD59x18 number.
/// @return result The product as an SD59x18 number.
/// @custom:smtchecker abstract-function-nondet
function mul(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) {
int256 xInt = x.unwrap();
int256 yInt = y.unwrap();
if (xInt == uMIN_SD59x18 || yInt == uMIN_SD59x18) {
revert Errors.PRBMath_SD59x18_Mul_InputTooSmall();
}
// Get hold of the absolute values of x and y.
uint256 xAbs;
uint256 yAbs;
unchecked {
xAbs = xInt < 0 ? uint256(-xInt) : uint256(xInt);
yAbs = yInt < 0 ? uint256(-yInt) : uint256(yInt);
}
// Compute the absolute value (x*y÷UNIT). The resulting value must fit in SD59x18.
uint256 resultAbs = Common.mulDiv18(xAbs, yAbs);
if (resultAbs > uint256(uMAX_SD59x18)) {
revert Errors.PRBMath_SD59x18_Mul_Overflow(x, y);
}
// Check if x and y have the same sign using two's complement representation. The left-most bit represents the sign (1 for
// negative, 0 for positive or zero).
bool sameSign = (xInt ^ yInt) > -1;
// If the inputs have the same sign, the result should be positive. Otherwise, it should be negative.
unchecked {
result = wrap(sameSign ? int256(resultAbs) : -int256(resultAbs));
}
}
/// @notice Raises x to the power of y using the following formula:
///
/// $$
/// x^y = 2^{log_2{x} * y}
/// $$
///
/// @dev Notes:
/// - Refer to the notes in {exp2}, {log2}, and {mul}.
/// - Returns `UNIT` for 0^0.
///
/// Requirements:
/// - Refer to the requirements in {exp2}, {log2}, and {mul}.
///
/// @param x The base as an SD59x18 number.
/// @param y Exponent to raise x to, as an SD59x18 number
/// @return result x raised to power y, as an SD59x18 number.
/// @custom:smtchecker abstract-function-nondet
function pow(SD59x18 x, SD59x18 y) pure returns (SD59x18 result) {
int256 xInt = x.unwrap();
int256 yInt = y.unwrap();
// If both x and y are zero, the result is `UNIT`. If just x is zero, the result is always zero.
if (xInt == 0) {
return yInt == 0 ? UNIT : ZERO;
}
// If x is `UNIT`, the result is always `UNIT`.
else if (xInt == uUNIT) {
return UNIT;
}
// If y is zero, the result is always `UNIT`.
if (yInt == 0) {
return UNIT;
}
// If y is `UNIT`, the result is always x.
else if (yInt == uUNIT) {
return x;
}
// Calculate the result using the formula.
result = exp2(mul(log2(x), y));
}
/// @notice Raises x (an SD59x18 number) to the power y (an unsigned basic integer) using the well-known
/// algorithm "exponentiation by squaring".
///
/// @dev See https://en.wikipedia.org/wiki/Exponentiation_by_squaring.
///
/// Notes:
/// - Refer to the notes in {Common.mulDiv18}.
/// - Returns `UNIT` for 0^0.
///
/// Requirements:
/// - Refer to the requirements in {abs} and {Common.mulDiv18}.
/// - The result must fit in SD59x18.
///
/// @param x The base as an SD59x18 number.
/// @param y The exponent as a uint256.
/// @return result The result as an SD59x18 number.
/// @custom:smtchecker abstract-function-nondet
function powu(SD59x18 x, uint256 y) pure returns (SD59x18 result) {
uint256 xAbs = uint256(abs(x).unwrap());
// Calculate the first iteration of the loop in advance.
uint256 resultAbs = y & 1 > 0 ? xAbs : uint256(uUNIT);
// Equivalent to `for(y /= 2; y > 0; y /= 2)`.
uint256 yAux = y;
for (yAux >>= 1; yAux > 0; yAux >>= 1) {
xAbs = Common.mulDiv18(xAbs, xAbs);
// Equivalent to `y % 2 == 1`.
if (yAux & 1 > 0) {
resultAbs = Common.mulDiv18(resultAbs, xAbs);
}
}
// The result must fit in SD59x18.
if (resultAbs > uint256(uMAX_SD59x18)) {
revert Errors.PRBMath_SD59x18_Powu_Overflow(x, y);
}
unchecked {
// Is the base negative and the exponent odd? If yes, the result should be negative.
int256 resultInt = int256(resultAbs);
bool isNegative = x.unwrap() < 0 && y & 1 == 1;
if (isNegative) {
resultInt = -resultInt;
}
result = wrap(resultInt);
}
}
/// @notice Calculates the square root of x using the Babylonian method.
///
/// @dev See https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method.
///
/// Notes:
/// - Only the positive root is returned.
/// - The result is rounded toward zero.
///
/// Requirements:
/// - x ≥ 0, since complex numbers are not supported.
/// - x ≤ MAX_SD59x18 / UNIT
///
/// @param x The SD59x18 number for which to calculate the square root.
/// @return result The result as an SD59x18 number.
/// @custom:smtchecker abstract-function-nondet
function sqrt(SD59x18 x) pure returns (SD59x18 result) {
int256 xInt = x.unwrap();
if (xInt < 0) {
revert Errors.PRBMath_SD59x18_Sqrt_NegativeInput(x);
}
if (xInt > uMAX_SD59x18 / uUNIT) {
revert Errors.PRBMath_SD59x18_Sqrt_Overflow(x);
}
unchecked {
// Multiply x by `UNIT` to account for the factor of `UNIT` picked up when multiplying two SD59x18 numbers.
// In this case, the two numbers are both the square root.
uint256 resultUint = Common.sqrt(uint256(xInt * uUNIT));
result = wrap(int256(resultUint));
}
}
================================================
FILE: src/sd59x18/ValueType.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import "./Casting.sol" as Casting;
import "./Helpers.sol" as Helpers;
import "./Math.sol" as Math;
/// @notice The signed 59.18-decimal fixed-point number representation, which can have up to 59 digits and up to 18
/// decimals. The values of this are bound by the minimum and the maximum values permitted by the underlying Solidity
/// type int256.
type SD59x18 is int256;
/*//////////////////////////////////////////////////////////////////////////
CASTING
//////////////////////////////////////////////////////////////////////////*/
using {
Casting.intoInt256,
Casting.intoSD1x18,
Casting.intoSD21x18,
Casting.intoUD2x18,
Casting.intoUD21x18,
Casting.intoUD60x18,
Casting.intoUint256,
Casting.intoUint128,
Casting.intoUint40,
Casting.unwrap
} for SD59x18 global;
/*//////////////////////////////////////////////////////////////////////////
MATHEMATICAL FUNCTIONS
//////////////////////////////////////////////////////////////////////////*/
using {
Math.abs,
Math.avg,
Math.ceil,
Math.div,
Math.exp,
Math.exp2,
Math.floor,
Math.frac,
Math.gm,
Math.inv,
Math.log10,
Math.log2,
Math.ln,
Math.mul,
Math.pow,
Math.powu,
Math.sqrt
} for SD59x18 global;
/*//////////////////////////////////////////////////////////////////////////
HELPER FUNCTIONS
//////////////////////////////////////////////////////////////////////////*/
using {
Helpers.add,
Helpers.and,
Helpers.eq,
Helpers.gt,
Helpers.gte,
Helpers.isZero,
Helpers.lshift,
Helpers.lt,
Helpers.lte,
Helpers.mod,
Helpers.neq,
Helpers.not,
Helpers.or,
Helpers.rshift,
Helpers.sub,
Helpers.uncheckedAdd,
Helpers.uncheckedSub,
Helpers.uncheckedUnary,
Helpers.xor
} for SD59x18 global;
/*//////////////////////////////////////////////////////////////////////////
OPERATORS
//////////////////////////////////////////////////////////////////////////*/
// The global "using for" directive makes it possible to use these operators on the SD59x18 type.
using {
Helpers.add as +,
Helpers.and2 as &,
Math.div as /,
Helpers.eq as ==,
Helpers.gt as >,
Helpers.gte as >=,
Helpers.lt as <,
Helpers.lte as <=,
Helpers.mod as %,
Math.mul as *,
Helpers.neq as !=,
Helpers.not as ~,
Helpers.or as |,
Helpers.sub as -,
Helpers.unary as -,
Helpers.xor as ^
} for SD59x18 global;
================================================
FILE: src/ud21x18/Casting.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import "../Common.sol" as Common;
import "./Errors.sol" as Errors;
import { SD59x18 } from "../sd59x18/ValueType.sol";
import { UD60x18 } from "../ud60x18/ValueType.sol";
import { UD21x18 } from "./ValueType.sol";
/// @notice Casts a UD21x18 number into SD59x18.
/// @dev There is no overflow check because UD21x18 ⊆ SD59x18.
function intoSD59x18(UD21x18 x) pure returns (SD59x18 result) {
result = SD59x18.wrap(int256(uint256(UD21x18.unwrap(x))));
}
/// @notice Casts a UD21x18 number into UD60x18.
/// @dev There is no overflow check because UD21x18 ⊆ UD60x18.
function intoUD60x18(UD21x18 x) pure returns (UD60x18 result) {
result = UD60x18.wrap(UD21x18.unwrap(x));
}
/// @notice Casts a UD21x18 number into uint128.
/// @dev This is basically an alias for {unwrap}.
function intoUint128(UD21x18 x) pure returns (uint128 result) {
result = UD21x18.unwrap(x);
}
/// @notice Casts a UD21x18 number into uint256.
/// @dev There is no overflow check because UD21x18 ⊆ uint256.
function intoUint256(UD21x18 x) pure returns (uint256 result) {
result = uint256(UD21x18.unwrap(x));
}
/// @notice Casts a UD21x18 number into uint40.
/// @dev Requirements:
/// - x ≤ MAX_UINT40
function intoUint40(UD21x18 x) pure returns (uint40 result) {
uint128 xUint = UD21x18.unwrap(x);
if (xUint > uint128(Common.MAX_UINT40)) {
revert Errors.PRBMath_UD21x18_IntoUint40_Overflow(x);
}
result = uint40(xUint);
}
/// @notice Alias for {wrap}.
function ud21x18(uint128 x) pure returns (UD21x18 result) {
result = UD21x18.wrap(x);
}
/// @notice Unwrap a UD21x18 number into uint128.
function unwrap(UD21x18 x) pure returns (uint128 result) {
result = UD21x18.unwrap(x);
}
/// @notice Wraps a uint128 number into UD21x18.
function wrap(uint128 x) pure returns (UD21x18 result) {
result = UD21x18.wrap(x);
}
================================================
FILE: src/ud21x18/Constants.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { UD21x18 } from "./ValueType.sol";
/// @dev Euler's number as a UD21x18 number.
UD21x18 constant E = UD21x18.wrap(2_718281828459045235);
/// @dev The maximum value a UD21x18 number can have.
uint128 constant uMAX_UD21x18 = 340282366920938463463_374607431768211455;
UD21x18 constant MAX_UD21x18 = UD21x18.wrap(uMAX_UD21x18);
/// @dev PI as a UD21x18 number.
UD21x18 constant PI = UD21x18.wrap(3_141592653589793238);
/// @dev The unit number, which gives the decimal precision of UD21x18.
uint256 constant uUNIT = 1e18;
UD21x18 constant UNIT = UD21x18.wrap(1e18);
================================================
FILE: src/ud21x18/Errors.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { UD21x18 } from "./ValueType.sol";
/// @notice Thrown when trying to cast a UD21x18 number that doesn't fit in uint40.
error PRBMath_UD21x18_IntoUint40_Overflow(UD21x18 x);
================================================
FILE: src/ud21x18/ValueType.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import "./Casting.sol" as Casting;
/// @notice The unsigned 21.18-decimal fixed-point number representation, which can have up to 21 digits and up to 18
/// decimals. The values of this are bound by the minimum and the maximum values permitted by the underlying Solidity
/// type uint128. This is useful when end users want to use uint128 to save gas, e.g. with tight variable packing in contract
/// storage.
type UD21x18 is uint128;
/*//////////////////////////////////////////////////////////////////////////
CASTING
//////////////////////////////////////////////////////////////////////////*/
using {
Casting.intoSD59x18,
Casting.intoUD60x18,
Casting.intoUint128,
Casting.intoUint256,
Casting.intoUint40,
Casting.unwrap
} for UD21x18 global;
================================================
FILE: src/ud2x18/Casting.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import "../Common.sol" as Common;
import "./Errors.sol" as Errors;
import { SD59x18 } from "../sd59x18/ValueType.sol";
import { UD60x18 } from "../ud60x18/ValueType.sol";
import { UD2x18 } from "./ValueType.sol";
/// @notice Casts a UD2x18 number into SD59x18.
/// @dev There is no overflow check because UD2x18 ⊆ SD59x18.
function intoSD59x18(UD2x18 x) pure returns (SD59x18 result) {
result = SD59x18.wrap(int256(uint256(UD2x18.unwrap(x))));
}
/// @notice Casts a UD2x18 number into UD60x18.
/// @dev There is no overflow check because UD2x18 ⊆ UD60x18.
function intoUD60x18(UD2x18 x) pure returns (UD60x18 result) {
result = UD60x18.wrap(UD2x18.unwrap(x));
}
/// @notice Casts a UD2x18 number into uint128.
/// @dev There is no overflow check because UD2x18 ⊆ uint128.
function intoUint128(UD2x18 x) pure returns (uint128 result) {
result = uint128(UD2x18.unwrap(x));
}
/// @notice Casts a UD2x18 number into uint256.
/// @dev There is no overflow check because UD2x18 ⊆ uint256.
function intoUint256(UD2x18 x) pure returns (uint256 result) {
result = uint256(UD2x18.unwrap(x));
}
/// @notice Casts a UD2x18 number into uint40.
/// @dev Requirements:
/// - x ≤ MAX_UINT40
function intoUint40(UD2x18 x) pure returns (uint40 result) {
uint64 xUint = UD2x18.unwrap(x);
if (xUint > uint64(Common.MAX_UINT40)) {
revert Errors.PRBMath_UD2x18_IntoUint40_Overflow(x);
}
result = uint40(xUint);
}
/// @notice Alias for {wrap}.
function ud2x18(uint64 x) pure returns (UD2x18 result) {
result = UD2x18.wrap(x);
}
/// @notice Unwrap a UD2x18 number into uint64.
function unwrap(UD2x18 x) pure returns (uint64 result) {
result = UD2x18.unwrap(x);
}
/// @notice Wraps a uint64 number into UD2x18.
function wrap(uint64 x) pure returns (UD2x18 result) {
result = UD2x18.wrap(x);
}
================================================
FILE: src/ud2x18/Constants.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { UD2x18 } from "./ValueType.sol";
/// @dev Euler's number as a UD2x18 number.
UD2x18 constant E = UD2x18.wrap(2_718281828459045235);
/// @dev The maximum value a UD2x18 number can have.
uint64 constant uMAX_UD2x18 = 18_446744073709551615;
UD2x18 constant MAX_UD2x18 = UD2x18.wrap(uMAX_UD2x18);
/// @dev PI as a UD2x18 number.
UD2x18 constant PI = UD2x18.wrap(3_141592653589793238);
/// @dev The unit number, which gives the decimal precision of UD2x18.
UD2x18 constant UNIT = UD2x18.wrap(1e18);
uint64 constant uUNIT = 1e18;
================================================
FILE: src/ud2x18/Errors.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { UD2x18 } from "./ValueType.sol";
/// @notice Thrown when trying to cast a UD2x18 number that doesn't fit in uint40.
error PRBMath_UD2x18_IntoUint40_Overflow(UD2x18 x);
================================================
FILE: src/ud2x18/ValueType.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import "./Casting.sol" as Casting;
/// @notice The unsigned 2.18-decimal fixed-point number representation, which can have up to 2 digits and up to 18
/// decimals. The values of this are bound by the minimum and the maximum values permitted by the underlying Solidity
/// type uint64. This is useful when end users want to use uint64 to save gas, e.g. with tight variable packing in contract
/// storage.
type UD2x18 is uint64;
/*//////////////////////////////////////////////////////////////////////////
CASTING
//////////////////////////////////////////////////////////////////////////*/
using {
Casting.intoSD59x18,
Casting.intoUD60x18,
Casting.intoUint128,
Casting.intoUint256,
Casting.intoUint40,
Casting.unwrap
} for UD2x18 global;
================================================
FILE: src/ud60x18/Casting.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import "./Errors.sol" as CastingErrors;
import { MAX_UINT128, MAX_UINT40 } from "../Common.sol";
import { uMAX_SD1x18 } from "../sd1x18/Constants.sol";
import { SD1x18 } from "../sd1x18/ValueType.sol";
import { uMAX_SD21x18 } from "../sd21x18/Constants.sol";
import { SD21x18 } from "../sd21x18/ValueType.sol";
import { uMAX_SD59x18 } from "../sd59x18/Constants.sol";
import { SD59x18 } from "../sd59x18/ValueType.sol";
import { uMAX_UD2x18 } from "../ud2x18/Constants.sol";
import { uMAX_UD21x18 } from "../ud21x18/Constants.sol";
import { UD2x18 } from "../ud2x18/ValueType.sol";
import { UD21x18 } from "../ud21x18/ValueType.sol";
import { UD60x18 } from "./ValueType.sol";
/// @notice Casts a UD60x18 number into SD1x18.
/// @dev Requirements:
/// - x ≤ uMAX_SD1x18
function intoSD1x18(UD60x18 x) pure returns (SD1x18 result) {
uint256 xUint = UD60x18.unwrap(x);
if (xUint > uint256(int256(uMAX_SD1x18))) {
revert CastingErrors.PRBMath_UD60x18_IntoSD1x18_Overflow(x);
}
result = SD1x18.wrap(int64(uint64(xUint)));
}
/// @notice Casts a UD60x18 number into SD21x18.
/// @dev Requirements:
/// - x ≤ uMAX_SD21x18
function intoSD21x18(UD60x18 x) pure returns (SD21x18 result) {
uint256 xUint = UD60x18.unwrap(x);
if (xUint > uint256(int256(uMAX_SD21x18))) {
revert CastingErrors.PRBMath_UD60x18_IntoSD21x18_Overflow(x);
}
result = SD21x18.wrap(int128(uint128(xUint)));
}
/// @notice Casts a UD60x18 number into UD2x18.
/// @dev Requirements:
/// - x ≤ uMAX_UD2x18
function intoUD2x18(UD60x18 x) pure returns (UD2x18 result) {
uint256 xUint = UD60x18.unwrap(x);
if (xUint > uMAX_UD2x18) {
revert CastingErrors.PRBMath_UD60x18_IntoUD2x18_Overflow(x);
}
result = UD2x18.wrap(uint64(xUint));
}
/// @notice Casts a UD60x18 number into UD21x18.
/// @dev Requirements:
/// - x ≤ uMAX_UD21x18
function intoUD21x18(UD60x18 x) pure returns (UD21x18 result) {
uint256 xUint = UD60x18.unwrap(x);
if (xUint > uMAX_UD21x18) {
revert CastingErrors.PRBMath_UD60x18_IntoUD21x18_Overflow(x);
}
result = UD21x18.wrap(uint128(xUint));
}
/// @notice Casts a UD60x18 number into SD59x18.
/// @dev Requirements:
/// - x ≤ uMAX_SD59x18
function intoSD59x18(UD60x18 x) pure returns (SD59x18 result) {
uint256 xUint = UD60x18.unwrap(x);
if (xUint > uint256(uMAX_SD59x18)) {
revert CastingErrors.PRBMath_UD60x18_IntoSD59x18_Overflow(x);
}
result = SD59x18.wrap(int256(xUint));
}
/// @notice Casts a UD60x18 number into uint128.
/// @dev This is basically an alias for {unwrap}.
function intoUint256(UD60x18 x) pure returns (uint256 result) {
result = UD60x18.unwrap(x);
}
/// @notice Casts a UD60x18 number into uint128.
/// @dev Requirements:
/// - x ≤ MAX_UINT128
function intoUint128(UD60x18 x) pure returns (uint128 result) {
uint256 xUint = UD60x18.unwrap(x);
if (xUint > MAX_UINT128) {
revert CastingErrors.PRBMath_UD60x18_IntoUint128_Overflow(x);
}
result = uint128(xUint);
}
/// @notice Casts a UD60x18 number into uint40.
/// @dev Requirements:
/// - x ≤ MAX_UINT40
function intoUint40(UD60x18 x) pure returns (uint40 result) {
uint256 xUint = UD60x18.unwrap(x);
if (xUint > MAX_UINT40) {
revert CastingErrors.PRBMath_UD60x18_IntoUint40_Overflow(x);
}
result = uint40(xUint);
}
/// @notice Alias for {wrap}.
function ud(uint256 x) pure returns (UD60x18 result) {
result = UD60x18.wrap(x);
}
/// @notice Alias for {wrap}.
function ud60x18(uint256 x) pure returns (UD60x18 result) {
result = UD60x18.wrap(x);
}
/// @notice Unwraps a UD60x18 number into uint256.
function unwrap(UD60x18 x) pure returns (uint256 result) {
result = UD60x18.unwrap(x);
}
/// @notice Wraps a uint256 number into the UD60x18 value type.
function wrap(uint256 x) pure returns (UD60x18 result) {
result = UD60x18.wrap(x);
}
================================================
FILE: src/ud60x18/Constants.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { UD60x18 } from "./ValueType.sol";
// NOTICE: the "u" prefix stands for "unwrapped".
/// @dev Euler's number as a UD60x18 number.
UD60x18 constant E = UD60x18.wrap(2_718281828459045235);
/// @dev The maximum input permitted in {exp}.
uint256 constant uEXP_MAX_INPUT = 133_084258667509499440;
UD60x18 constant EXP_MAX_INPUT = UD60x18.wrap(uEXP_MAX_INPUT);
/// @dev The maximum input permitted in {exp2}.
uint256 constant uEXP2_MAX_INPUT = 192e18 - 1;
UD60x18 constant EXP2_MAX_INPUT = UD60x18.wrap(uEXP2_MAX_INPUT);
/// @dev Half the UNIT number.
uint256 constant uHALF_UNIT = 0.5e18;
UD60x18 constant HALF_UNIT = UD60x18.wrap(uHALF_UNIT);
/// @dev $log_2(10)$ as a UD60x18 number.
uint256 constant uLOG2_10 = 3_321928094887362347;
UD60x18 constant LOG2_10 = UD60x18.wrap(uLOG2_10);
/// @dev $log_2(e)$ as a UD60x18 number.
uint256 constant uLOG2_E = 1_442695040888963407;
UD60x18 constant LOG2_E = UD60x18.wrap(uLOG2_E);
/// @dev The maximum value a UD60x18 number can have.
uint256 constant uMAX_UD60x18 = 115792089237316195423570985008687907853269984665640564039457_584007913129639935;
UD60x18 constant MAX_UD60x18 = UD60x18.wrap(uMAX_UD60x18);
/// @dev The maximum whole value a UD60x18 number can have.
uint256 constant uMAX_WHOLE_UD60x18 = 115792089237316195423570985008687907853269984665640564039457_000000000000000000;
UD60x18 constant MAX_WHOLE_UD60x18 = UD60x18.wrap(uMAX_WHOLE_UD60x18);
/// @dev PI as a UD60x18 number.
UD60x18 constant PI = UD60x18.wrap(3_141592653589793238);
/// @dev The unit number, which gives the decimal precision of UD60x18.
uint256 constant uUNIT = 1e18;
UD60x18 constant UNIT = UD60x18.wrap(uUNIT);
/// @dev The unit number squared.
uint256 constant uUNIT_SQUARED = 1e36;
UD60x18 constant UNIT_SQUARED = UD60x18.wrap(uUNIT_SQUARED);
/// @dev Zero as a UD60x18 number.
UD60x18 constant ZERO = UD60x18.wrap(0);
================================================
FILE: src/ud60x18/Conversions.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { uMAX_UD60x18, uUNIT } from "./Constants.sol";
import { PRBMath_UD60x18_Convert_Overflow } from "./Errors.sol";
import { UD60x18 } from "./ValueType.sol";
/// @notice Converts a UD60x18 number to a simple integer by dividing it by `UNIT`.
/// @dev The result is rounded toward zero.
/// @param x The UD60x18 number to convert.
/// @return result The same number in basic integer form.
function convert(UD60x18 x) pure returns (uint256 result) {
result = UD60x18.unwrap(x) / uUNIT;
}
/// @notice Converts a simple integer to UD60x18 by multiplying it by `UNIT`.
///
/// @dev Requirements:
/// - x ≤ MAX_UD60x18 / UNIT
///
/// @param x The basic integer to convert.
/// @return result The same number converted to UD60x18.
function convert(uint256 x) pure returns (UD60x18 result) {
if (x > uMAX_UD60x18 / uUNIT) {
revert PRBMath_UD60x18_Convert_Overflow(x);
}
unchecked {
result = UD60x18.wrap(x * uUNIT);
}
}
================================================
FILE: src/ud60x18/Errors.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { UD60x18 } from "./ValueType.sol";
/// @notice Thrown when ceiling a number overflows UD60x18.
error PRBMath_UD60x18_Ceil_Overflow(UD60x18 x);
/// @notice Thrown when converting a basic integer to the fixed-point format overflows UD60x18.
error PRBMath_UD60x18_Convert_Overflow(uint256 x);
/// @notice Thrown when taking the natural exponent of a base greater than 133_084258667509499441.
error PRBMath_UD60x18_Exp_InputTooBig(UD60x18 x);
/// @notice Thrown when taking the binary exponent of a base greater than 192e18.
error PRBMath_UD60x18_Exp2_InputTooBig(UD60x18 x);
/// @notice Thrown when taking the geometric mean of two numbers and multiplying them overflows UD60x18.
error PRBMath_UD60x18_Gm_Overflow(UD60x18 x, UD60x18 y);
/// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in SD1x18.
error PRBMath_UD60x18_IntoSD1x18_Overflow(UD60x18 x);
/// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in SD21x18.
error PRBMath_UD60x18_IntoSD21x18_Overflow(UD60x18 x);
/// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in SD59x18.
error PRBMath_UD60x18_IntoSD59x18_Overflow(UD60x18 x);
/// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in UD2x18.
error PRBMath_UD60x18_IntoUD2x18_Overflow(UD60x18 x);
/// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in UD21x18.
error PRBMath_UD60x18_IntoUD21x18_Overflow(UD60x18 x);
/// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in uint128.
error PRBMath_UD60x18_IntoUint128_Overflow(UD60x18 x);
/// @notice Thrown when trying to cast a UD60x18 number that doesn't fit in uint40.
error PRBMath_UD60x18_IntoUint40_Overflow(UD60x18 x);
/// @notice Thrown when taking the logarithm of a number less than UNIT.
error PRBMath_UD60x18_Log_InputTooSmall(UD60x18 x);
/// @notice Thrown when calculating the square root overflows UD60x18.
error PRBMath_UD60x18_Sqrt_Overflow(UD60x18 x);
================================================
FILE: src/ud60x18/Helpers.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import { wrap } from "./Casting.sol";
import { UD60x18 } from "./ValueType.sol";
/// @notice Implements the checked addition operation (+) in the UD60x18 type.
function add(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
result = wrap(x.unwrap() + y.unwrap());
}
/// @notice Implements the AND (&) bitwise operation in the UD60x18 type.
function and(UD60x18 x, uint256 bits) pure returns (UD60x18 result) {
result = wrap(x.unwrap() & bits);
}
/// @notice Implements the AND (&) bitwise operation in the UD60x18 type.
function and2(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
result = wrap(x.unwrap() & y.unwrap());
}
/// @notice Implements the equal operation (==) in the UD60x18 type.
function eq(UD60x18 x, UD60x18 y) pure returns (bool result) {
result = x.unwrap() == y.unwrap();
}
/// @notice Implements the greater than operation (>) in the UD60x18 type.
function gt(UD60x18 x, UD60x18 y) pure returns (bool result) {
result = x.unwrap() > y.unwrap();
}
/// @notice Implements the greater than or equal to operation (>=) in the UD60x18 type.
function gte(UD60x18 x, UD60x18 y) pure returns (bool result) {
result = x.unwrap() >= y.unwrap();
}
/// @notice Implements a zero comparison check function in the UD60x18 type.
function isZero(UD60x18 x) pure returns (bool result) {
// This wouldn't work if x could be negative.
result = x.unwrap() == 0;
}
/// @notice Implements the left shift operation (<<) in the UD60x18 type.
function lshift(UD60x18 x, uint256 bits) pure returns (UD60x18 result) {
result = wrap(x.unwrap() << bits);
}
/// @notice Implements the lower than operation (<) in the UD60x18 type.
function lt(UD60x18 x, UD60x18 y) pure returns (bool result) {
result = x.unwrap() < y.unwrap();
}
/// @notice Implements the lower than or equal to operation (<=) in the UD60x18 type.
function lte(UD60x18 x, UD60x18 y) pure returns (bool result) {
result = x.unwrap() <= y.unwrap();
}
/// @notice Implements the checked modulo operation (%) in the UD60x18 type.
function mod(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
result = wrap(x.unwrap() % y.unwrap());
}
/// @notice Implements the not equal operation (!=) in the UD60x18 type.
function neq(UD60x18 x, UD60x18 y) pure returns (bool result) {
result = x.unwrap() != y.unwrap();
}
/// @notice Implements the NOT (~) bitwise operation in the UD60x18 type.
function not(UD60x18 x) pure returns (UD60x18 result) {
result = wrap(~x.unwrap());
}
/// @notice Implements the OR (|) bitwise operation in the UD60x18 type.
function or(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
result = wrap(x.unwrap() | y.unwrap());
}
/// @notice Implements the right shift operation (>>) in the UD60x18 type.
function rshift(UD60x18 x, uint256 bits) pure returns (UD60x18 result) {
result = wrap(x.unwrap() >> bits);
}
/// @notice Implements the checked subtraction operation (-) in the UD60x18 type.
function sub(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
result = wrap(x.unwrap() - y.unwrap());
}
/// @notice Implements the unchecked addition operation (+) in the UD60x18 type.
function uncheckedAdd(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
unchecked {
result = wrap(x.unwrap() + y.unwrap());
}
}
/// @notice Implements the unchecked subtraction operation (-) in the UD60x18 type.
function uncheckedSub(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
unchecked {
result = wrap(x.unwrap() - y.unwrap());
}
}
/// @notice Implements the XOR (^) bitwise operation in the UD60x18 type.
function xor(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
result = wrap(x.unwrap() ^ y.unwrap());
}
================================================
FILE: src/ud60x18/Math.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import "../Common.sol" as Common;
import "./Errors.sol" as Errors;
import { wrap } from "./Casting.sol";
import {
uEXP_MAX_INPUT,
uEXP2_MAX_INPUT,
uHALF_UNIT,
uLOG2_10,
uLOG2_E,
uMAX_UD60x18,
uMAX_WHOLE_UD60x18,
UNIT,
uUNIT,
uUNIT_SQUARED,
ZERO
} from "./Constants.sol";
import { UD60x18 } from "./ValueType.sol";
/*//////////////////////////////////////////////////////////////////////////
MATHEMATICAL FUNCTIONS
//////////////////////////////////////////////////////////////////////////*/
/// @notice Calculates the arithmetic average of x and y using the following formula:
///
/// $$
/// avg(x, y) = (x & y) + ((xUint ^ yUint) / 2)
/// $$
///
/// In English, this is what this formula does:
///
/// 1. AND x and y.
/// 2. Calculate half of XOR x and y.
/// 3. Add the two results together.
///
/// This technique is known as SWAR, which stands for "SIMD within a register". You can read more about it here:
/// https://devblogs.microsoft.com/oldnewthing/20220207-00/?p=106223
///
/// @dev Notes:
/// - The result is rounded toward zero.
///
/// @param x The first operand as a UD60x18 number.
/// @param y The second operand as a UD60x18 number.
/// @return result The arithmetic average as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function avg(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
uint256 xUint = x.unwrap();
uint256 yUint = y.unwrap();
unchecked {
result = wrap((xUint & yUint) + ((xUint ^ yUint) >> 1));
}
}
/// @notice Yields the smallest whole number greater than or equal to x.
///
/// @dev This is optimized for fractional value inputs, because for every whole value there are (1e18 - 1) fractional
/// counterparts. See https://en.wikipedia.org/wiki/Floor_and_ceiling_functions.
///
/// Requirements:
/// - x ≤ MAX_WHOLE_UD60x18
///
/// @param x The UD60x18 number to ceil.
/// @return result The smallest whole number greater than or equal to x, as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function ceil(UD60x18 x) pure returns (UD60x18 result) {
uint256 xUint = x.unwrap();
if (xUint > uMAX_WHOLE_UD60x18) {
revert Errors.PRBMath_UD60x18_Ceil_Overflow(x);
}
assembly ("memory-safe") {
// Equivalent to `x % UNIT`.
let remainder := mod(x, uUNIT)
// Equivalent to `UNIT - remainder`.
let delta := sub(uUNIT, remainder)
// Equivalent to `x + remainder > 0 ? delta : 0`.
result := add(x, mul(delta, gt(remainder, 0)))
}
}
/// @notice Divides two UD60x18 numbers, returning a new UD60x18 number.
///
/// @dev Uses {Common.mulDiv} to enable overflow-safe multiplication and division.
///
/// Notes:
/// - Refer to the notes in {Common.mulDiv}.
///
/// Requirements:
/// - Refer to the requirements in {Common.mulDiv}.
///
/// @param x The numerator as a UD60x18 number.
/// @param y The denominator as a UD60x18 number.
/// @return result The quotient as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function div(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
result = wrap(Common.mulDiv(x.unwrap(), uUNIT, y.unwrap()));
}
/// @notice Calculates the natural exponent of x using the following formula:
///
/// $$
/// e^x = 2^{x * log_2{e}}
/// $$
///
/// @dev Requirements:
/// - x ≤ 133_084258667509499440
///
/// @param x The exponent as a UD60x18 number.
/// @return result The result as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function exp(UD60x18 x) pure returns (UD60x18 result) {
uint256 xUint = x.unwrap();
// This check prevents values greater than 192e18 from being passed to {exp2}.
if (xUint > uEXP_MAX_INPUT) {
revert Errors.PRBMath_UD60x18_Exp_InputTooBig(x);
}
unchecked {
// Inline the fixed-point multiplication to save gas.
uint256 doubleUnitProduct = xUint * uLOG2_E;
result = exp2(wrap(doubleUnitProduct / uUNIT));
}
}
/// @notice Calculates the binary exponent of x using the binary fraction method.
///
/// @dev See https://ethereum.stackexchange.com/q/79903/24693
///
/// Requirements:
/// - x < 192e18
/// - The result must fit in UD60x18.
///
/// @param x The exponent as a UD60x18 number.
/// @return result The result as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function exp2(UD60x18 x) pure returns (UD60x18 result) {
uint256 xUint = x.unwrap();
// Numbers greater than or equal to 192e18 don't fit in the 192.64-bit format.
if (xUint > uEXP2_MAX_INPUT) {
revert Errors.PRBMath_UD60x18_Exp2_InputTooBig(x);
}
// Convert x to the 192.64-bit fixed-point format.
uint256 x_192x64 = (xUint << 64) / uUNIT;
// Pass x to the {Common.exp2} function, which uses the 192.64-bit fixed-point number representation.
result = wrap(Common.exp2(x_192x64));
}
/// @notice Yields the greatest whole number less than or equal to x.
/// @dev Optimized for fractional value inputs, because every whole value has (1e18 - 1) fractional counterparts.
/// See https://en.wikipedia.org/wiki/Floor_and_ceiling_functions.
/// @param x The UD60x18 number to floor.
/// @return result The greatest whole number less than or equal to x, as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function floor(UD60x18 x) pure returns (UD60x18 result) {
assembly ("memory-safe") {
// Equivalent to `x % UNIT`.
let remainder := mod(x, uUNIT)
// Equivalent to `x - ((remainder > 0) ? remainder : 0)`.
result := sub(x, mul(remainder, gt(remainder, 0)))
}
}
/// @notice Yields the excess beyond the floor of x using the odd function definition.
/// @dev See https://en.wikipedia.org/wiki/Fractional_part.
/// @param x The UD60x18 number to get the fractional part of.
/// @return result The fractional part of x as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function frac(UD60x18 x) pure returns (UD60x18 result) {
assembly ("memory-safe") {
result := mod(x, uUNIT)
}
}
/// @notice Calculates the geometric mean of x and y, i.e. $\sqrt{x * y}$, rounding down.
///
/// @dev Requirements:
/// - x * y must fit in UD60x18.
///
/// @param x The first operand as a UD60x18 number.
/// @param y The second operand as a UD60x18 number.
/// @return result The result as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function gm(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
uint256 xUint = x.unwrap();
uint256 yUint = y.unwrap();
if (xUint == 0 || yUint == 0) {
return ZERO;
}
unchecked {
// Checking for overflow this way is faster than letting Solidity do it.
uint256 xyUint = xUint * yUint;
if (xyUint / xUint != yUint) {
revert Errors.PRBMath_UD60x18_Gm_Overflow(x, y);
}
// We don't need to multiply the result by `UNIT` here because the x*y product picked up a factor of `UNIT`
// during multiplication. See the comments in {Common.sqrt}.
result = wrap(Common.sqrt(xyUint));
}
}
/// @notice Calculates the inverse of x.
///
/// @dev Notes:
/// - The result is rounded toward zero.
///
/// Requirements:
/// - x must not be zero.
///
/// @param x The UD60x18 number for which to calculate the inverse.
/// @return result The inverse as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function inv(UD60x18 x) pure returns (UD60x18 result) {
unchecked {
result = wrap(uUNIT_SQUARED / x.unwrap());
}
}
/// @notice Calculates the natural logarithm of x using the following formula:
///
/// $$
/// ln{x} = log_2{x} / log_2{e}
/// $$
///
/// @dev Notes:
/// - Refer to the notes in {log2}.
/// - The precision isn't sufficiently fine-grained to return exactly `UNIT` when the input is `E`.
///
/// Requirements:
/// - Refer to the requirements in {log2}.
///
/// @param x The UD60x18 number for which to calculate the natural logarithm.
/// @return result The natural logarithm as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function ln(UD60x18 x) pure returns (UD60x18 result) {
unchecked {
// Inline the fixed-point multiplication to save gas. This is overflow-safe because the maximum value that
// {log2} can return is ~196_205294292027477728.
result = wrap(log2(x).unwrap() * uUNIT / uLOG2_E);
}
}
/// @notice Calculates the common logarithm of x using the following formula:
///
/// $$
/// log_{10}{x} = log_2{x} / log_2{10}
/// $$
///
/// However, if x is an exact power of ten, a hard coded value is returned.
///
/// @dev Notes:
/// - Refer to the notes in {log2}.
///
/// Requirements:
/// - Refer to the requirements in {log2}.
///
/// @param x The UD60x18 number for which to calculate the common logarithm.
/// @return result The common logarithm as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function log10(UD60x18 x) pure returns (UD60x18 result) {
uint256 xUint = x.unwrap();
if (xUint < uUNIT) {
revert Errors.PRBMath_UD60x18_Log_InputTooSmall(x);
}
// Note that the `mul` in this assembly block is the standard multiplication operation, not {UD60x18.mul}.
// prettier-ignore
assembly ("memory-safe") {
switch x
case 1 { result := mul(uUNIT, sub(0, 18)) }
case 10 { result := mul(uUNIT, sub(1, 18)) }
case 100 { result := mul(uUNIT, sub(2, 18)) }
case 1000 { result := mul(uUNIT, sub(3, 18)) }
case 10000 { result := mul(uUNIT, sub(4, 18)) }
case 100000 { result := mul(uUNIT, sub(5, 18)) }
case 1000000 { result := mul(uUNIT, sub(6, 18)) }
case 10000000 { result := mul(uUNIT, sub(7, 18)) }
case 100000000 { result := mul(uUNIT, sub(8, 18)) }
case 1000000000 { result := mul(uUNIT, sub(9, 18)) }
case 10000000000 { result := mul(uUNIT, sub(10, 18)) }
case 100000000000 { result := mul(uUNIT, sub(11, 18)) }
case 1000000000000 { result := mul(uUNIT, sub(12, 18)) }
case 10000000000000 { result := mul(uUNIT, sub(13, 18)) }
case 100000000000000 { result := mul(uUNIT, sub(14, 18)) }
case 1000000000000000 { result := mul(uUNIT, sub(15, 18)) }
case 10000000000000000 { result := mul(uUNIT, sub(16, 18)) }
case 100000000000000000 { result := mul(uUNIT, sub(17, 18)) }
case 1000000000000000000 { result := 0 }
case 10000000000000000000 { result := uUNIT }
case 100000000000000000000 { result := mul(uUNIT, 2) }
case 1000000000000000000000 { result := mul(uUNIT, 3) }
case 10000000000000000000000 { result := mul(uUNIT, 4) }
case 100000000000000000000000 { result := mul(uUNIT, 5) }
case 1000000000000000000000000 { result := mul(uUNIT, 6) }
case 10000000000000000000000000 { result := mul(uUNIT, 7) }
case 100000000000000000000000000 { result := mul(uUNIT, 8) }
case 1000000000000000000000000000 { result := mul(uUNIT, 9) }
case 10000000000000000000000000000 { result := mul(uUNIT, 10) }
case 100000000000000000000000000000 { result := mul(uUNIT, 11) }
case 1000000000000000000000000000000 { result := mul(uUNIT, 12) }
case 10000000000000000000000000000000 { result := mul(uUNIT, 13) }
case 100000000000000000000000000000000 { result := mul(uUNIT, 14) }
case 1000000000000000000000000000000000 { result := mul(uUNIT, 15) }
case 10000000000000000000000000000000000 { result := mul(uUNIT, 16) }
case 100000000000000000000000000000000000 { result := mul(uUNIT, 17) }
case 1000000000000000000000000000000000000 { result := mul(uUNIT, 18) }
case 10000000000000000000000000000000000000 { result := mul(uUNIT, 19) }
case 100000000000000000000000000000000000000 { result := mul(uUNIT, 20) }
case 1000000000000000000000000000000000000000 { result := mul(uUNIT, 21) }
case 10000000000000000000000000000000000000000 { result := mul(uUNIT, 22) }
case 100000000000000000000000000000000000000000 { result := mul(uUNIT, 23) }
case 1000000000000000000000000000000000000000000 { result := mul(uUNIT, 24) }
case 10000000000000000000000000000000000000000000 { result := mul(uUNIT, 25) }
case 100000000000000000000000000000000000000000000 { result := mul(uUNIT, 26) }
case 1000000000000000000000000000000000000000000000 { result := mul(uUNIT, 27) }
case 10000000000000000000000000000000000000000000000 { result := mul(uUNIT, 28) }
case 100000000000000000000000000000000000000000000000 { result := mul(uUNIT, 29) }
case 1000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 30) }
case 10000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 31) }
case 100000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 32) }
case 1000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 33) }
case 10000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 34) }
case 100000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 35) }
case 1000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 36) }
case 10000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 37) }
case 100000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 38) }
case 1000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 39) }
case 10000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 40) }
case 100000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 41) }
case 1000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 42) }
case 10000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 43) }
case 100000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 44) }
case 1000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 45) }
case 10000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 46) }
case 100000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 47) }
case 1000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 48) }
case 10000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 49) }
case 100000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 50) }
case 1000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 51) }
case 10000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 52) }
case 100000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 53) }
case 1000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 54) }
case 10000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 55) }
case 100000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 56) }
case 1000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 57) }
case 10000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 58) }
case 100000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(uUNIT, 59) }
default { result := uMAX_UD60x18 }
}
if (result.unwrap() == uMAX_UD60x18) {
unchecked {
// Inline the fixed-point division to save gas.
result = wrap(log2(x).unwrap() * uUNIT / uLOG2_10);
}
}
}
/// @notice Calculates the binary logarithm of x using the iterative approximation algorithm:
///
/// $$
/// log_2{x} = n + log_2{y}, \text{ where } y = x*2^{-n}, \ y \in [1, 2)
/// $$
///
/// For $0 \leq x \lt 1$, the input is inverted:
///
/// $$
/// log_2{x} = -log_2{\frac{1}{x}}
/// $$
///
/// @dev See https://en.wikipedia.org/wiki/Binary_logarithm#Iterative_approximation
///
/// Notes:
/// - Due to the lossy precision of the iterative approximation, the results are not perfectly accurate to the last decimal.
///
/// Requirements:
/// - x ≥ UNIT
///
/// @param x The UD60x18 number for which to calculate the binary logarithm.
/// @return result The binary logarithm as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function log2(UD60x18 x) pure returns (UD60x18 result) {
uint256 xUint = x.unwrap();
if (xUint < uUNIT) {
revert Errors.PRBMath_UD60x18_Log_InputTooSmall(x);
}
unchecked {
// Calculate the integer part of the logarithm.
uint256 n = Common.msb(xUint / uUNIT);
// This is the integer part of the logarithm as a UD60x18 number. The operation can't overflow because
// n is at most 255 and UNIT is 1e18.
uint256 resultUint = n * uUNIT;
// Calculate $y = x * 2^{-n}$.
uint256 y = xUint >> n;
// If y is the unit number, the fractional part is zero.
if (y == uUNIT) {
return wrap(resultUint);
}
// Calculate the fractional part via the iterative approximation.
// The `delta >>= 1` part is equivalent to `delta /= 2`, but shifting bits is more gas efficient.
uint256 doubleUnit = 2e18;
for (uint256 delta = uHALF_UNIT; delta > 0; delta >>= 1) {
y = (y * y) / uUNIT;
// Is y^2 >= 2e18 and so in the range [2e18, 4e18)?
if (y >= doubleUnit) {
// Add the 2^{-m} factor to the logarithm.
resultUint += delta;
// Halve y, which corresponds to z/2 in the Wikipedia article.
y >>= 1;
}
}
result = wrap(resultUint);
}
}
/// @notice Multiplies two UD60x18 numbers together, returning a new UD60x18 number.
///
/// @dev Uses {Common.mulDiv} to enable overflow-safe multiplication and division.
///
/// Notes:
/// - Refer to the notes in {Common.mulDiv}.
///
/// Requirements:
/// - Refer to the requirements in {Common.mulDiv}.
///
/// @dev See the documentation in {Common.mulDiv18}.
/// @param x The multiplicand as a UD60x18 number.
/// @param y The multiplier as a UD60x18 number.
/// @return result The product as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function mul(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
result = wrap(Common.mulDiv18(x.unwrap(), y.unwrap()));
}
/// @notice Raises x to the power of y.
///
/// For $1 \leq x \leq \infty$, the following standard formula is used:
///
/// $$
/// x^y = 2^{log_2{x} * y}
/// $$
///
/// For $0 \leq x \lt 1$, since the unsigned {log2} is undefined, an equivalent formula is used:
///
/// $$
/// i = \frac{1}{x}
/// w = 2^{log_2{i} * y}
/// x^y = \frac{1}{w}
/// $$
///
/// @dev Notes:
/// - Refer to the notes in {log2} and {mul}.
/// - Returns `UNIT` for 0^0.
/// - It may not perform well with very small values of x. Consider using SD59x18 as an alternative.
///
/// Requirements:
/// - Refer to the requirements in {exp2}, {log2}, and {mul}.
///
/// @param x The base as a UD60x18 number.
/// @param y The exponent as a UD60x18 number.
/// @return result The result as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function pow(UD60x18 x, UD60x18 y) pure returns (UD60x18 result) {
uint256 xUint = x.unwrap();
uint256 yUint = y.unwrap();
// If both x and y are zero, the result is `UNIT`. If just x is zero, the result is always zero.
if (xUint == 0) {
return yUint == 0 ? UNIT : ZERO;
}
// If x is `UNIT`, the result is always `UNIT`.
else if (xUint == uUNIT) {
return UNIT;
}
// If y is zero, the result is always `UNIT`.
if (yUint == 0) {
return UNIT;
}
// If y is `UNIT`, the result is always x.
else if (yUint == uUNIT) {
return x;
}
// If x is > UNIT, use the standard formula.
if (xUint > uUNIT) {
result = exp2(mul(log2(x), y));
}
// Conversely, if x < UNIT, use the equivalent formula.
else {
UD60x18 i = wrap(uUNIT_SQUARED / xUint);
UD60x18 w = exp2(mul(log2(i), y));
result = wrap(uUNIT_SQUARED / w.unwrap());
}
}
/// @notice Raises x (a UD60x18 number) to the power y (an unsigned basic integer) using the well-known
/// algorithm "exponentiation by squaring".
///
/// @dev See https://en.wikipedia.org/wiki/Exponentiation_by_squaring.
///
/// Notes:
/// - Refer to the notes in {Common.mulDiv18}.
/// - Returns `UNIT` for 0^0.
///
/// Requirements:
/// - The result must fit in UD60x18.
///
/// @param x The base as a UD60x18 number.
/// @param y The exponent as a uint256.
/// @return result The result as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function powu(UD60x18 x, uint256 y) pure returns (UD60x18 result) {
// Calculate the first iteration of the loop in advance.
uint256 xUint = x.unwrap();
uint256 resultUint = y & 1 > 0 ? xUint : uUNIT;
// Equivalent to `for(y /= 2; y > 0; y /= 2)`.
for (y >>= 1; y > 0; y >>= 1) {
xUint = Common.mulDiv18(xUint, xUint);
// Equivalent to `y % 2 == 1`.
if (y & 1 > 0) {
resultUint = Common.mulDiv18(resultUint, xUint);
}
}
result = wrap(resultUint);
}
/// @notice Calculates the square root of x using the Babylonian method.
///
/// @dev See https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method.
///
/// Notes:
/// - The result is rounded toward zero.
///
/// Requirements:
/// - x ≤ MAX_UD60x18 / UNIT
///
/// @param x The UD60x18 number for which to calculate the square root.
/// @return result The result as a UD60x18 number.
/// @custom:smtchecker abstract-function-nondet
function sqrt(UD60x18 x) pure returns (UD60x18 result) {
uint256 xUint = x.unwrap();
unchecked {
if (xUint > uMAX_UD60x18 / uUNIT) {
revert Errors.PRBMath_UD60x18_Sqrt_Overflow(x);
}
// Multiply x by `UNIT` to account for the factor of `UNIT` picked up when multiplying two UD60x18 numbers.
// In this case, the two numbers are both the square root.
result = wrap(Common.sqrt(xUint * uUNIT));
}
}
================================================
FILE: src/ud60x18/ValueType.sol
================================================
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.19;
import "./Casting.sol" as Casting;
import "./Helpers.sol" as Helpers;
import "./Math.sol" as Math;
/// @notice The unsigned 60.18-decimal fixed-point number representation, which can have up to 60 digits and up to 18
/// decimals. The values of this are bound by the minimum and t
gitextract_hgsxn60y/
├── .editorconfig
├── .github/
│ ├── FUNDING.yml
│ ├── ISSUE_TEMPLATE/
│ │ ├── 1-bug-report.yml
│ │ ├── 2-feature-request.yml
│ │ └── config.yml
│ └── workflows/
│ ├── ci-multibuild.yml
│ ├── ci.yml
│ └── release.yml
├── .gitignore
├── .prettierignore
├── .prettierrc.yml
├── .solhint.json
├── .vscode/
│ └── settings.json
├── CHANGELOG.md
├── CLAUDE.md
├── LICENSE.md
├── README.md
├── SECURITY.md
├── foundry.toml
├── funding.json
├── justfile
├── package.json
├── src/
│ ├── Common.sol
│ ├── SD1x18.sol
│ ├── SD21x18.sol
│ ├── SD59x18.sol
│ ├── UD21x18.sol
│ ├── UD2x18.sol
│ ├── UD60x18.sol
│ ├── casting/
│ │ ├── Uint128.sol
│ │ ├── Uint256.sol
│ │ └── Uint40.sol
│ ├── sd1x18/
│ │ ├── Casting.sol
│ │ ├── Constants.sol
│ │ ├── Errors.sol
│ │ └── ValueType.sol
│ ├── sd21x18/
│ │ ├── Casting.sol
│ │ ├── Constants.sol
│ │ ├── Errors.sol
│ │ └── ValueType.sol
│ ├── sd59x18/
│ │ ├── Casting.sol
│ │ ├── Constants.sol
│ │ ├── Conversions.sol
│ │ ├── Errors.sol
│ │ ├── Helpers.sol
│ │ ├── Math.sol
│ │ └── ValueType.sol
│ ├── ud21x18/
│ │ ├── Casting.sol
│ │ ├── Constants.sol
│ │ ├── Errors.sol
│ │ └── ValueType.sol
│ ├── ud2x18/
│ │ ├── Casting.sol
│ │ ├── Constants.sol
│ │ ├── Errors.sol
│ │ └── ValueType.sol
│ └── ud60x18/
│ ├── Casting.sol
│ ├── Constants.sol
│ ├── Conversions.sol
│ ├── Errors.sol
│ ├── Helpers.sol
│ ├── Math.sol
│ └── ValueType.sol
└── test/
├── .solhint.json
├── Base.t.sol
├── fuzz/
│ ├── casting/
│ │ ├── Uint128.t.sol
│ │ ├── Uint256.t.sol
│ │ └── Uint40.t.sol
│ ├── common/
│ │ ├── msb.t.sol
│ │ └── sqrt.t.sol
│ ├── sd1x18/
│ │ └── casting/
│ │ └── Casting.t.sol
│ ├── sd21x18/
│ │ └── casting/
│ │ └── Casting.t.sol
│ ├── sd59x18/
│ │ ├── casting/
│ │ │ └── Casting.t.sol
│ │ ├── helpers/
│ │ │ └── Helpers.t.sol
│ │ └── math/
│ │ └── pow/
│ │ └── pow.t.sol
│ ├── ud21x18/
│ │ └── casting/
│ │ └── Casting.t.sol
│ ├── ud2x18/
│ │ └── casting/
│ │ └── Casting.t.sol
│ └── ud60x18/
│ ├── casting/
│ │ └── Casting.t.sol
│ ├── helpers/
│ │ └── Helpers.t.sol
│ └── math/
│ └── pow/
│ └── pow.t.sol
├── unit/
│ ├── sd59x18/
│ │ ├── SD59x18.t.sol
│ │ ├── conversion/
│ │ │ ├── convert-from/
│ │ │ │ ├── convertFrom.t.sol
│ │ │ │ └── convertFrom.tree
│ │ │ └── convert-to/
│ │ │ ├── convertTo.t.sol
│ │ │ └── convertTo.tree
│ │ └── math/
│ │ ├── abs/
│ │ │ ├── abs.t.sol
│ │ │ └── abs.tree
│ │ ├── avg/
│ │ │ ├── avg.t.sol
│ │ │ └── avg.tree
│ │ ├── ceil/
│ │ │ ├── ceil.t.sol
│ │ │ └── ceil.tree
│ │ ├── div/
│ │ │ ├── div.t.sol
│ │ │ └── div.tree
│ │ ├── exp/
│ │ │ ├── exp.t.sol
│ │ │ └── exp.tree
│ │ ├── exp2/
│ │ │ ├── exp2.t.sol
│ │ │ └── exp2.tree
│ │ ├── floor/
│ │ │ ├── floor.t.sol
│ │ │ └── floor.tree
│ │ ├── frac/
│ │ │ ├── frac.t.sol
│ │ │ └── frac.tree
│ │ ├── gm/
│ │ │ ├── gm.t.sol
│ │ │ └── gm.tree
│ │ ├── inv/
│ │ │ ├── inv.t.sol
│ │ │ └── inv.tree
│ │ ├── ln/
│ │ │ ├── ln.t.sol
│ │ │ └── ln.tree
│ │ ├── log10/
│ │ │ ├── log10.t.sol
│ │ │ └── log10.tree
│ │ ├── log2/
│ │ │ ├── log2.t.sol
│ │ │ └── log2.tree
│ │ ├── mul/
│ │ │ ├── mul.t.sol
│ │ │ └── mul.tree
│ │ ├── pow/
│ │ │ ├── pow.t.sol
│ │ │ └── pow.tree
│ │ ├── powu/
│ │ │ ├── powu.t.sol
│ │ │ └── powu.tree
│ │ └── sqrt/
│ │ ├── sqrt.t.sol
│ │ └── sqrt.tree
│ └── ud60x18/
│ ├── UD60x18.t.sol
│ ├── conversion/
│ │ ├── convert-from/
│ │ │ ├── convertFrom.t.sol
│ │ │ └── convertFrom.tree
│ │ └── convert-to/
│ │ ├── convertTo.t.sol
│ │ └── convertTo.tree
│ └── math/
│ ├── avg/
│ │ ├── avg.t.sol
│ │ └── avg.tree
│ ├── ceil/
│ │ ├── ceil.t.sol
│ │ └── ceil.tree
│ ├── div/
│ │ ├── div.t.sol
│ │ └── div.tree
│ ├── exp/
│ │ ├── exp.t.sol
│ │ └── exp.tree
│ ├── exp2/
│ │ ├── exp2.t.sol
│ │ └── exp2.tree
│ ├── floor/
│ │ ├── floor.t.sol
│ │ └── floor.tree
│ ├── frac/
│ │ ├── frac.t.sol
│ │ └── frac.tree
│ ├── gm/
│ │ ├── gm.t.sol
│ │ └── gm.tree
│ ├── inv/
│ │ ├── inv.t.sol
│ │ └── inv.tree
│ ├── ln/
│ │ ├── ln.t.sol
│ │ └── ln.tree
│ ├── log10/
│ │ ├── log10.t.sol
│ │ └── log10.tree
│ ├── log2/
│ │ ├── log2.t.sol
│ │ └── log2.tree
│ ├── mul/
│ │ ├── mul.t.sol
│ │ └── mul.tree
│ ├── pow/
│ │ ├── pow.t.sol
│ │ └── pow.tree
│ ├── powu/
│ │ ├── powu.t.sol
│ │ └── powu.tree
│ └── sqrt/
│ ├── sqrt.t.sol
│ └── sqrt.tree
└── utils/
├── Assertions.sol
└── Utils.sol
Condensed preview — 157 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (471K chars).
[
{
"path": ".editorconfig",
"chars": 280,
"preview": "# EditorConfig http://EditorConfig.org\n\n# top-most EditorConfig file\nroot = true\n\n# All files\n[*]\ncharset = utf-8\nend_o"
},
{
"path": ".github/FUNDING.yml",
"chars": 133,
"preview": "custom: \"https://3cities.xyz/#/pay?c=CAESFAKY9DMuOFdjE4Wzl2YyUFipPiSfIgICATICCAJaFURvbmF0aW9uIHRvIFBhdWwgQmVyZw\"\ngithub:"
},
{
"path": ".github/ISSUE_TEMPLATE/1-bug-report.yml",
"chars": 752,
"preview": "name: \"🐛 Bug report\"\ndescription: \"File a bug report\"\nlabels: [\"bug\"]\nbody:\n - type: markdown\n attributes:\n val"
},
{
"path": ".github/ISSUE_TEMPLATE/2-feature-request.yml",
"chars": 479,
"preview": "description: \"Suggest an idea for this project\"\nlabels:\n - \"feature\"\nname: \"🚀 Feature request\"\nbody:\n - type: \"textare"
},
{
"path": ".github/ISSUE_TEMPLATE/config.yml",
"chars": 211,
"preview": "blank_issues_enabled: true\ncontact_links:\n - name: \"🙋 Ask a question\"\n url: \"https://github.com/PaulRBerg/prb-math/d"
},
{
"path": ".github/workflows/ci-multibuild.yml",
"chars": 587,
"preview": "name: CI Multibuild\n\non:\n workflow_dispatch:\n schedule:\n - cron: \"0 3 * * 0\" # at 3:00am UTC every Sunday\n\njobs:\n "
},
{
"path": ".github/workflows/ci.yml",
"chars": 1976,
"preview": "name: CI\n\nconcurrency:\n cancel-in-progress: true\n group: ${{github.workflow}}-${{github.ref}}\n\nenv:\n FOUNDRY_PROFILE:"
},
{
"path": ".github/workflows/release.yml",
"chars": 1203,
"preview": "# Creates GitHub releases automatically when version tags (e.g. v1.0.0) are pushed.\n# Also syncs version branches (e.g. "
},
{
"path": ".gitignore",
"chars": 118,
"preview": "# directories\ncache\nnode_modules\nout\n\n# files\n*.env\n*.log\n.DS_Store\n.pnp.*\npackage-lock.json\npnpm-lock.yaml\nyarn.lock\n"
},
{
"path": ".prettierignore",
"chars": 86,
"preview": "# directories\ncache\nnode_modules\nout\n\n# files\n.pnp.*\npackage-lock.json\npnpm-lock.yaml\n"
},
{
"path": ".prettierrc.yml",
"chars": 128,
"preview": "printWidth: 120\ntrailingComma: \"all\"\n\noverrides:\n - files: \"*.md\"\n options:\n printWidth: 150\n proseWrap: \""
},
{
"path": ".solhint.json",
"chars": 336,
"preview": "{\n \"extends\": \"solhint:recommended\",\n \"rules\": {\n \"compiler-version\": [\"error\", \">=0.8.19\"],\n \"function-max-line"
},
{
"path": ".vscode/settings.json",
"chars": 272,
"preview": "{\n \"solidity.formatter\": \"forge\",\n \"[json][jsonc][yaml]\": { \"editor.defaultFormatter\": \"esbenp.prettier-vscode\" },\n \""
},
{
"path": "CHANGELOG.md",
"chars": 18507,
"preview": "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\nThe format is based on [Common Change"
},
{
"path": "CLAUDE.md",
"chars": 2393,
"preview": "# PRBMath\n\nSolidity library for advanced fixed-point math with signed (SD59x18) and unsigned (UD60x18) 18-decimal types."
},
{
"path": "LICENSE.md",
"chars": 1081,
"preview": "MIT License\n\nCopyright (c) 2023-present Paul Razvan Berg\n\nPermission is hereby granted, free of charge, to any person ob"
},
{
"path": "README.md",
"chars": 17219,
"preview": "# PRBMath [![GitHub Actions][gha-badge]][gha] [![Foundry][foundry-badge]][foundry] [![License: MIT][license-badge]][lice"
},
{
"path": "SECURITY.md",
"chars": 1858,
"preview": "# Security\n\nThe PRBMath codebase has undergone audits by leading security experts from Cantina and Certora.\n\n| :warning:"
},
{
"path": "foundry.toml",
"chars": 691,
"preview": "# Full reference: https://github.com/foundry-rs/foundry/tree/master/crates/config\n\n[profile.default]\n allow_internal_ex"
},
{
"path": "funding.json",
"chars": 109,
"preview": "{\n \"opRetro\": {\n \"projectId\": \"0x7e917a2d0718401c9fe2a82f43ea558f5128f251b1e658c76dc7ff9a5e9fd993\"\n }\n}\n"
},
{
"path": "justfile",
"chars": 3443,
"preview": "set allow-duplicate-variables\nset allow-duplicate-recipes\nset shell := [\"bash\", \"-euo\", \"pipefail\", \"-c\"]\nset unstable\n\n"
},
{
"path": "package.json",
"chars": 895,
"preview": "{\n \"name\": \"@prb/math\",\n \"description\": \"Solidity library for advanced fixed-point math\",\n \"version\": \"4.1.1\",\n \"aut"
},
{
"path": "src/Common.sol",
"chars": 25811,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\n// Common.sol\n//\n// Common mathematical functions used in bot"
},
{
"path": "src/SD1x18.sol",
"chars": 806,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\n/*\n\n██████╗ ██████╗ ██████╗ ███╗ ███╗ █████╗ ████████╗██╗ "
},
{
"path": "src/SD21x18.sol",
"chars": 858,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\n/*\n\n██████╗ ██████╗ ██████╗ ███╗ ███╗ █████╗ ████████╗██╗ "
},
{
"path": "src/SD59x18.sol",
"chars": 979,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\n/*\n\n██████╗ ██████╗ ██████╗ ███╗ ███╗ █████╗ ████████╗██╗ "
},
{
"path": "src/UD21x18.sol",
"chars": 864,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\n/*\n\n██████╗ ██████╗ ██████╗ ███╗ ███╗ █████╗ ████████╗██╗ "
},
{
"path": "src/UD2x18.sol",
"chars": 836,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\n/*\n\n██████╗ ██████╗ ██████╗ ███╗ ███╗ █████╗ ████████╗██╗ "
},
{
"path": "src/UD60x18.sol",
"chars": 997,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\n/*\n\n██████╗ ██████╗ ██████╗ ███╗ ███╗ █████╗ ████████╗██╗ "
},
{
"path": "src/casting/Uint128.sol",
"chars": 2686,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport { uMAX_SD1x18 } from \"../sd1x18/Constants.sol\";\nimport"
},
{
"path": "src/casting/Uint256.sol",
"chars": 3240,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport { uMAX_SD1x18 } from \"../sd1x18/Constants.sol\";\nimport"
},
{
"path": "src/casting/Uint40.sol",
"chars": 1925,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport { SD1x18 } from \"../sd1x18/ValueType.sol\";\nimport { SD"
},
{
"path": "src/sd1x18/Casting.sol",
"chars": 2303,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport \"../Common.sol\" as Common;\nimport \"./Errors.sol\" as Ca"
},
{
"path": "src/sd1x18/Constants.sol",
"chars": 758,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport { SD1x18 } from \"./ValueType.sol\";\n\n/// @dev Euler's n"
},
{
"path": "src/sd1x18/Errors.sol",
"chars": 786,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport { SD1x18 } from \"./ValueType.sol\";\n\n/// @notice Thrown"
},
{
"path": "src/sd1x18/ValueType.sol",
"chars": 855,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport \"./Casting.sol\" as Casting;\n\n/// @notice The signed 1."
},
{
"path": "src/sd21x18/Casting.sol",
"chars": 2340,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport \"../Common.sol\" as Common;\nimport \"./Errors.sol\" as Ca"
},
{
"path": "src/sd21x18/Constants.sol",
"chars": 823,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport { SD21x18 } from \"./ValueType.sol\";\n\n/// @dev Euler's "
},
{
"path": "src/sd21x18/Errors.sol",
"chars": 802,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport { SD21x18 } from \"./ValueType.sol\";\n\n/// @notice Throw"
},
{
"path": "src/sd21x18/ValueType.sol",
"chars": 863,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport \"./Casting.sol\" as Casting;\n\n/// @notice The signed 21"
},
{
"path": "src/sd59x18/Casting.sol",
"chars": 4910,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport \"./Errors.sol\" as CastingErrors;\nimport { MAX_UINT128,"
},
{
"path": "src/sd59x18/Constants.sol",
"chars": 2777,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport { SD59x18 } from \"./ValueType.sol\";\n\n// NOTICE: the \"u"
},
{
"path": "src/sd59x18/Conversions.sol",
"chars": 1188,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport { uMAX_SD59x18, uMIN_SD59x18, uUNIT } from \"./Constant"
},
{
"path": "src/sd59x18/Errors.sol",
"chars": 4456,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport { SD59x18 } from \"./ValueType.sol\";\n\n/// @notice Throw"
},
{
"path": "src/sd59x18/Helpers.sol",
"chars": 4117,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport { wrap } from \"./Casting.sol\";\nimport { SD59x18 } from"
},
{
"path": "src/sd59x18/Math.sol",
"chars": 27617,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport \"../Common.sol\" as Common;\nimport \"./Errors.sol\" as Er"
},
{
"path": "src/sd59x18/ValueType.sol",
"chars": 2655,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport \"./Casting.sol\" as Casting;\nimport \"./Helpers.sol\" as "
},
{
"path": "src/ud21x18/Casting.sol",
"chars": 1902,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport \"../Common.sol\" as Common;\nimport \"./Errors.sol\" as Er"
},
{
"path": "src/ud21x18/Constants.sol",
"chars": 633,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport { UD21x18 } from \"./ValueType.sol\";\n\n/// @dev Euler's "
},
{
"path": "src/ud21x18/Errors.sol",
"chars": 241,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport { UD21x18 } from \"./ValueType.sol\";\n\n/// @notice Throw"
},
{
"path": "src/ud21x18/ValueType.sol",
"chars": 868,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport \"./Casting.sol\" as Casting;\n\n/// @notice The unsigned "
},
{
"path": "src/ud2x18/Casting.sol",
"chars": 1887,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport \"../Common.sol\" as Common;\nimport \"./Errors.sol\" as Er"
},
{
"path": "src/ud2x18/Constants.sol",
"chars": 596,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport { UD2x18 } from \"./ValueType.sol\";\n\n/// @dev Euler's n"
},
{
"path": "src/ud2x18/Errors.sol",
"chars": 237,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport { UD2x18 } from \"./ValueType.sol\";\n\n/// @notice Thrown"
},
{
"path": "src/ud2x18/ValueType.sol",
"chars": 861,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport \"./Casting.sol\" as Casting;\n\n/// @notice The unsigned "
},
{
"path": "src/ud60x18/Casting.sol",
"chars": 3940,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport \"./Errors.sol\" as CastingErrors;\nimport { MAX_UINT128,"
},
{
"path": "src/ud60x18/Constants.sol",
"chars": 1926,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport { UD60x18 } from \"./ValueType.sol\";\n\n// NOTICE: the \"u"
},
{
"path": "src/ud60x18/Conversions.sol",
"chars": 1014,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport { uMAX_UD60x18, uUNIT } from \"./Constants.sol\";\nimport"
},
{
"path": "src/ud60x18/Errors.sol",
"chars": 2033,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport { UD60x18 } from \"./ValueType.sol\";\n\n/// @notice Throw"
},
{
"path": "src/ud60x18/Helpers.sol",
"chars": 3786,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport { wrap } from \"./Casting.sol\";\nimport { UD60x18 } from"
},
{
"path": "src/ud60x18/Math.sol",
"chars": 22818,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport \"../Common.sol\" as Common;\nimport \"./Errors.sol\" as Er"
},
{
"path": "src/ud60x18/ValueType.sol",
"chars": 2840,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19;\n\nimport \"./Casting.sol\" as Casting;\nimport \"./Helpers.sol\" as "
},
{
"path": "test/.solhint.json",
"chars": 183,
"preview": "{\n \"rules\": {\n \"const-name-snakecase\": \"off\",\n \"contract-name-capwords\": \"off\",\n \"gas-small-strings\": \"off\",\n "
},
{
"path": "test/Base.t.sol",
"chars": 2504,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { StdAssertions } from \"forge-std/src/St"
},
{
"path": "test/fuzz/casting/Uint128.t.sol",
"chars": 3139,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport {\n PRBMathCastingUint128 as CastingUi"
},
{
"path": "test/fuzz/casting/Uint256.t.sol",
"chars": 3422,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport {\n PRBMathCastingUint256 as CastingUi"
},
{
"path": "test/fuzz/casting/Uint40.t.sol",
"chars": 2000,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { PRBMathCastingUint40 as CastingUint40 "
},
{
"path": "test/fuzz/common/msb.t.sol",
"chars": 1180,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19 <0.9.0;\n\nimport { msb } from \"src/Common.sol\";\n\nimport { Base_T"
},
{
"path": "test/fuzz/common/sqrt.t.sol",
"chars": 1596,
"preview": "// SPDX-License-Identifier: MIT\npragma solidity >=0.8.19 <0.9.0;\n\nimport { sqrt, MAX_UINT128 } from \"src/Common.sol\";\n\ni"
},
{
"path": "test/fuzz/sd1x18/casting/Casting.t.sol",
"chars": 3803,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { sd1x18, wrap } from \"src/sd1x18/Castin"
},
{
"path": "test/fuzz/sd21x18/casting/Casting.t.sol",
"chars": 3868,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { sd21x18, wrap } from \"src/sd21x18/Cast"
},
{
"path": "test/fuzz/sd59x18/casting/Casting.t.sol",
"chars": 8362,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { uMAX_SD1x18, uMIN_SD1x18 } from \"src/s"
},
{
"path": "test/fuzz/sd59x18/helpers/Helpers.t.sol",
"chars": 5199,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { sd } from \"src/sd59x18/Casting.sol\";\ni"
},
{
"path": "test/fuzz/sd59x18/math/pow/pow.t.sol",
"chars": 1573,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { UNIT, ZERO } from \"src/sd59x18/Constan"
},
{
"path": "test/fuzz/ud21x18/casting/Casting.t.sol",
"chars": 2600,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { SD59x18 } from \"src/sd59x18/ValueType."
},
{
"path": "test/fuzz/ud2x18/casting/Casting.t.sol",
"chars": 2568,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { SD59x18 } from \"src/sd59x18/ValueType."
},
{
"path": "test/fuzz/ud60x18/casting/Casting.t.sol",
"chars": 5792,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { uMAX_SD1x18 } from \"src/sd1x18/Constan"
},
{
"path": "test/fuzz/ud60x18/helpers/Helpers.t.sol",
"chars": 4687,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { ud } from \"src/ud60x18/Casting.sol\";\ni"
},
{
"path": "test/fuzz/ud60x18/math/pow/pow.t.sol",
"chars": 1573,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { UNIT, ZERO } from \"src/ud60x18/Constan"
},
{
"path": "test/unit/sd59x18/SD59x18.t.sol",
"chars": 5324,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { console2 } from \"forge-std/src/console"
},
{
"path": "test/unit/sd59x18/conversion/convert-from/convertFrom.t.sol",
"chars": 2873,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { E, MAX_SD59x18, MAX_WHOLE_SD59x18, MIN"
},
{
"path": "test/unit/sd59x18/conversion/convert-from/convertFrom.tree",
"chars": 228,
"preview": "convertFrom.t.sol\n├── when x is less than the absolute value of the unit number\n│ └── it should return zero\n└── when x "
},
{
"path": "test/unit/sd59x18/conversion/convert-to/convertTo.t.sol",
"chars": 2544,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { MAX_WHOLE_SD59x18, MIN_WHOLE_SD59x18 }"
},
{
"path": "test/unit/sd59x18/conversion/convert-to/convertTo.tree",
"chars": 332,
"preview": "convertTo.t.sol\n├── when x is less than the minimum permitted\n│ └── it should revert\n└── when x is greater than or equal"
},
{
"path": "test/unit/sd59x18/math/abs/abs.t.sol",
"chars": 2838,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { sd } from \"src/sd59x18/Casting.sol\";\ni"
},
{
"path": "test/unit/sd59x18/math/abs/abs.tree",
"chars": 341,
"preview": "abs.t.sol\n├── when x is zero\n│ └── it should return zero\n└── when x is not zero\n ├── when x negative\n │ ├── when x"
},
{
"path": "test/unit/sd59x18/math/avg/avg.t.sol",
"chars": 6063,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { MAX_SD59x18, MAX_WHOLE_SD59x18, MIN_SD"
},
{
"path": "test/unit/sd59x18/math/avg/avg.tree",
"chars": 685,
"preview": "avg.t.sol\n├── when both operands are zero\n│ └── it should return zero\n├── when only one operand is zero\n│ └── it shoul"
},
{
"path": "test/unit/sd59x18/math/ceil/ceil.t.sol",
"chars": 2766,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { sd } from \"src/sd59x18/Casting.sol\";\ni"
},
{
"path": "test/unit/sd59x18/math/ceil/ceil.tree",
"chars": 373,
"preview": "ceil.t.sol\n├── when x is zero\n│ └── it should return zero\n└── when x is not zero\n ├── when x negative\n │ └── it sh"
},
{
"path": "test/unit/sd59x18/math/div/div.t.sol",
"chars": 10605,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { stdError } from \"forge-std/src/StdErro"
},
{
"path": "test/unit/sd59x18/math/div/div.tree",
"chars": 869,
"preview": "div.t.sol\n├── when the denominator is zero\n│ └── it should revert\n└── when the denominator is not zero\n ├── when the "
},
{
"path": "test/unit/sd59x18/math/exp/exp.t.sol",
"chars": 4611,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { sd } from \"src/sd59x18/Casting.sol\";\ni"
},
{
"path": "test/unit/sd59x18/math/exp/exp.tree",
"chars": 545,
"preview": "exp.t.sol\n├── when x is zero\n│ └── it should return the unit number\n└── when x is not zero\n ├── when x is negative\n "
},
{
"path": "test/unit/sd59x18/math/exp2/exp2.t.sol",
"chars": 4929,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { sd } from \"src/sd59x18/Casting.sol\";\ni"
},
{
"path": "test/unit/sd59x18/math/exp2/exp2.tree",
"chars": 534,
"preview": "exp2.t.sol\n├── when x is zero\n│ └── it should return the unit number\n└── when x is not zero\n ├── when x is negative\n "
},
{
"path": "test/unit/sd59x18/math/floor/floor.t.sol",
"chars": 2709,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { sd } from \"src/sd59x18/Casting.sol\";\ni"
},
{
"path": "test/unit/sd59x18/math/floor/floor.tree",
"chars": 377,
"preview": "floor.t.sol\n├── when x is zero\n│ └── it should return zero\n└── when x is not zero\n ├── when x is negative\n │ ├── w"
},
{
"path": "test/unit/sd59x18/math/frac/frac.t.sol",
"chars": 2444,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { MAX_SD59x18, MAX_WHOLE_SD59x18, MIN_SD"
},
{
"path": "test/unit/sd59x18/math/frac/frac.tree",
"chars": 224,
"preview": "frac.t.sol\n├── when x is zero\n│ └── it should return zero\n└── when x is not zero\n ├── when x is negative\n │ └── it"
},
{
"path": "test/unit/sd59x18/math/gm/gm.t.sol",
"chars": 5187,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { sd } from \"src/sd59x18/Casting.sol\";\ni"
},
{
"path": "test/unit/sd59x18/math/gm/gm.tree",
"chars": 408,
"preview": "gm.t.sol\n├── when one of the operands is zero\n│ └── it should return zero\n└── when neither operand is zero\n ├── when "
},
{
"path": "test/unit/sd59x18/math/inv/inv.t.sol",
"chars": 3293,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { stdError } from \"forge-std/src/StdErro"
},
{
"path": "test/unit/sd59x18/math/inv/inv.tree",
"chars": 218,
"preview": "inv.t.sol\n├── when x is zero\n│ └── it should revert\n└── when x is not zero\n ├── when x is negative\n │ └── it shoul"
},
{
"path": "test/unit/sd59x18/math/ln/ln.t.sol",
"chars": 2636,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { sd } from \"src/sd59x18/Casting.sol\";\ni"
},
{
"path": "test/unit/sd59x18/math/ln/ln.tree",
"chars": 199,
"preview": "ln.t.sol\n├── when x is zero\n│ └── it should revert\n└── when x is not zero\n ├── when x is negative\n │ └── it should"
},
{
"path": "test/unit/sd59x18/math/log10/log10.t.sol",
"chars": 3916,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { sd } from \"src/sd59x18/Casting.sol\";\ni"
},
{
"path": "test/unit/sd59x18/math/log10/log10.tree",
"chars": 327,
"preview": "log10.t.sol\n├── when x is zero\n│ └── it should revert\n└── when x is not zero\n ├── when x is negative\n │ └── it sho"
},
{
"path": "test/unit/sd59x18/math/log2/log2.t.sol",
"chars": 3374,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { sd } from \"src/sd59x18/Casting.sol\";\ni"
},
{
"path": "test/unit/sd59x18/math/log2/log2.tree",
"chars": 326,
"preview": "log2.t.sol\n├── when x is zero\n│ └── it should revert\n└── when x is not zero\n ├── when x is negative\n │ └── it shou"
},
{
"path": "test/unit/sd59x18/math/mul/mul.t.sol",
"chars": 10463,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { PRBMath_MulDiv18_Overflow } from \"src/"
},
{
"path": "test/unit/sd59x18/math/mul/mul.tree",
"chars": 703,
"preview": "div.t.sol\n├── when one of the operands is zero\n│ └── it should return zero\n└── when neither operand is zero\n ├── when"
},
{
"path": "test/unit/sd59x18/math/pow/pow.t.sol",
"chars": 6134,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { E, PI, UNIT, ZERO } from \"src/sd59x18/"
},
{
"path": "test/unit/sd59x18/math/pow/pow.tree",
"chars": 799,
"preview": "pow.t.sol\n├── when the base is zero\n│ ├── when the exponent is zero\n│ │ └── it should return the unit number\n│ └── w"
},
{
"path": "test/unit/sd59x18/math/powu/powu.t.sol",
"chars": 7507,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { PRBMath_MulDiv18_Overflow } from \"src/"
},
{
"path": "test/unit/sd59x18/math/powu/powu.tree",
"chars": 805,
"preview": "powu.t.sol\n├── when the base is zero\n│ ├── when the exponent is zero\n│ │ └── it should return the unit number\n│ └── "
},
{
"path": "test/unit/sd59x18/math/sqrt/sqrt.t.sol",
"chars": 2786,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { sd } from \"src/sd59x18/Casting.sol\";\ni"
},
{
"path": "test/unit/sd59x18/math/sqrt/sqrt.tree",
"chars": 358,
"preview": "sqrt.t.sol\n├── when x is zero\n│ └── it should return zero\n└── when x is not zero\n ├── when x is negative\n │ └── it"
},
{
"path": "test/unit/ud60x18/UD60x18.t.sol",
"chars": 4756,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { console2 } from \"forge-std/src/console"
},
{
"path": "test/unit/ud60x18/conversion/convert-from/convertFrom.t.sol",
"chars": 1959,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { E, MAX_WHOLE_UD60x18, MAX_UD60x18, PI "
},
{
"path": "test/unit/ud60x18/conversion/convert-from/convertFrom.tree",
"chars": 179,
"preview": "convertFrom.t.sol\n├── when x is less than the unit number\n│ └── it should revert\n└── when x is greater than or equal to"
},
{
"path": "test/unit/ud60x18/conversion/convert-to/convertTo.t.sol",
"chars": 1563,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { MAX_WHOLE_UD60x18 } from \"src/ud60x18/"
},
{
"path": "test/unit/ud60x18/conversion/convert-to/convertTo.tree",
"chars": 188,
"preview": "convertT.t.sol\n├── when x is greater than the maximum permitted\n│ └── it should revert\n└── when x is less than or equal"
},
{
"path": "test/unit/ud60x18/math/avg/avg.t.sol",
"chars": 3603,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { MAX_UD60x18, MAX_WHOLE_UD60x18, ZERO }"
},
{
"path": "test/unit/ud60x18/math/avg/avg.tree",
"chars": 437,
"preview": "avg.t.sol\n├── when both operands are zero\n│ └── it should return zero\n├── when only one operand is zero\n│ └── it shoul"
},
{
"path": "test/unit/ud60x18/math/ceil/ceil.t.sol",
"chars": 1816,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { ud } from \"src/ud60x18/Casting.sol\";\ni"
},
{
"path": "test/unit/ud60x18/math/ceil/ceil.tree",
"chars": 267,
"preview": "ceil.t.sol\n├── when x is zero\n│ └── it should return zero\n└── when x is not zero\n ├── when x is greater than the maxi"
},
{
"path": "test/unit/ud60x18/math/div/div.t.sol",
"chars": 3862,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { stdError } from \"forge-std/src/StdErro"
},
{
"path": "test/unit/ud60x18/math/div/div.tree",
"chars": 382,
"preview": "div.t.sol\n├── when the denominator is zero\n│ └── it should revert\n└── when the denominator is not zero\n ├── when the "
},
{
"path": "test/unit/ud60x18/math/exp/exp.t.sol",
"chars": 2649,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { ud } from \"src/ud60x18/Casting.sol\";\ni"
},
{
"path": "test/unit/ud60x18/math/exp/exp.tree",
"chars": 277,
"preview": "exp.t.sol\n├── when x is zero\n│ └── it should return the unit number\n└── when x is not zero\n ├── when x is greater tha"
},
{
"path": "test/unit/ud60x18/math/exp2/exp2.t.sol",
"chars": 2921,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { ud } from \"src/ud60x18/Casting.sol\";\ni"
},
{
"path": "test/unit/ud60x18/math/exp2/exp2.tree",
"chars": 242,
"preview": "exp2.t.sol\n├── when x is zero\n│ └── it should return the unit number\n└── when x is not zero\n ├── when x is greater th"
},
{
"path": "test/unit/ud60x18/math/floor/floor.t.sol",
"chars": 1490,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { MAX_UD60x18, MAX_WHOLE_UD60x18, PI, ZE"
},
{
"path": "test/unit/ud60x18/math/floor/floor.tree",
"chars": 125,
"preview": "floor.t.sol\n├── when x is zero\n│ └── it should return zero\n└── when x is not zero\n └── it should return the correct v"
},
{
"path": "test/unit/ud60x18/math/frac/frac.t.sol",
"chars": 1487,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { MAX_UD60x18, MAX_WHOLE_UD60x18, PI, ZE"
},
{
"path": "test/unit/ud60x18/math/frac/frac.tree",
"chars": 124,
"preview": "frac.t.sol\n├── when x is zero\n│ └── it should return zero\n└── when x is not zero\n └── it should return the correct va"
},
{
"path": "test/unit/ud60x18/math/gm/gm.t.sol",
"chars": 2553,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { E, MAX_UD60x18, MAX_WHOLE_UD60x18, PI "
},
{
"path": "test/unit/ud60x18/math/gm/gm.tree",
"chars": 286,
"preview": "gm.t.sol\n├── when one of the operands is zero\n│ └── it should return zero\n└── when neither operand is zero\n ├── whe"
},
{
"path": "test/unit/ud60x18/math/inv/inv.t.sol",
"chars": 1921,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { stdError } from \"forge-std/src/StdErro"
},
{
"path": "test/unit/ud60x18/math/inv/inv.tree",
"chars": 118,
"preview": "inv.t.sol\n├── when x is zero\n│ └── it should revert\n└── when x is not zero\n └── it should return the correct value\n"
},
{
"path": "test/unit/ud60x18/math/ln/ln.t.sol",
"chars": 1710,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { ud } from \"src/ud60x18/Casting.sol\";\ni"
},
{
"path": "test/unit/ud60x18/math/ln/ln.tree",
"chars": 171,
"preview": "inv.t.sol\n├── when x is less than the unit number\n│ └── it should revert\n└── when x is greater than or equal to the uni"
},
{
"path": "test/unit/ud60x18/math/log10/log10.t.sol",
"chars": 2628,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { E, MAX_UD60x18, MAX_WHOLE_UD60x18, PI,"
},
{
"path": "test/unit/ud60x18/math/log10/log10.tree",
"chars": 289,
"preview": "log10.t.sol\n├── when x is less than the unit number\n│ └── it should revert\n└── when x is greater than or equal to the u"
},
{
"path": "test/unit/ud60x18/math/log2/log2.t.sol",
"chars": 2132,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { ud } from \"src/ud60x18/Casting.sol\";\ni"
},
{
"path": "test/unit/ud60x18/math/log2/log2.tree",
"chars": 289,
"preview": "log2.t.sol\n├── when x is less than the unit number\n│ └── it should revert\n└── when x is greater than or equal to the un"
},
{
"path": "test/unit/ud60x18/math/mul/mul.t.sol",
"chars": 3572,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { PRBMath_MulDiv18_Overflow } from \"src/"
},
{
"path": "test/unit/ud60x18/math/mul/mul.tree",
"chars": 271,
"preview": "div.t.sol\n├── when one of the operands is zero\n│ └── it should return zero\n└── when neither operand is zero\n ├── when"
},
{
"path": "test/unit/ud60x18/math/pow/pow.t.sol",
"chars": 4885,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { E, PI, UNIT, ZERO } from \"src/ud60x18/"
},
{
"path": "test/unit/ud60x18/math/pow/pow.tree",
"chars": 1081,
"preview": "pow.t.sol\n├── when the base is zero\n│ ├── when the exponent is zero\n│ │ └── it should return the unit number\n│ └── w"
},
{
"path": "test/unit/ud60x18/math/powu/powu.t.sol",
"chars": 4140,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { ud } from \"src/ud60x18/Casting.sol\";\ni"
},
{
"path": "test/unit/ud60x18/math/powu/powu.tree",
"chars": 499,
"preview": "powu.t.sol\n├── when the base is zero\n│ ├── when the exponent is zero\n│ │ └── it should return the unit number\n│ └── "
},
{
"path": "test/unit/ud60x18/math/sqrt/sqrt.t.sol",
"chars": 2532,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19 <0.9.0;\n\nimport { E, PI, ZERO } from \"src/ud60x18/Consta"
},
{
"path": "test/unit/ud60x18/math/sqrt/sqrt.tree",
"chars": 267,
"preview": "sqrt.t.sol\n├── when x is zero\n│ └── it should return zero\n└── when x is not zero\n ├── when x is greater than the maxi"
},
{
"path": "test/utils/Assertions.sol",
"chars": 15744,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19;\n\nimport { StdAssertions } from \"forge-std/src/StdAssert"
},
{
"path": "test/utils/Utils.sol",
"chars": 14994,
"preview": "// SPDX-License-Identifier: UNLICENSED\npragma solidity >=0.8.19;\n\nimport { StdUtils } from \"forge-std/src/StdUtils.sol\";"
}
]
About this extraction
This page contains the full source code of the hifi-finance/prb-math GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 157 files (428.4 KB), approximately 139.0k tokens. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.