laakhay-quantlab 0.0.1__tar.gz

laakhay_quantlab-0.0.1/.gitignore

@@ -0,0 +1,20 @@
+venv/
+.venv/
+
+*.egg-info/
+
+**/__pycache__/
+**/.DS_Store
+
+.env*
+
+.claude/
+.pytest_cache/
+.ruff_cache/
+.coverage*
+
+quantlab/_version.py
+
+htmlcov/
+uv.lock
+

laakhay_quantlab-0.0.1/LICENSE

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

laakhay_quantlab-0.0.1/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: laakhay-quantlab
+Version: 0.0.1
+Summary: Quant tools built with ♥︎ by Laakhay
+Project-URL: Homepage, https://laakhay.com
+Project-URL: Repository, https://github.com/laakhay/quantlab
+Author-email: Laakhay Corporation <laakhay.corp@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: backtesting,finance,quantitative-analysis,trading
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.12
+Requires-Dist: laakhay-data
+Requires-Dist: laakhay-ta
+Provides-Extra: all
+Requires-Dist: jax[cpu]>=0.4.0; extra == 'all'
+Requires-Dist: numpy>=1.21.0; extra == 'all'
+Requires-Dist: scipy>=1.10.0; extra == 'all'
+Requires-Dist: torch>=2.0.0; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: build>=1.0; extra == 'dev'
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: numpy>=1.21.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Requires-Dist: scipy>=1.10.0; extra == 'dev'
+Requires-Dist: twine>=5.0; extra == 'dev'
+Provides-Extra: jax
+Requires-Dist: jax[cpu]>=0.4.0; extra == 'jax'
+Provides-Extra: jax-gpu
+Requires-Dist: jax[cuda]>=0.4.0; extra == 'jax-gpu'
+Provides-Extra: numpy
+Requires-Dist: numpy>=1.21.0; extra == 'numpy'
+Requires-Dist: scipy>=1.10.0; extra == 'numpy'
+Provides-Extra: torch
+Requires-Dist: torch>=2.0.0; extra == 'torch'
+Description-Content-Type: text/markdown
+
+# Laakhay Quantlab
+
+`laakhay-quantlab` is a high-performance, backend-agnostic quantitative computation layer designed for simulation-heavy research and production analytics. It provides a unified interface over **NumPy**, **JAX**, and **PyTorch**, enabling seamless switching between CPU and GPU backends without code changes.
+
+## Key Features
+
+- **Backend Agnostic**: Write once, run on NumPy, JAX, or PyTorch.
+- **Hardware Acceleration**: Transparent GPU/TPU support via JAX/Torch backends.
+- **Vectorized Operations**: Optimized `ArrayBackend` with JIT compilation support.
+- **Simulation Primitives**: Fast Gaussian sampling, Geometric Brownian Motion (GBM), and more.
+- **Options & Pricing (New)**: Comprehensive verification and pricing of derivatives using analytical (Black-Scholes) and numerical (Monte Carlo) methods.
+
+## Ecosystem
+
+`laakhay-quantlab` fits into the broader Laakhay quantitative ecosystem:
+1. **`laakhay-data`**: Market data acquisition and normalization.
+2. **`laakhay-ta`**: Technical analysis indicators and strategy engine.
+3. **`laakhay-quantlab`**: Numerical simulation, pricing, and risk modeling.
+
+## Installation
+
+```bash
+pip install laakhay-quantlab
+# extensions: [jax, jax-gpu, torch, all]
+pip install "laakhay-quantlab[all]"
+```
+
+## Quick Start: Options Pricing
+
+The `pricing` module supports a wide range of exotic and vanilla options, along with Greeks calculation.
+
+```python
+from laakhay.quantlab.pricing import (
+    EuropeanCall, 
+    MarketData, 
+    Pricer, 
+    PricingMethod
+)
+
+# 1. Define Market Conditions
+market = MarketData(spot=100.0, rate=0.05, vol=0.2)
+
+# 2. Define Instrument
+option = EuropeanCall(strike=100.0, expiry=1.0)
+
+# 3. Price using Black-Scholes (Analytical)
+bs_pricer = Pricer(method=PricingMethod.BLACK_SCHOLES)
+price, greeks = bs_pricer.price_with_greeks(option, market)
+
+print(f"Price: {price:.4f}")
+print(f"Delta: {greeks.delta:.4f}")
+
+# 4. Price using Monte Carlo (Numerical)
+mc_pricer = Pricer(method=PricingMethod.MONTE_CARLO)
+mc_price = mc_pricer.price(option, market)
+
+print(f"MC Price: {mc_price:.4f}")
+```
+
+## Documentation
+
+See the `docs/` directory for detailed guides:
+- **Getting Started**: Installation and first steps.
+- **Pricing**: Detailed guide on options, strategies, and pricing models.
+- **Backends**: Configuring specific computation backends.

laakhay_quantlab-0.0.1/README.md

@@ -0,0 +1,65 @@
+# Laakhay Quantlab
+
+`laakhay-quantlab` is a high-performance, backend-agnostic quantitative computation layer designed for simulation-heavy research and production analytics. It provides a unified interface over **NumPy**, **JAX**, and **PyTorch**, enabling seamless switching between CPU and GPU backends without code changes.
+
+## Key Features
+
+- **Backend Agnostic**: Write once, run on NumPy, JAX, or PyTorch.
+- **Hardware Acceleration**: Transparent GPU/TPU support via JAX/Torch backends.
+- **Vectorized Operations**: Optimized `ArrayBackend` with JIT compilation support.
+- **Simulation Primitives**: Fast Gaussian sampling, Geometric Brownian Motion (GBM), and more.
+- **Options & Pricing (New)**: Comprehensive verification and pricing of derivatives using analytical (Black-Scholes) and numerical (Monte Carlo) methods.
+
+## Ecosystem
+
+`laakhay-quantlab` fits into the broader Laakhay quantitative ecosystem:
+1. **`laakhay-data`**: Market data acquisition and normalization.
+2. **`laakhay-ta`**: Technical analysis indicators and strategy engine.
+3. **`laakhay-quantlab`**: Numerical simulation, pricing, and risk modeling.
+
+## Installation
+
+```bash
+pip install laakhay-quantlab
+# extensions: [jax, jax-gpu, torch, all]
+pip install "laakhay-quantlab[all]"
+```
+
+## Quick Start: Options Pricing
+
+The `pricing` module supports a wide range of exotic and vanilla options, along with Greeks calculation.
+
+```python
+from laakhay.quantlab.pricing import (
+    EuropeanCall, 
+    MarketData, 
+    Pricer, 
+    PricingMethod
+)
+
+# 1. Define Market Conditions
+market = MarketData(spot=100.0, rate=0.05, vol=0.2)
+
+# 2. Define Instrument
+option = EuropeanCall(strike=100.0, expiry=1.0)
+
+# 3. Price using Black-Scholes (Analytical)
+bs_pricer = Pricer(method=PricingMethod.BLACK_SCHOLES)
+price, greeks = bs_pricer.price_with_greeks(option, market)
+
+print(f"Price: {price:.4f}")
+print(f"Delta: {greeks.delta:.4f}")
+
+# 4. Price using Monte Carlo (Numerical)
+mc_pricer = Pricer(method=PricingMethod.MONTE_CARLO)
+mc_price = mc_pricer.price(option, market)
+
+print(f"MC Price: {mc_price:.4f}")
+```
+
+## Documentation
+
+See the `docs/` directory for detailed guides:
+- **Getting Started**: Installation and first steps.
+- **Pricing**: Detailed guide on options, strategies, and pricing models.
+- **Backends**: Configuring specific computation backends.

laakhay_quantlab-0.0.1/laakhay/quantlab/__init__.py

@@ -0,0 +1,6 @@
+"""
+Quantlab - Quantitative analysis tools for the Laakhay ecosystem
+"""
+
+__author__ = "Laakhay Corporation"
+__version__ = "0.1.0"

laakhay_quantlab-0.0.1/laakhay/quantlab/backend/__init__.py

@@ -0,0 +1,81 @@
+"""Backend abstraction for array operations."""
+
+from . import ops
+from .backend import ArrayBackend, active_backend, backend
+from .interface import AbstractBackend, Backend
+from .registry import (
+    convert_array,
+    get_backend,
+    has_backend,
+    infer_backend,
+    infer_backend_from_arrays,
+    list_backends,
+    register,
+    set_default,
+)
+
+
+def _init():
+    """Initialize available backends."""
+    available = []
+
+    try:
+        from .implementations.numpy import NumpyBackend
+
+        register("numpy", NumpyBackend())
+        available.append("numpy")
+    except ImportError:
+        pass
+
+    try:
+        from .implementations.jax import JaxBackend
+
+        register("jax", JaxBackend())
+        available.append("jax")
+    except ImportError:
+        pass
+
+    try:
+        from .implementations.torch import TorchBackend
+
+        register("torch", TorchBackend())
+        available.append("torch")
+    except ImportError:
+        pass
+
+    # Always register fallback
+    from .implementations.fallback import FallbackBackend
+
+    register("fallback", FallbackBackend())
+
+    # Set default to first available real backend, or fallback
+    for name in ["numpy", "jax", "torch"]:
+        if name in available:
+            set_default(name)
+            return
+
+    set_default("fallback")
+
+
+_init()
+
+__all__ = [
+    # Core
+    "Backend",
+    "AbstractBackend",
+    "ArrayBackend",
+    # High-level API
+    "backend",
+    "active_backend",
+    # Registry
+    "register",
+    "get_backend",
+    "set_default",
+    "list_backends",
+    "infer_backend",
+    "infer_backend_from_arrays",
+    "convert_array",
+    "has_backend",
+    # Ops module
+    "ops",
+]

laakhay_quantlab-0.0.1/laakhay/quantlab/backend/backend.py

@@ -0,0 +1,163 @@
+"""Backend wrapper with autodiff."""
+
+from ..types import Array
+from .registry import get_backend as _get_backend
+from .registry import infer_backend
+
+
+class ArrayBackend:
+    """Backend wrapper with autodiff support."""
+
+    def __init__(self, backend=None):
+        if backend is None:
+            self._backend = _get_backend()
+        elif isinstance(backend, str):
+            self._backend = _get_backend(backend)
+        else:
+            self._backend = backend
+
+    @property
+    def name(self) -> str:
+        return self._backend.name
+
+    @property
+    def supports_autodiff(self) -> bool:
+        """Check autodiff support."""
+        return self.name in ["jax", "torch"]
+
+    def __getattr__(self, name):
+        return getattr(self._backend, name)
+
+    @staticmethod
+    def from_array(array: Array) -> "ArrayBackend":
+        """Create backend from array."""
+        backend_name = infer_backend(array)
+        if backend_name:
+            return ArrayBackend(backend_name)
+        return ArrayBackend()
+
+    def grad(self, func, argnums=0):
+        """Compute gradient."""
+        if self.name == "jax":
+            import jax
+
+            def scalar_func(*args):
+                output = func(*args)
+                if hasattr(output, "shape") and output.shape:
+                    return output.sum()
+                return output
+
+            return jax.grad(scalar_func, argnums=argnums)
+        elif self.name == "torch":
+
+            def torch_grad(*args):
+                import torch
+
+                tensors = []
+                for i, arg in enumerate(args):
+                    if i == argnums:
+                        t = (
+                            arg
+                            if isinstance(arg, torch.Tensor)
+                            else torch.tensor(arg, dtype=torch.float32)
+                        )
+                        t.requires_grad_(True)
+                        tensors.append(t)
+                    else:
+                        t = arg if isinstance(arg, torch.Tensor) else torch.tensor(arg)
+                        tensors.append(t)
+
+                output = func(*tensors)
+
+                if output.numel() > 1:
+                    output = output.sum()
+
+                output.backward()
+                return tensors[argnums].grad
+
+            return torch_grad
+        else:
+            raise RuntimeError(f"Backend {self.name} doesn't support autodiff")
+
+    def value_and_grad(self, func, argnums=0):
+        """Compute value and gradient."""
+        if self.name == "jax":
+            import jax
+
+            def wrapped_func(*args):
+                output = func(*args)
+                scalar = output.sum() if hasattr(output, "shape") and output.shape else output
+                return scalar
+
+            scalar_value_and_grad = jax.value_and_grad(wrapped_func, argnums=argnums)
+
+            def value_and_grad_wrapper(*args):
+                original_output = func(*args)
+                _, grad = scalar_value_and_grad(*args)
+                return original_output, grad
+
+            return value_and_grad_wrapper
+        elif self.name == "torch":
+
+            def torch_value_and_grad(*args):
+                import torch
+
+                tensors = []
+                for i, arg in enumerate(args):
+                    if i == argnums:
+                        t = (
+                            arg
+                            if isinstance(arg, torch.Tensor)
+                            else torch.tensor(arg, dtype=torch.float32)
+                        )
+                        t.requires_grad_(True)
+                        tensors.append(t)
+                    else:
+                        t = arg if isinstance(arg, torch.Tensor) else torch.tensor(arg)
+                        tensors.append(t)
+
+                output = func(*tensors)
+                value = output.detach().clone()
+
+                if output.numel() > 1:
+                    output = output.sum()
+
+                output.backward()
+                return value, tensors[argnums].grad
+
+            return torch_value_and_grad
+        else:
+            raise RuntimeError(f"Backend {self.name} doesn't support value_and_grad")
+
+    def vmap(self, func):
+        """Vectorize function."""
+        if self.name == "jax":
+            import jax
+
+            return jax.vmap(func)
+        else:
+
+            def vmapped(*args):
+                results = [func(x, *args[1:]) for x in args[0]]
+                return self._backend.stack(results)
+
+            return vmapped
+
+    def jit(self, func):
+        """JIT compile function."""
+        if self.name == "jax":
+            import jax
+
+            return jax.jit(func)
+        else:
+            return func
+
+
+def backend(name=None) -> ArrayBackend:
+    """Get backend instance."""
+    return ArrayBackend(name)
+
+
+def active_backend() -> ArrayBackend:
+    """Get active backend."""
+    return ArrayBackend()

laakhay_quantlab-0.0.1/laakhay/quantlab/backend/device.py

@@ -0,0 +1,57 @@
+"""Device management."""
+
+from __future__ import annotations
+
+
+class Device:
+    """Compute device (CPU/GPU)."""
+
+    def __init__(self, device_type: str, device_id: int = 0):
+        self.type = device_type.lower()
+        if self.type == "gpu":
+            self.type = "cuda"
+        self.id = device_id
+
+    def __str__(self):
+        if self.type == "cpu":
+            return "cpu"
+        return f"{self.type}:{self.id}"
+
+    def __eq__(self, other):
+        if isinstance(other, str):
+            return str(self) == other
+        return self.type == other.type and self.id == other.id
+
+    def __hash__(self):
+        return hash((self.type, self.id))
+
+    def __repr__(self):
+        return f"Device({self})"
+
+    @classmethod
+    def cpu(cls):
+        """CPU device."""
+        return cls("cpu")
+
+    @classmethod
+    def gpu(cls, device_id: int = 0):
+        """GPU device."""
+        return cls("cuda", device_id)
+
+
+def get_device(array) -> Device:
+    """Infer device from array."""
+    if hasattr(array, "device") and callable(array.device):
+        device = array.device()
+        if hasattr(device, "platform"):
+            if device.platform == "gpu":
+                return Device.gpu(device.id)
+            return Device.cpu()
+
+    if hasattr(array, "device") and not callable(array.device):
+        device = array.device
+        if hasattr(device, "type") and device.type == "cuda":
+            return Device.gpu(device.index or 0)
+        return Device.cpu()
+
+    return Device.cpu()

laakhay_quantlab-0.0.1/laakhay/quantlab/backend/implementations/__init__.py

@@ -0,0 +1,27 @@
+"""Backend implementations."""
+
+from .fallback import FallbackBackend
+
+__all__ = ["FallbackBackend"]
+
+# Import actual backends only if available
+try:
+    from .numpy import NumpyBackend  # noqa: F401
+
+    __all__.append("NumpyBackend")
+except ImportError:
+    pass
+
+try:
+    from .jax import JaxBackend  # noqa: F401
+
+    __all__.append("JaxBackend")
+except ImportError:
+    pass
+
+try:
+    from .torch import TorchBackend  # noqa: F401
+
+    __all__.append("TorchBackend")
+except ImportError:
+    pass

laakhay_quantlab-0.0.1/laakhay/quantlab/backend/implementations/fallback.py

@@ -0,0 +1,47 @@
+"""Fallback backend for when no array libraries are installed."""
+
+from ..interface import AbstractBackend
+
+
+class FallbackBackend(AbstractBackend):
+    """Fallback backend that raises helpful errors."""
+
+    name = "fallback"
+
+    def __init__(self):
+        self._error_msg = (
+            "No array backend available. Install one of:\n"
+            "  pip install numpy\n"
+            "  pip install jax jaxlib\n"
+            "  pip install torch"
+        )
+
+    def _not_available(self, *args, **kwargs):
+        raise RuntimeError(self._error_msg)
+
+    def __getattribute__(self, name):
+        if name in (
+            "name",
+            "_error_msg",
+            "_not_available",
+            "__class__",
+            "__init__",
+        ):
+            return object.__getattribute__(self, name)
+        return object.__getattribute__(self, "_not_available")
+
+    # Add explicit methods to satisfy the protocol
+    def gather(self, a, indices, axis=0):
+        return self._not_available()
+
+    def norm(self, a, ord=None, axis=None):
+        return self._not_available()
+
+    def solve(self, a, b):
+        return self._not_available()
+
+    def inv(self, a):
+        return self._not_available()
+
+    def det(self, a):
+        return self._not_available()