rbca 0.1.0__tar.gz

rbca-0.1.0/.gitignore

@@ -0,0 +1,45 @@
+# virtual environment
+.venv/
+.venv-test/
+
+# Python cache
+__pycache__/
+*.py[cod]
+*$py.class
+
+# build
+build/
+dist/
+*.egg-info/
+archived_dist/
+
+# test / coverage
+.pytest_cache/
+.coverage
+htmlcov/
+
+# type checker / linter
+.mypy_cache/
+.ruff_cache/
+
+# Jupyter
+.ipynb_checkpoints/
+
+# IDE
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# environment variables
+.env
+.env.*
+
+# logs
+*.log
+
+uv.lock
+test.py
+/manual_tests

rbca-0.1.0/.python-version

@@ -0,0 +1 @@
+3.13

rbca-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Imagination12357
+
+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.

rbca-0.1.0/PKG-INFO

@@ -0,0 +1,203 @@
+Metadata-Version: 2.4
+Name: rbca
+Version: 0.1.0
+Summary: Recursive Binary Cosine Approximation
+Project-URL: Homepage, https://github.com/Imagination12357/rbca
+Project-URL: Repository, https://github.com/Imagination12357/rbca
+Project-URL: Issues, https://github.com/Imagination12357/rbca/issues
+Author: imagination12357
+License: MIT
+License-File: LICENSE
+Keywords: approximation,symbolic-math,sympy,trigonometry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Requires-Dist: sympy>=1.10.0
+Description-Content-Type: text/markdown
+
+# rbca
+
+`rbca` (Recursive Binary Cosine Approximation) is a trigonometric approximation library with both symbolic and float APIs.
+
+It computes `cos`, `sin`, and `tan` through recursive binary partitioning on angles.
+
+The default APIs keep expressions in exact symbolic form (SymPy `Expr`) instead of forcing early floating-point evaluation. The `_float` APIs use float arithmetic internally for practical numeric calculation.
+
+Current package version is `0.1.0`.
+
+## Features
+
+- Symbolic trig outputs using SymPy expressions
+- Practical float trig outputs using float arithmetic
+- Recursive midpoint-based approximation for angle intervals
+- Angle normalization over full `0~360` degree input range
+- Three API families:
+  - `calc_*_pure`: mathematically pure symbolic recursion from `0` to `90`
+  - `calc_*`: symbolic recursion seeded with well-known anchor angles (`0, 15, 30, 45, 60, 75`)
+  - `calc_*_float`: practical float calculation using the same anchor strategy as `calc_*`
+
+## Installation
+
+### Using `pip`
+
+```bash
+pip install rbca
+```
+
+### Local development (this repository)
+
+```bash
+pip install -e .
+```
+
+Project requirements:
+- Python `>=3.10`
+- `sympy>=1.10.0`
+
+## Quick Start
+
+```python
+from rbca import calc_cos, calc_cos_float, calc_sin, calc_sin_float, calc_tan
+from sympy import sqrtdenest
+
+depth = 5
+
+cos_expr = calc_cos(37, depth)      # SymPy Expr
+sin_expr = calc_sin(37, depth)      # SymPy Expr
+tan_expr = calc_tan(37, depth)      # SymPy Expr
+
+cos_value = calc_cos_float(37, depth)  # float
+sin_value = calc_sin_float(37, depth)  # float
+
+print(cos_expr)                     # symbolic expression
+print(float(cos_expr))              # numeric projection
+print(sqrtdenest(cos_expr))         # optional radical denesting
+print(cos_value)                    # practical float result
+```
+
+## Choosing an API Family
+
+- Use `calc_cos_pure`, `calc_sin_pure`, and `calc_tan_pure` when you want the mathematically pure symbolic path.
+  - This path starts from `[0, 90]` only.
+- Use `calc_cos`, `calc_sin`, and `calc_tan` when you want symbolic results with a more practical anchored start.
+  - This path uses anchor angles (`0, 15, 30, 45, 60, 75, 90`) to start from a narrower interval.
+- Use `calc_cos_float`, `calc_sin_float`, and `calc_tan_float` when you want practical float results.
+  - This path is implemented with float arithmetic internally.
+
+## Core API
+
+- `calc_cos(angle, depth) -> Expr`
+- `calc_sin(angle, depth) -> Expr`
+- `calc_tan(angle, depth) -> Expr`
+
+- `calc_cos_pure(angle, depth) -> Expr`
+- `calc_sin_pure(angle, depth) -> Expr`
+- `calc_tan_pure(angle, depth) -> Expr`
+
+- `calc_cos_float(angle, depth) -> float`
+- `calc_sin_float(angle, depth) -> float`
+- `calc_tan_float(angle, depth) -> float`
+
+For symbolic APIs, `angle` accepts `Rational | int | float | str` and is internally converted with `sympy.Rational` where needed.
+
+Symbolic input note:
+- `float` inputs are converted through `Rational(float_value)`, which can preserve binary-float artifacts.
+- For exact decimal intent, prefer `str` or `Rational` directly.
+  - Example: use `"0.1"` instead of `0.1`.
+
+For float APIs, `angle` accepts `int | float | str` and is internally converted with `float(angle)`.
+
+`depth` is recursion depth:
+- `depth = 0`: return one of the current interval endpoints
+- larger depth: finer binary partitioning and generally tighter approximation
+
+## How It Works
+
+1. Normalize input angle to first quadrant (`0~90`) and track output sign.
+2. Choose initial bracket interval:
+   - `calc_cos_pure`: `[0, 90]`
+   - `calc_cos`: narrower interval between predefined anchor angles when possible.
+   - `calc_cos_float`: same anchored interval strategy as `calc_cos`, but with float nodes and float values.
+3. Recursively bisect the interval by midpoint angle.
+4. Compute midpoint cosine via:
+   - a product/half-angle style expression using endpoint cosine values.
+5. Recurse until `depth == 0` (or exact angle hit), then apply sign flip if needed.
+
+## Notes and Limitations
+
+- This library is symbolic-first; expressions can grow quickly as depth increases.
+- For angles where cosine is zero (e.g. `90 + 180k` degrees), `calc_tan` and `calc_tan_pure` return `sympy.zoo`.
+- For the same tangent singularities, `calc_tan_float` lets Python's `ZeroDivisionError` propagate.
+- Inputs with symbolic free variables are rejected during normalization.
+
+## Maths
+Condition:
+
+$$
+0^\circ \le A,B \le 90^\circ
+$$
+
+Using the half-angle formula,
+
+$$
+\cos\frac{A+B}{2}
+=
+\sqrt{\frac{1+\cos(A+B)}{2}}
+$$
+
+Also, by the angle addition formula,
+
+$$
+\cos(A+B)
+=
+\cos A\cos B-\sin A\sin B
+$$
+
+Since
+
+$$
+0^\circ \le A,B \le 90^\circ
+$$
+
+we can use
+
+$$
+\sin A=\sqrt{1-\cos^2 A}
+$$
+
+and
+
+$$
+\sin B=\sqrt{1-\cos^2 B}
+$$
+
+Therefore,
+
+$$
+\cos(A+B)
+=
+\cos A\cos B
+-
+\sqrt{(1-\cos^2 A)(1-\cos^2 B)}
+$$
+
+Substituting this into the half-angle formula finally gives
+
+$$
+\boxed{
+\cos\frac{A+B}{2}
+=
+\sqrt{
+\frac{
+1+\cos A\cos B-\sqrt{(1-\cos^2 A)(1-\cos^2 B)}
+}{2}
+}
+}
+$$
+
+## License
+
+MIT License. See [`LICENSE`](./LICENSE).

rbca-0.1.0/README.md

@@ -0,0 +1,183 @@
+# rbca
+
+`rbca` (Recursive Binary Cosine Approximation) is a trigonometric approximation library with both symbolic and float APIs.
+
+It computes `cos`, `sin`, and `tan` through recursive binary partitioning on angles.
+
+The default APIs keep expressions in exact symbolic form (SymPy `Expr`) instead of forcing early floating-point evaluation. The `_float` APIs use float arithmetic internally for practical numeric calculation.
+
+Current package version is `0.1.0`.
+
+## Features
+
+- Symbolic trig outputs using SymPy expressions
+- Practical float trig outputs using float arithmetic
+- Recursive midpoint-based approximation for angle intervals
+- Angle normalization over full `0~360` degree input range
+- Three API families:
+  - `calc_*_pure`: mathematically pure symbolic recursion from `0` to `90`
+  - `calc_*`: symbolic recursion seeded with well-known anchor angles (`0, 15, 30, 45, 60, 75`)
+  - `calc_*_float`: practical float calculation using the same anchor strategy as `calc_*`
+
+## Installation
+
+### Using `pip`
+
+```bash
+pip install rbca
+```
+
+### Local development (this repository)
+
+```bash
+pip install -e .
+```
+
+Project requirements:
+- Python `>=3.10`
+- `sympy>=1.10.0`
+
+## Quick Start
+
+```python
+from rbca import calc_cos, calc_cos_float, calc_sin, calc_sin_float, calc_tan
+from sympy import sqrtdenest
+
+depth = 5
+
+cos_expr = calc_cos(37, depth)      # SymPy Expr
+sin_expr = calc_sin(37, depth)      # SymPy Expr
+tan_expr = calc_tan(37, depth)      # SymPy Expr
+
+cos_value = calc_cos_float(37, depth)  # float
+sin_value = calc_sin_float(37, depth)  # float
+
+print(cos_expr)                     # symbolic expression
+print(float(cos_expr))              # numeric projection
+print(sqrtdenest(cos_expr))         # optional radical denesting
+print(cos_value)                    # practical float result
+```
+
+## Choosing an API Family
+
+- Use `calc_cos_pure`, `calc_sin_pure`, and `calc_tan_pure` when you want the mathematically pure symbolic path.
+  - This path starts from `[0, 90]` only.
+- Use `calc_cos`, `calc_sin`, and `calc_tan` when you want symbolic results with a more practical anchored start.
+  - This path uses anchor angles (`0, 15, 30, 45, 60, 75, 90`) to start from a narrower interval.
+- Use `calc_cos_float`, `calc_sin_float`, and `calc_tan_float` when you want practical float results.
+  - This path is implemented with float arithmetic internally.
+
+## Core API
+
+- `calc_cos(angle, depth) -> Expr`
+- `calc_sin(angle, depth) -> Expr`
+- `calc_tan(angle, depth) -> Expr`
+
+- `calc_cos_pure(angle, depth) -> Expr`
+- `calc_sin_pure(angle, depth) -> Expr`
+- `calc_tan_pure(angle, depth) -> Expr`
+
+- `calc_cos_float(angle, depth) -> float`
+- `calc_sin_float(angle, depth) -> float`
+- `calc_tan_float(angle, depth) -> float`
+
+For symbolic APIs, `angle` accepts `Rational | int | float | str` and is internally converted with `sympy.Rational` where needed.
+
+Symbolic input note:
+- `float` inputs are converted through `Rational(float_value)`, which can preserve binary-float artifacts.
+- For exact decimal intent, prefer `str` or `Rational` directly.
+  - Example: use `"0.1"` instead of `0.1`.
+
+For float APIs, `angle` accepts `int | float | str` and is internally converted with `float(angle)`.
+
+`depth` is recursion depth:
+- `depth = 0`: return one of the current interval endpoints
+- larger depth: finer binary partitioning and generally tighter approximation
+
+## How It Works
+
+1. Normalize input angle to first quadrant (`0~90`) and track output sign.
+2. Choose initial bracket interval:
+   - `calc_cos_pure`: `[0, 90]`
+   - `calc_cos`: narrower interval between predefined anchor angles when possible.
+   - `calc_cos_float`: same anchored interval strategy as `calc_cos`, but with float nodes and float values.
+3. Recursively bisect the interval by midpoint angle.
+4. Compute midpoint cosine via:
+   - a product/half-angle style expression using endpoint cosine values.
+5. Recurse until `depth == 0` (or exact angle hit), then apply sign flip if needed.
+
+## Notes and Limitations
+
+- This library is symbolic-first; expressions can grow quickly as depth increases.
+- For angles where cosine is zero (e.g. `90 + 180k` degrees), `calc_tan` and `calc_tan_pure` return `sympy.zoo`.
+- For the same tangent singularities, `calc_tan_float` lets Python's `ZeroDivisionError` propagate.
+- Inputs with symbolic free variables are rejected during normalization.
+
+## Maths
+Condition:
+
+$$
+0^\circ \le A,B \le 90^\circ
+$$
+
+Using the half-angle formula,
+
+$$
+\cos\frac{A+B}{2}
+=
+\sqrt{\frac{1+\cos(A+B)}{2}}
+$$
+
+Also, by the angle addition formula,
+
+$$
+\cos(A+B)
+=
+\cos A\cos B-\sin A\sin B
+$$
+
+Since
+
+$$
+0^\circ \le A,B \le 90^\circ
+$$
+
+we can use
+
+$$
+\sin A=\sqrt{1-\cos^2 A}
+$$
+
+and
+
+$$
+\sin B=\sqrt{1-\cos^2 B}
+$$
+
+Therefore,
+
+$$
+\cos(A+B)
+=
+\cos A\cos B
+-
+\sqrt{(1-\cos^2 A)(1-\cos^2 B)}
+$$
+
+Substituting this into the half-angle formula finally gives
+
+$$
+\boxed{
+\cos\frac{A+B}{2}
+=
+\sqrt{
+\frac{
+1+\cos A\cos B-\sqrt{(1-\cos^2 A)(1-\cos^2 B)}
+}{2}
+}
+}
+$$
+
+## License
+
+MIT License. See [`LICENSE`](./LICENSE).

rbca-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[project]
+name = "rbca"
+version = "0.1.0"
+description = "Recursive Binary Cosine Approximation"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [
+    { name = "imagination12357" },
+]
+keywords = ["symbolic-math", "trigonometry", "sympy", "approximation"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+dependencies = [
+    "sympy>=1.10.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/Imagination12357/rbca"
+Repository = "https://github.com/Imagination12357/rbca"
+Issues = "https://github.com/Imagination12357/rbca/issues"
+
+[dependency-groups]
+dev = [
+  "pytest>=8,<9"
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/rbca"]

rbca-0.1.0/src/rbca/__init__.py

@@ -0,0 +1,2 @@
+from .lib import calc_cos, calc_cos_pure, calc_sin, calc_sin_pure, calc_tan, calc_tan_pure
+from .lib_float import calc_cos_float, calc_sin_float, calc_tan_float

rbca-0.1.0/src/rbca/core.py

@@ -0,0 +1,48 @@
+from sympy import Rational, Expr, sqrt
+from dataclasses import dataclass
+
+@dataclass
+class RbcaNode:
+    angle: Rational
+    value: Expr
+
+    def __neg__(self):
+        return RbcaNode(self.angle, -self.value)
+    
+    def flipif(self, is_flipped: bool):
+        return -self if is_flipped else self
+
+def calc_mid_cos(lo: RbcaNode, hi:RbcaNode):
+    return RbcaNode(
+        (lo.angle + hi.angle) / 2,
+        #(sqrt((1+lo.value)*(1+hi.value))-sqrt((1-lo.value)*(1-hi.value)))/2
+        sqrt(
+            (1 + lo.value*hi.value - sqrt(1 - lo.value**2)*sqrt(1 - hi.value**2)) / 2
+        )
+    )
+
+def _validate_depth(depth: int):
+    
+    if not isinstance(depth, int) or isinstance(depth, bool):
+        raise TypeError("Depth must be integer.")
+
+    if depth < 0:
+        raise ValueError("Depth must be non-negative.")
+
+def recursive_approx_cos(lo: RbcaNode, hi:RbcaNode, target:Rational, depth:int) -> RbcaNode:
+
+    _validate_depth(depth)
+
+    if depth == 0:
+        return lo if target - lo.angle < hi.angle - target else hi
+    
+    mid = calc_mid_cos(lo, hi)
+
+    if mid.angle == target:
+        return mid
+    
+    if target < mid.angle:
+        return recursive_approx_cos(lo, mid, target, depth-1)
+    
+    else:
+        return recursive_approx_cos(mid, hi, target, depth-1)

rbca-0.1.0/src/rbca/core_float.py

@@ -0,0 +1,41 @@
+import math
+from dataclasses import dataclass
+from .core import _validate_depth
+
+@dataclass
+class RbcaNodeF:
+    angle: float
+    value: float
+
+    def __neg__(self):
+        return RbcaNodeF(self.angle, -self.value)
+    
+    def flipif(self, is_flipped: bool):
+        return -self if is_flipped else self
+
+def calc_mid_cos_f(lo: RbcaNodeF, hi:RbcaNodeF):
+    return RbcaNodeF(
+        (lo.angle + hi.angle) / 2,
+        (math.sqrt((1+lo.value)*(1+hi.value))-math.sqrt((1-lo.value)*(1-hi.value)))/2
+        #math.sqrt(
+        #    (1 + lo.value*hi.value - math.sqrt(1 - lo.value**2)*math.sqrt(1 - hi.value**2)) / 2
+        #)
+    )
+
+def recursive_approx_cos_f(lo: RbcaNodeF, hi:RbcaNodeF, target:float, depth:int) -> RbcaNodeF:
+
+    _validate_depth(depth)
+
+    if depth == 0:
+        return lo if target - lo.angle < hi.angle - target else hi
+    
+    mid = calc_mid_cos_f(lo, hi)
+
+    if mid.angle == target:
+        return mid
+    
+    if target < mid.angle:
+        return recursive_approx_cos_f(lo, mid, target, depth-1)
+    
+    else:
+        return recursive_approx_cos_f(mid, hi, target, depth-1)

rbca-0.1.0/src/rbca/lib.py

@@ -0,0 +1,146 @@
+from sympy import Rational, Expr, sqrt, zoo
+from .core import RbcaNode, recursive_approx_cos, _validate_depth
+
+def _rationalize(angle:Rational|int|float|str) -> Rational:
+    try:
+        return Rational(angle)
+    except Exception as e:
+        raise ValueError("Angle must be representable as a single Rational.") from e
+
+def normalize_cos(angle:Rational|int|float|str) -> tuple[Rational, bool]:
+
+    norm_angle = _rationalize(angle) % 360
+
+    if norm_angle <= 90:
+        final_angle = norm_angle
+        is_flipped = False
+
+    elif norm_angle <= 180:
+        final_angle = 180 - norm_angle
+        is_flipped = True
+    
+    elif norm_angle <= 270:
+        final_angle = norm_angle - 180
+        is_flipped = True
+
+    else:
+        final_angle = 360 - norm_angle
+        is_flipped = False
+
+    return final_angle, is_flipped
+
+def calc_cos_pure(angle:Rational|int|float|str, depth:int) -> Expr:
+
+    _validate_depth(depth)
+
+    norm_angle, is_flipped = normalize_cos(angle)
+
+    return recursive_approx_cos(
+        RbcaNode(Rational(0), 1),
+        RbcaNode(Rational(90), 0),
+        norm_angle,
+        depth
+    ).flipif(is_flipped).value
+
+def calc_sin_pure(angle:Rational|int|float|str, depth:int) -> Expr:
+    return calc_cos_pure(90 - _rationalize(angle), depth)
+
+def calc_tan_pure(angle:Rational|int|float|str, depth:int) -> Expr:
+    try:
+        return calc_sin_pure(angle, depth) / calc_cos_pure(angle, depth)
+    except ZeroDivisionError:
+        return zoo
+
+
+def calc_cos(angle:Rational|int|float|str, depth:int) -> Expr:
+
+    _validate_depth(depth)
+
+    norm_angle, is_flipped = normalize_cos(angle)
+
+    if norm_angle == 0:
+        return RbcaNode(Rational(0), Rational(1)).flipif(is_flipped).value
+    
+    elif norm_angle < 15:
+        return recursive_approx_cos(
+            RbcaNode(Rational(0), Rational(1)),
+            RbcaNode(Rational(15), sqrt(6)/4 + sqrt(2)/4),
+            norm_angle,
+            depth
+        ).flipif(is_flipped).value
+    
+    elif norm_angle == 15:
+        return RbcaNode(Rational(15), sqrt(6)/4 + sqrt(2)/4).flipif(is_flipped).value
+    
+    elif norm_angle < 30:
+        return recursive_approx_cos(
+            RbcaNode(Rational(15), sqrt(6)/4 + sqrt(2)/4),
+            RbcaNode(Rational(30), sqrt(3)/2),
+            norm_angle,
+            depth
+        ).flipif(is_flipped).value
+    
+    elif norm_angle == 30:
+        return RbcaNode(Rational(30), sqrt(3)/2).flipif(is_flipped).value
+
+    elif norm_angle < 45:
+        return recursive_approx_cos(
+            RbcaNode(Rational(30), sqrt(3)/2),
+            RbcaNode(Rational(45), sqrt(2)/2),
+            norm_angle,
+            depth
+        ).flipif(is_flipped).value
+
+    elif norm_angle == 45:
+        return RbcaNode(Rational(45), sqrt(2)/2).flipif(is_flipped).value
+    
+    elif norm_angle < 60:
+        return recursive_approx_cos(
+            RbcaNode(Rational(45), sqrt(2)/2),
+            RbcaNode(Rational(60), Rational(1,2)),
+            norm_angle,
+            depth
+        ).flipif(is_flipped).value
+
+    elif norm_angle == 60:
+        return RbcaNode(Rational(60), Rational(1,2)).flipif(is_flipped).value
+    
+    elif norm_angle < 75:
+        return recursive_approx_cos(
+            RbcaNode(Rational(60), Rational(1,2)),
+            RbcaNode(Rational(75), sqrt(6)/4 - sqrt(2)/4),
+            norm_angle,
+            depth
+        ).flipif(is_flipped).value
+
+    elif norm_angle == 75:
+        return RbcaNode(Rational(75), sqrt(6)/4 - sqrt(2)/4).flipif(is_flipped).value
+    
+    elif norm_angle < 90:
+        return recursive_approx_cos(
+            RbcaNode(Rational(75), sqrt(6)/4 - sqrt(2)/4),
+            RbcaNode(Rational(90), 0),
+            norm_angle,
+            depth
+        ).flipif(is_flipped).value
+    
+    elif norm_angle == 90:
+        return RbcaNode(Rational(90), 0).flipif(is_flipped).value
+
+    else:
+        raise RuntimeError(f"Normalization is wrong with something\nnorm_angle:{norm_angle}")
+
+def calc_sin(angle:Rational|int|float|str, depth:int) -> Expr:
+    return calc_cos(90 - _rationalize(angle), depth)
+
+def calc_tan(angle:Rational|int|float|str, depth:int) -> Expr:
+    try:
+        return calc_sin(angle, depth) / calc_cos(angle, depth)
+    except ZeroDivisionError:
+        return zoo
+
+if __name__ == "__main__":
+    from sympy import latex, sqrtdenest
+    result = sqrtdenest(calc_cos(37, 5))
+    print(latex(result))
+    print(float(result))

rbca-0.1.0/src/rbca/lib_float.py

@@ -0,0 +1,111 @@
+from .core_float import RbcaNodeF, recursive_approx_cos_f, _validate_depth
+import math
+
+def normalize_cos(angle:int|float|str) -> tuple[float, bool]:
+
+    norm_angle = float(angle) % 360
+
+    if norm_angle <= 90:
+        final_angle = norm_angle
+        is_flipped = False
+
+    elif norm_angle <= 180:
+        final_angle = 180 - norm_angle
+        is_flipped = True
+    
+    elif norm_angle <= 270:
+        final_angle = norm_angle - 180
+        is_flipped = True
+
+    else:
+        final_angle = 360 - norm_angle
+        is_flipped = False
+
+    return final_angle, is_flipped
+
+def calc_cos_float(angle:int|float|str, depth:int) -> float:
+
+    _validate_depth(depth)
+
+    norm_angle, is_flipped = normalize_cos(angle)
+
+    if norm_angle == 0:
+        return RbcaNodeF(0, 1).flipif(is_flipped).value
+    
+    elif norm_angle < 15:
+        return recursive_approx_cos_f(
+            RbcaNodeF(0, 1),
+            RbcaNodeF(15, math.sqrt(6)/4 + math.sqrt(2)/4),
+            norm_angle,
+            depth
+        ).flipif(is_flipped).value
+    
+    elif norm_angle == 15:
+        return RbcaNodeF(15, math.sqrt(6)/4 + math.sqrt(2)/4).flipif(is_flipped).value
+    
+    elif norm_angle < 30:
+        return recursive_approx_cos_f(
+            RbcaNodeF(15, math.sqrt(6)/4 + math.sqrt(2)/4),
+            RbcaNodeF(30, math.sqrt(3)/2),
+            norm_angle,
+            depth
+        ).flipif(is_flipped).value
+    
+    elif norm_angle == 30:
+        return RbcaNodeF(30, math.sqrt(3)/2).flipif(is_flipped).value
+
+    elif norm_angle < 45:
+        return recursive_approx_cos_f(
+            RbcaNodeF(30, math.sqrt(3)/2),
+            RbcaNodeF(45, math.sqrt(2)/2),
+            norm_angle,
+            depth
+        ).flipif(is_flipped).value
+
+    elif norm_angle == 45:
+        return RbcaNodeF(45, math.sqrt(2)/2).flipif(is_flipped).value
+    
+    elif norm_angle < 60:
+        return recursive_approx_cos_f(
+            RbcaNodeF(45, math.sqrt(2)/2),
+            RbcaNodeF(60, 1/2),
+            norm_angle,
+            depth
+        ).flipif(is_flipped).value
+
+    elif norm_angle == 60:
+        return RbcaNodeF(60, 1/2).flipif(is_flipped).value
+    
+    elif norm_angle < 75:
+        return recursive_approx_cos_f(
+            RbcaNodeF(60, 1/2),
+            RbcaNodeF(75, math.sqrt(6)/4 - math.sqrt(2)/4),
+            norm_angle,
+            depth
+        ).flipif(is_flipped).value
+
+    elif norm_angle == 75:
+        return RbcaNodeF(75, math.sqrt(6)/4 - math.sqrt(2)/4).flipif(is_flipped).value
+    
+    elif norm_angle < 90:
+        return recursive_approx_cos_f(
+            RbcaNodeF(75, math.sqrt(6)/4 - math.sqrt(2)/4),
+            RbcaNodeF(90, 0),
+            norm_angle,
+            depth
+        ).flipif(is_flipped).value
+    
+    elif norm_angle == 90:
+        return RbcaNodeF(90, 0).flipif(is_flipped).value
+
+    else:
+        raise RuntimeError(f"Normalization is wrong with something\nnorm_angle:{norm_angle}")
+
+def calc_sin_float(angle:int|float|str, depth:int) -> float:
+    return calc_cos_float(90 - float(angle), depth)
+
+def calc_tan_float(angle:int|float|str, depth:int) -> float:
+    return calc_sin_float(angle, depth) / calc_cos_float(angle, depth) # Let the ZeroDivisionError go
+
+if __name__ == "__main__":
+    print(calc_cos_float(37,10))

rbca-0.1.0/tests/test_core_api.py

@@ -0,0 +1,132 @@
+import pytest
+from sympy import Rational, sqrt, zoo
+
+from rbca import (
+    calc_cos,
+    calc_cos_float,
+    calc_sin,
+    calc_sin_float,
+    calc_tan,
+    calc_tan_float,
+    calc_tan_pure,
+)
+from rbca.lib import normalize_cos
+
+
+@pytest.mark.parametrize(
+    ("angle", "expected"),
+    [
+        (0, (Rational(0), False)),
+        (90, (Rational(90), False)),
+        (180, (Rational(0), True)),
+        (270, (Rational(90), True)),
+        (360, (Rational(0), False)),
+        (-90, (Rational(90), True)),
+    ],
+)
+def test_normalize_cos_boundaries(angle, expected):
+    assert normalize_cos(angle) == expected
+
+
+@pytest.mark.parametrize(
+    ("angle", "expected"),
+    [
+        (0, Rational(1)),
+        (30, sqrt(3) / 2),
+        (45, sqrt(2) / 2),
+        (60, Rational(1, 2)),
+        (90, Rational(0)),
+    ],
+)
+def test_calc_cos_anchor_values(angle, expected):
+    assert calc_cos(angle, 2) == expected
+
+
+@pytest.mark.parametrize(
+    ("angle", "expected"),
+    [
+        (0, Rational(0)),
+        (30, Rational(1, 2)),
+        (45, sqrt(2) / 2),
+        (60, sqrt(3) / 2),
+        (90, Rational(1)),
+    ],
+)
+def test_calc_sin_anchor_values(angle, expected):
+    assert calc_sin(angle, 2) == expected
+
+
+def test_depth_negative_raises():
+    with pytest.raises(ValueError):
+        calc_cos(30, -1)
+
+
+def test_depth_non_integer_raises():
+    with pytest.raises(TypeError):
+        calc_cos(30, 1.5)
+
+
+def test_depth_bool_raises():
+    with pytest.raises(TypeError):
+        calc_cos(30, True)
+
+
+def test_calc_tan_90_behavior():
+    assert calc_tan(90, 2) == zoo
+
+
+def test_calc_tan_pure_90_behavior():
+    assert calc_tan_pure(90, 2) == zoo
+
+
+@pytest.mark.parametrize(
+    ("angle", "expected"),
+    [
+        (0, 1.0),
+        (30, 3**0.5 / 2),
+        (45, 2**0.5 / 2),
+        (60, 0.5),
+        (90, 0.0),
+    ],
+)
+def test_calc_cos_float_anchor_values(angle, expected):
+    assert calc_cos_float(angle, 2) == pytest.approx(expected)
+
+
+@pytest.mark.parametrize(
+    ("angle", "expected"),
+    [
+        (0, 0.0),
+        (30, 0.5),
+        (45, 2**0.5 / 2),
+        (60, 3**0.5 / 2),
+        (90, 1.0),
+    ],
+)
+def test_calc_sin_float_anchor_values(angle, expected):
+    assert calc_sin_float(angle, 2) == pytest.approx(expected)
+
+
+def test_calc_tan_float_90_behavior():
+    with pytest.raises(ZeroDivisionError):
+        calc_tan_float(90, 2)
+
+
+def test_calc_cos_float_depth_negative_raises():
+    with pytest.raises(ValueError):
+        calc_cos_float(30, -1)
+
+
+def test_calc_cos_float_depth_non_integer_raises():
+    with pytest.raises(TypeError):
+        calc_cos_float(30, 1.5)
+
+
+def test_calc_cos_float_angle_non_floatable_raises():
+    with pytest.raises(ValueError):
+        calc_cos_float("Not-a-float", 2)
+
+
+def test_angle_non_Rational_raises():
+    with pytest.raises(ValueError):
+        calc_cos("Not-a-Rational", 2)