flexfloat 0.4.0__tar.gz → 1.0.0__tar.gz

{flexfloat-0.4.0 → flexfloat-1.0.0}/.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.4.0
+current_version = 1.0.0
 commit = False
 tag = False
 allow_dirty = True

{flexfloat-0.4.0 → flexfloat-1.0.0}/.github/workflows/manual-release.yml

@@ -3,6 +3,11 @@ name: Manual Release
 on:
   workflow_dispatch:
     inputs:
+      skip_version_bump:
+        description: "Skip version bump and release with current version"
+        required: false
+        default: false
+        type: boolean
       version_bump:
         description: "Version bump type"
         required: true
@@ -70,19 +75,25 @@ jobs:
       - name: Bump or set version
         id: bump_version
         run: |
-          if [ -n "${{ steps.set_new_version.outputs.new_version }}" ]; then
+          if [ "${{ github.event.inputs.skip_version_bump }}" = "true" ]; then
+            # Skip version bump, use current version
+            CURRENT_VERSION=$(grep -E '^version = ' pyproject.toml | cut -d'"' -f2)
+            echo "new_version=$CURRENT_VERSION" >> $GITHUB_OUTPUT
+            echo "Skipping version bump, using current version: $CURRENT_VERSION"
+          elif [ -n "${{ steps.set_new_version.outputs.new_version }}" ]; then
             # Set version directly
             bump2version --new-version ${{ steps.set_new_version.outputs.new_version }} patch
+            NEW_VERSION=$(grep -E '^version = ' pyproject.toml | cut -d'"' -f2)
+            echo "new_version=$NEW_VERSION" >> $GITHUB_OUTPUT
+            echo "New version: $NEW_VERSION"
           else
             # Bump version as per input
             bump2version ${{ github.event.inputs.version_bump }}
+            NEW_VERSION=$(grep -E '^version = ' pyproject.toml | cut -d'"' -f2)
+            echo "new_version=$NEW_VERSION" >> $GITHUB_OUTPUT
+            echo "New version: $NEW_VERSION"
           fi
 
-          # Get new version
-          NEW_VERSION=$(grep -E '^version = ' pyproject.toml | cut -d'"' -f2)
-          echo "new_version=$NEW_VERSION" >> $GITHUB_OUTPUT
-          echo "New version: $NEW_VERSION"
-
       - name: Run tests
         run: |
           pip install -e ".[dev]"
@@ -93,6 +104,7 @@ jobs:
           python -m build
 
       - name: Commit version bump
+        if: ${{ github.event.inputs.skip_version_bump != 'true' }}
         run: |
           git add pyproject.toml flexfloat/__init__.py .bumpversion.cfg
           git commit -m "Bump version to ${{ steps.bump_version.outputs.new_version }} [skip ci]"

flexfloat-1.0.0/CHANGELOG.md

@@ -0,0 +1,69 @@
+# Changelog
+
+All notable changes to FlexFloat will be documented in this file.
+
+## [1.0.0] - 2025-08-03
+
+### 🎉 First Stable Release
+
+FlexFloat 1.0.0 marks the first stable release with a complete implementation of arbitrary precision floating-point arithmetic and a comprehensive mathematical function library.
+
+### ✨ Features
+
+#### Core Arithmetic
+- ✅ Full arithmetic operations: addition, subtraction, multiplication, division, power
+- ✅ IEEE 754 compatible special value handling (NaN, ±infinity, zero)
+- ✅ Growable exponents for handling extremely large/small numbers
+- ✅ Fixed 52-bit fraction precision for consistency
+- ✅ Multiple BitArray backend implementations for performance optimization
+
+#### Complete Mathematical Function Library
+- ✅ **Trigonometric functions**: `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `atan2`
+- ✅ **Exponential functions**: `exp`, `expm1`, `pow`
+- ✅ **Logarithmic functions**: `log`, `log10`, `log2`, `log1p`
+- ✅ **Hyperbolic functions**: `sinh`, `cosh`, `tanh`, `asinh`, `acosh`, `atanh`
+- ✅ **Square root functions**: `sqrt`, `cbrt`
+- ✅ **Mathematical constants**: `pi`, `e`, `tau`, `inf`, `nan`
+- ✅ **Utility functions**: `ceil`, `floor`, `fabs`, `fmod`, `copysign`, and more
+
+#### BitArray Implementations
+- ✅ `ListBoolBitArray`: Simple bool-list implementation for debugging
+- ✅ `ListInt64BitArray`: Optimized int64-list implementation for performance
+- ✅ `BigIntBitArray`: Python int-based implementation for maximum flexibility
+
+#### API and Usability
+- ✅ Pythonic interface with natural mathematical syntax
+- ✅ Comprehensive type hints and documentation
+- ✅ Full test coverage with extensive edge case testing
+- ✅ Clear error handling and special case behavior
+
+### 📊 Technical Details
+
+- **Precision**: IEEE 754 compatible 52-bit fraction precision
+- **Range**: Dynamically growable exponents prevent overflow/underflow
+- **Performance**: Multiple backend implementations for different use cases
+- **Compatibility**: Python 3.11+ support
+
+### 📚 Documentation
+
+- ✅ Complete API documentation
+- ✅ User guide with examples
+- ✅ Mathematical function reference
+- ✅ Performance optimization guide
+
+### 🧪 Testing
+
+- ✅ Comprehensive test suite with >95% code coverage
+- ✅ Mathematical function accuracy verified against Python's `math` module
+- ✅ Edge case testing for special values (NaN, infinity, zero)
+- ✅ Extreme value testing for very large/small numbers
+
+### 🏗️ Architecture
+
+The library is built with a modular architecture:
+- `flexfloat.core`: Main FlexFloat class and arithmetic operations
+- `flexfloat.math`: Complete mathematical function library
+- `flexfloat.bitarray`: Multiple BitArray backend implementations
+- `flexfloat.types`: Type definitions and protocols
+
+This release represents a production-ready library suitable for scientific computing, financial calculations, and any application requiring high-precision floating-point arithmetic beyond the limitations of standard IEEE 754 double precision.

{flexfloat-0.4.0 → flexfloat-1.0.0}/MANIFEST.in

@@ -1,4 +1,5 @@
 include README.md
+include CHANGELOG.md
 include LICENSE
 include pyproject.toml
 include setup.py

{flexfloat-0.4.0 → flexfloat-1.0.0}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: flexfloat
-Version: 0.4.0
-Summary: A library for arbitrary precision floating point arithmetic
+Version: 1.0.0
+Summary: A high-precision Python library for arbitrary precision floating-point arithmetic with growable exponents and fixed-size fractions
 Author: Ferran Sanchez Llado
 License: MIT
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
@@ -12,6 +12,7 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.11
@@ -20,6 +21,7 @@ License-File: LICENSE
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: pytest-xdist>=3.0; extra == "dev"
 Requires-Dist: black>=23.0; extra == "dev"
 Requires-Dist: isort>=5.0; extra == "dev"
 Requires-Dist: mypy>=1.0; extra == "dev"
@@ -39,7 +41,7 @@ Requires-Dist: sphinx-autobuild>=2021.3.14; extra == "docs"
 Requires-Dist: requests>=2.25.0; extra == "docs"
 Dynamic: license-file
 
-# FlexFloat
+# FlexFloat 1.0.0
 
 [![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
@@ -50,8 +52,9 @@ A high-precision Python library for arbitrary precision floating-point arithmeti
 ## ✨ Key Features
 
 - **🔢 Growable Exponents**: Dynamically expand exponent size to handle extremely large (>10^308) or small (<10^-308) numbers
-- **🎯 Fixed-Size Fractions**: Maintain IEEE 754-compatible 52-bit fraction precision for consistent accuracy
+- **🎯 Fixed-Size Fractions**: Maintain IEEE 754-compatible 52-bit fraction precision for consistent accuracy  
 - **⚡ Full Arithmetic Support**: Addition, subtraction, multiplication, division, and power operations
+- **📐 Complete Math Library**: Comprehensive mathematical functions including trigonometric, logarithmic, exponential, and hyperbolic functions
 - **🔧 Multiple BitArray Backends**: Choose between bool-list, int64-list, and big-integer implementations for optimal performance
 - **🌟 Special Value Handling**: Complete support for NaN, ±infinity, and zero values
 - **🛡️ Overflow Protection**: Automatic exponent growth prevents overflow/underflow errors
@@ -88,38 +91,45 @@ print(f"Exponent bits: {len(large_result.exponent)}")  # > 11 (grown beyond IEEE
 print(f"Can represent: {large_result}")  # No overflow!
 ```
 
-### Advanced Features
+### Advanced Mathematical Functions
 
 ```python
-from flexfloat import FlexFloat, BigIntBitArray
-
-# Use different BitArray implementations for specific needs
-FlexFloat.set_bitarray_implementation(BigIntBitArray)
+from flexfloat import FlexFloat
+from flexfloat.math import sin, cos, log, exp, sqrt, sinh, cosh
 
-# Mathematical operations with unlimited precision
+# Create FlexFloat instances
 x = FlexFloat.from_float(2.0)
 y = FlexFloat.from_float(3.0)
 
-# Power operations
+# Trigonometric functions
+angle = FlexFloat.from_float(1.5708)  # π/2 radians
+sin_result = sin(angle)
+cos_result = cos(angle)
+print(f"sin(π/2) = {sin_result.to_float()}")  # ≈ 1.0
+print(f"cos(π/2) = {cos_result.to_float()}")  # ≈ 0.0
+
+# Logarithmic and exponential functions
+log_result = log(x)  # Natural logarithm
+exp_result = exp(x)  # e^x
+sqrt_result = sqrt(x)  # √x
+print(f"ln(2) = {log_result.to_float()}")
+print(f"e^2 = {exp_result.to_float()}")
+print(f"√2 = {sqrt_result.to_float()}")
+
+# Hyperbolic functions
+sinh_result = sinh(x)
+cosh_result = cosh(x)
+print(f"sinh(2) = {sinh_result.to_float()}")
+print(f"cosh(2) = {cosh_result.to_float()}")
+
+# Power operations with extreme precision
 power_result = x ** y  # 2^3 = 8
-print(power_result.to_float())  # 8.0
+print(f"2^3 = {power_result.to_float()}")
 
-# Exponential using Euler's number
-e_result = FlexFloat.e ** x  # e^2
-print(f"e^2 ≈ {e_result.to_float()}")
-
-# Absolute value operations
-abs_result = abs(FlexFloat.from_float(-42.0))
-print(f"|-42| = {abs_result.to_float()}")  # 42.0
-
-# Working with extreme values
-huge = FlexFloat.from_float(1e300)
-extreme_product = huge * huge
-print(f"Product: {extreme_product.to_float()}")  # Still computable!
-
-# Precision demonstration
-precise_calc = FlexFloat.from_float(1.0) / FlexFloat.from_float(3.0)
-print(f"1/3 with 52-bit precision: {precise_calc}")
+# Working with mathematical constants
+from flexfloat.math import pi, e
+circle_area = pi * (x ** FlexFloat.from_float(2.0))  # π * r²
+print(f"Area of circle with radius 2: {circle_area.to_float()}")
 ```
 
 ## 🔧 BitArray Backends
@@ -166,21 +176,71 @@ bigint_array = BigIntBitArray.from_bits(bits)
 ```python
 # Construction
 FlexFloat.from_float(value: float) -> FlexFloat
+FlexFloat.from_int(value: int) -> FlexFloat
 FlexFloat(sign: bool, exponent: BitArray, fraction: BitArray)
 
 # Conversion
 flexfloat.to_float() -> float
+flexfloat.to_int() -> int
 
-# Arithmetic
+# Arithmetic Operations
 a + b, a - b, a * b, a / b, a ** b
 abs(a), -a
 
-# Mathematical functions
-FlexFloat.e ** x  # Exponential function
-flexfloat.exp()   # Natural exponential
-flexfloat.abs()   # Absolute value
+# Comparison Operations  
+a == b, a != b, a < b, a <= b, a > b, a >= b
+```
+
+### Mathematical Functions
+
+FlexFloat provides a comprehensive math library similar to Python's `math` module:
+
+```python
+from flexfloat.math import *
+
+# Exponential and Power Functions
+exp(x)      # e^x
+expm1(x)    # exp(x) - 1 (accurate for small x)
+pow(x, y)   # x^y
+
+# Logarithmic Functions
+log(x)       # Natural logarithm (base e)
+log10(x)     # Base-10 logarithm
+log2(x)      # Base-2 logarithm
+log1p(x)     # log(1 + x) (accurate for small x)
+
+# Trigonometric Functions
+sin(x), cos(x), tan(x)           # Basic trig functions
+asin(x), acos(x), atan(x)        # Inverse trig functions
+atan2(y, x)                      # Two-argument arctangent
+degrees(x), radians(x)           # Angle conversion
+
+# Hyperbolic Functions
+sinh(x), cosh(x), tanh(x)        # Hyperbolic functions
+asinh(x), acosh(x), atanh(x)     # Inverse hyperbolic functions
+
+# Square Root Functions
+sqrt(x)      # Square root
+cbrt(x)      # Cube root
+
+# Mathematical Constants
+pi, e, tau   # π, Euler's number, τ (2π)
+inf, nan     # Positive infinity, Not a Number
+
+# Utility Functions
+ceil(x), floor(x)                # Ceiling and floor
+fmod(x, y)                       # Floating-point remainder
+fabs(x)                          # Absolute value
+copysign(x, y)                   # Copy sign from y to x
+```
+
+### BitArray Configuration
 
-# BitArray configuration
+```python
+from flexfloat import FlexFloat
+from flexfloat.math import sin, cos, pi
+
+# Configure FlexFloat to use a specific BitArray implementation
 FlexFloat.set_bitarray_implementation(implementation: Type[BitArray])
 ```
 
@@ -192,7 +252,7 @@ from flexfloat import FlexFloat
 # Create special values
 nan_val = FlexFloat.nan()
 inf_val = FlexFloat.infinity()
-neg_inf = FlexFloat.negative_infinity()
+neg_inf = FlexFloat.negative_infinity()  
 zero_val = FlexFloat.zero()
 
 # Check for special values
@@ -200,6 +260,8 @@ if result.is_nan():
     print("Result is Not a Number")
 if result.is_infinite():
     print("Result is infinite")
+if result.is_zero():
+    print("Result is zero")
 ```
 
 ## 🧪 Development & Testing
@@ -248,10 +310,19 @@ flake8 flexfloat/
 
 ### Scientific Computing
 ```python
-# Handle calculations that would overflow standard floats
 from flexfloat import FlexFloat
+from flexfloat.math import sin, cos, pi, exp, log
+
+# High-precision trigonometric calculations
+def calculate_wave_interference(amplitude, frequency, time):
+    ff_amp = FlexFloat.from_float(amplitude)
+    ff_freq = FlexFloat.from_float(frequency)
+    ff_time = FlexFloat.from_float(time)
+    
+    wave = ff_amp * sin(ff_freq * ff_time * pi)
+    return wave
 
-# Factorial of large numbers
+# Handle calculations that would overflow standard floats
 def flex_factorial(n):
     result = FlexFloat.from_float(1.0)
     for i in range(1, n + 1):
@@ -263,23 +334,53 @@ large_factorial = flex_factorial(1000)  # No overflow!
 
 ### Financial Calculations
 ```python
-# High-precision compound interest calculations
-principal = FlexFloat.from_float(1000000.0)
-rate = FlexFloat.from_float(1.05)  # 5% annual return
-years = FlexFloat.from_float(100)
+from flexfloat import FlexFloat
+from flexfloat.math import log, exp
 
-# Calculate compound interest over very long periods
-final_amount = principal * (rate ** years)
+# High-precision compound interest calculations
+def compound_interest(principal, rate, years, compounds_per_year):
+    p = FlexFloat.from_float(principal)
+    r = FlexFloat.from_float(rate)
+    n = FlexFloat.from_float(compounds_per_year)
+    t = FlexFloat.from_float(years)
+    
+    # A = P(1 + r/n)^(nt)
+    rate_per_period = r / n
+    exponent = n * t
+    base = FlexFloat.from_float(1.0) + rate_per_period
+    
+    final_amount = p * (base ** exponent)
+    return final_amount
+
+# Calculate compound interest over very long periods with high precision
+result = compound_interest(1000000.0, 0.05, 100, 12)
 ```
 
 ### Physics Simulations
 ```python
+from flexfloat import FlexFloat
+from flexfloat.math import sqrt, pi, exp
+
 # Handle extreme values in physics calculations
-c = FlexFloat.from_float(299792458)  # Speed of light
-mass = FlexFloat.from_float(1e-30)   # Atomic mass
+c = FlexFloat.from_float(299792458)  # Speed of light (m/s)
+mass = FlexFloat.from_float(1e-30)   # Atomic mass (kg)
 
 # E = mc² with extreme precision
 energy = mass * c * c
+
+# Quantum mechanics - wave function calculations
+def gaussian_wave_packet(x, x0, sigma, k0):
+    ff_x = FlexFloat.from_float(x)
+    ff_x0 = FlexFloat.from_float(x0)
+    ff_sigma = FlexFloat.from_float(sigma)
+    ff_k0 = FlexFloat.from_float(k0)
+    
+    # ψ(x) = exp(-(x-x0)²/(4σ²)) * exp(ik0x)
+    displacement = ff_x - ff_x0
+    gaussian = exp(-(displacement * displacement) / (FlexFloat.from_float(4.0) * ff_sigma * ff_sigma))
+    phase = ff_k0 * ff_x
+    
+    return gaussian  # Real part only for this example
 ```
 
 ## 🏗️ Architecture
@@ -288,8 +389,18 @@ FlexFloat is built with a modular architecture:
 
 ```
 flexfloat/
-├── core.py              # Main FlexFloat class
-├── types.py             # Type definitions
+├── core.py              # Main FlexFloat class and arithmetic operations
+├── types.py             # Type definitions and protocols
+├── math/                # Complete mathematical function library
+│   ├── __init__.py          # Math module exports
+│   ├── constants.py         # Mathematical constants (π, e, etc.)
+│   ├── exponential.py       # exp, expm1, pow functions
+│   ├── logarithmic.py       # log, log10, log2, log1p functions
+│   ├── trigonometric.py     # sin, cos, tan and inverse functions
+│   ├── hyperbolic.py        # sinh, cosh, tanh and inverse functions
+│   ├── sqrt.py              # sqrt, cbrt functions
+│   ├── floating_point.py    # IEEE 754 utilities
+│   └── utility.py           # ceil, floor, fmod and other utilities
 ├── bitarray/            # BitArray implementations
 │   ├── bitarray.py          # Abstract base class
 │   ├── bitarray_bool.py     # List[bool] implementation
@@ -302,10 +413,12 @@ flexfloat/
 ### Design Principles
 
 1. **IEEE 754 Compatibility**: Start with standard double-precision format
-2. **Graceful Scaling**: Automatically expand exponent when needed
+2. **Graceful Scaling**: Automatically expand exponent when needed  
 3. **Precision Preservation**: Keep fraction size fixed for consistent accuracy
 4. **Performance Options**: Multiple backends for different use cases
 5. **Pythonic Interface**: Natural syntax for mathematical operations
+6. **Comprehensive Math Library**: Complete set of mathematical functions matching Python's math module
+7. **Special Value Handling**: Proper IEEE 754 semantics for NaN, infinity, and zero
 
 ## 📊 Performance Considerations
 
@@ -326,6 +439,7 @@ flexfloat/
 
 ```python
 from flexfloat import FlexFloat, ListInt64BitArray, BigIntBitArray
+from flexfloat.math import sin, cos, pi
 
 # Choose the right BitArray implementation for your use case
 # For standard operations with moderate precision
@@ -334,6 +448,10 @@ FlexFloat.set_bitarray_implementation(ListInt64BitArray)
 # For most use cases, Python's int is already optimized
 FlexFloat.set_bitarray_implementation(BigIntBitArray)
 
+# Use mathematical constants from the math module
+from flexfloat.math import pi, e
+circle_area = pi * radius * radius  # More accurate than FlexFloat.from_float(3.14159...)
+
 # Batch operations when possible
 values = [FlexFloat.from_float(x) for x in range(1000)]
 sum_result = sum(values, FlexFloat.zero())
@@ -345,11 +463,23 @@ if value_in_standard_range:
 
 ## 📋 Roadmap
 
-- [ ] Additional mathematical functions (sin, cos, tan, log, sqrt)
-- [ ] Serialization support (JSON, pickle)
+### ✅ Version 1.0.0 - Complete Core Features
+- [x] Initial release with basic arithmetic and special values
+- [x] Complete mathematical function library (trigonometric, logarithmic, exponential, hyperbolic)
+- [x] Square root and power functions  
+- [x] Mathematical constants (π, e, τ)
+- [x] Comprehensive test suite with high coverage
+- [x] Multiple BitArray backend implementations
+- [x] IEEE 754 compatibility and special value handling
+
+### 🚧 Future Enhancements
 - [ ] Performance optimizations for large arrays
-- [ ] Complex number support
+- [ ] Serialization support (JSON, pickle)
 - [ ] Decimal mode for exact decimal representation
+- [ ] Complex number support (FlexComplex class)
+- [ ] Additional utility functions (gamma, erf, etc.)
+- [ ] GPU acceleration support
+- [ ] Integration with NumPy arrays
 
 
 ## 📄 License