[docs] Update the changelog for version 0.5.0

README.md

@@ -39,7 +39,13 @@ DeciMojo is available in the [modular-community](https://repo.prefix.dev/modular
 
 From the `pixi` CLI, simply run ```pixi add decimojo```. This fetches the latest version and makes it immediately available for import.
 
-For projects with a `mojoproject.toml`file, add the dependency ```decimojo = "==0.4.1"```. Then run `pixi install` to download and install the package.
+For projects with a `mojoproject.toml`file, add the dependency:
+
+```toml
+decimojo = "==0.5.0"
+```
+
+Then run `pixi install` to download and install the package.
 
 For the latest development version, clone the [GitHub repository](https://github.com/forfudan/decimojo) and build the package locally.
 
@@ -50,6 +56,7 @@ For the latest development version, clone the [GitHub repository](https://github
 | v0.3.0     | ==25.2        | magic           |
 | v0.3.1     | >=25.2, <25.4 | pixi            |
 | v0.4.x     | ==25.4        | pixi            |
+| v0.5.0     | ==25.4        | pixi            |
 
 ## Quick start
 
@@ -295,7 +302,7 @@ If you find DeciMojo useful for your research, consider listing it in your citat
     year         = {2025},
     title        = {An arbitrary-precision decimal and integer mathematics library for Mojo},
     url          = {https://github.com/forfudan/decimojo},
-    version      = {0.4.1},
+    version      = {0.5.0},
     note         = {Computer Software}
 }
 ```

docs/changelog.md

@@ -2,13 +2,56 @@
 
 This is a list of RELEASED changes for the DeciMojo Package.
 
-## 01/08/2025 (v0.4.2)
+## 20250801 (v0.5.0)
+
+DeciMojo v0.5.0 introduces significant enhancements to the `BigDecimal` and `BigUInt` types, including new mathematical functions and performance optimizations. The release adds **trigonometric functions** for `BigDecimal`, implements the **Chudnovsky algorithm** for computing π, implements the **Karatsuba multiplication algorithm** and **Burnikel-Ziegler fast division algorithm** for `BigUInt`. In-place subtraction is now supported for `BigUInt`, and SIMD is utilized for arithmetic operations. The `Decimal` type is renamed to `Decimal128` to reflect its 128-bit fixed precision. The release also includes improved error handling, optimized type conversions, and comprehensive documentation updates.
+
+DeciMojo v0.5.0 is compatible with Mojo v25.5.
+
+### ⭐️ New
+
+1. Introduce trigonometric functions for `BigDecimal`: `sin()`, `cos()`, `tan()`, `cot()`, `csc()`, `sec()`. These functions compute the corresponding trigonometric values of a given angle in radians with arbitrary precision (#96, #99).
+1. Introduce the function `pi()` for `BigDecimal` to compute the value of π (pi) with arbitrary precision with the Chudnovsky algorithm with binary splitting (#95).
+1. Implement the `sqrt()` function for `BigUInt` to compute the square root of a `BigUInt` number as a `BigUInt` object (#107).
+1. Introduce a `DeciMojoError` type and various aliases to handle errors in DeciMojo. This enables a more consistent error handling mechanism across the library and allows users to track errors more easily (#114).
+
+### 🦋 Changed
+
+Changes in **BigUInt**:
+
+1. Refine the `BigUInt` multiplication with the **Karatsuba algorithm**. The time complexity of maltiplication is reduced from $O(n^2)$ to $O(n^{ln(3/2)})$ for large integers, which significantly improves performance for big numbers. Doubling the size of the numbers will only increase the time taken by a factor of about 3, instead of 4 as in the previous implementation (#97).
+1. Refine the `BigUInt` division with the **Burnikel-Ziegler fast recursive division algorithm**. The time complexity of division is also reduced from $O(n^2)$ to $O(n^{ln(3/2)})$ for large integers (#103).
+1. Refine the fall-back **schoolbook division** of `BigUInt` to improve performance. The fallback division is used when the divisor is small enough (#98, #100).
+1. Implement auxiliary functions for arithmetic operations of `BigUInt` to handle **special cases** more efficiently, e.g., when the second operand is one-word long or is a `UInt32` value (#98, #104, #111).
+1. Implement in-place subtraction for `BigUInt`. The `__isub__` method of `BigUInt` will now conduct in-place subtraction. `x -= y` will not lead to memory allocation, but will modify the original `BigUInt` object `x` directly (#98).
+1. Use SIMD for `BigUInt` addition and subtraction operations. This allows the addition and subtraction of two `BigUInt` objects to be performed in parallel, significantly improving performance for large numbers (#101, #102).
+1. Implement functions for all arithmetic operations on slices of `BigUInt` objects. This allows you to perform arithmetic operations on slices of `BigUInt` objects without having to convert them to `BigUInt` first, leading to less memory allocation and improved performance (#105).
+1. Add `to_uint64()` and `to_uint128()` methods to `BigUInt` to for fast type conversion (#91).
+
+Changes in **BigDecimal**:
+
+1. Re-implemente the `sqrt()` function for `BigDecimal` to use the new `BigUInt.sqrt()` method for better performance and accuracy. The new implementation adjusts the scale and coefficient directly, which is more efficient than the previous method. Introduce a new `sqrt_decimal_approach()` function to preserve the old implementation for reference (#108).
+1. Refine or re-implement the basic arithmetic operations, *e.g.,*, addition, subtraction, multiplication, division, etc, for `BigDecimal` and simplify the logic. The new implementation is more efficient and easier to understand, leading to better performance (#109, #110).
+1. Add a default precision 36 for `BigDecimal` methods (#112).
+
+Other changes:
+
+1. Update the codebase to Mojo v25.5 (#113).
+1. Remove unnecessary `raises` keywords for all functions (#92).
+1. Rename the `Decimal` type to `Decimal128` to reflect its fixed precision of 128 bits. It has a new alias `Dec128` (#112).
+1. `Decimal` is now an alias for `BigDecimal` (#112).
 
 ### 🛠️ Fixed
 
-Fix a bug for `BigUInt` comparison: When there are leading zero words, the comparison returns incorrect results (#97).
+- Fix a bug for `BigUInt` comparison: When there are leading zero words, the comparison returns incorrect results (#97).
+- Fix the `is_zero()`, `is_one()`, and `is_two()` methods for `BigUInt` to correctly handle the case when there are leading zero words (#97).
+
+### 📚 Documentation and testing
+
+- Refactor the test files for `BigDecimal` (PR #93).
+- Refactor the test files for `BigInt` (PR #106).
 
-## 01/07/2025 (v0.4.1)
+## 20250701 (v0.4.1)
 
 Version 0.4.1 of DeciMojo introduces implicit type conversion between built-in integral types and arbitrary-precision types.
 
@@ -87,15 +130,15 @@ Fix a bug in `BigDecimal` where it cannot create a correct value from a integral
 
 Update the `tests` module and refactor the test files for `BigUInt` (PR #88).
 
-## 25/06/2025 (v0.4.0)
+## 20250625 (v0.4.0)
 
 DeciMojo v0.4.0 updates the codebase to Mojo v25.4. This release enables you to use DeciMojo with the latest Mojo features.
 
-## 06/06/2025 (v0.3.1)
+## 20250606 (v0.3.1)
 
 DeciMojo v0.3.1 updates the codebase to Mojo v25.3 and replaces the `magic` package manager with `pixi`. This release enables you to use DeciMojo with the latest Mojo features and the new package manager.
 
-## 15/04/2025 (v0.3.0)
+## 20250415 (v0.3.0)
 
 DeciMojo v0.3.0 introduces the arbitrary-precision `BigDecimal` type with comprehensive arithmetic operations, comparisons, and mathematical functions (`sqrt`, `root`, `log`, `exp`, `power`). A new `tomlmojo` package supports test refactoring. Improvements include refined `BigUInt` constructors, enhanced `scale_up_by_power_of_10()` functionality, and a critical multiplication bug fix.
 
@@ -118,7 +161,7 @@ DeciMojo v0.3.0 introduces the arbitrary-precision `BigDecimal` type with compre
 
 - Fix a bug in `BigUInt` multiplication where the calcualtion of carry is mistakenly skipped if a word of x2 is zero (PR #70).
 
-## 01/04/2025 (v0.2.0)
+## 20250401 (v0.2.0)
 
 Version 0.2.0 marks a significant expansion of DeciMojo with the introduction of `BigInt` and `BigUInt` types, providing unlimited precision integer arithmetic to complement the existing fixed-precision `Decimal` type. Core arithmetic functions for the `Decimal` type have been completely rewritten using Mojo 25.2's `UInt128`, delivering substantial performance improvements. This release also extends mathematical capabilities with advanced operations including logarithms, exponentials, square roots, and n-th roots for the `Decimal` type. The codebase has been reorganized into a more modular structure, enhancing maintainability and extensibility. With comprehensive test coverage, improved documentation in multiple languages, and optimized memory management, v0.2.0 represents a major advancement in both functionality and performance for numerical computing in Mojo.
 

docs/internal_notes.md

@@ -1,8 +1,8 @@
 # Internal Notes
 
-## Values and results
+## Inconsistencies between libraries
 
-- For power functionality: `BigDecimal.power()`, Python's decimal, WolframAlpha give the same result, but `mpmath` gives a different result. Eamples: 
+- For power functionality: `BigDecimal.power()`, Python's decimal, WolframAlpha give the same result, but `mpmath` gives a different result. Eamples:
   - `0.123456789 ** 1000`
   - `1234523894766789 ** 1098.1209848`
 - For sin functionality: `BigDecimal.sin()` and WolframAlpha give the same results, but `mpmath` gives a different result. This occurs mainly for pi-related values. Examples:
@@ -15,7 +15,13 @@
     - WolframAlpha: 4.4.0994231605661201249788358050110815384367187427582 x 10-29
     - mpmath:       4.0994231605661201249789078578417210843506987202039e-29
 
-## Time complexity
+## Roadmap for Decimojo
+
+- [ ] Re-implement some methods of `BigUInt` to improve the performance, since it is the building block of `BigDecimal` and `BigInt`.
+- [ ] Refine the methods of `BigDecimal` to improve the performance.
+- [ ] Implement the big **binary** (signed and unsigned) integer type (`BigBinaryUInt`) when users do not need the full precision of BigDecimal. When it is finished, the current BigUInt will be renamed to `BigDecimalUInt`. The alias `BUInt` may be rebound to `BigBinaryUInt`.
+
+## Time complexity for pi() implementations
 
 - #94. Implementing pi() with Machin's formula. Time taken for precision 2048: 33.580649 seconds.
 - #95. Implementing pi() with Chudnovsky algorithm (binary splitting). Time taken for precision 2048: 1.771954 seconds.