#686

.github/pull_request_template.md

@@ -7,4 +7,4 @@
 ## Additional Context for Reviewers  
 
 
-- [ ] I passed tests locally for both code (`pytest`) and documentation changes (`uv run jb build docs --builder=custom --custom-builder=doctest`)
+- [ ] I passed tests locally for both code (`uv run pytest`) and documentation changes (`uv run jb build docs --builder=custom --custom-builder=doctest`)

chainladder/adjustments/parallelogram.py

@@ -7,8 +7,8 @@
 
 
 class ParallelogramOLF(BaseEstimator, TransformerMixin, EstimatorIO):
-    """
-    Estimator to create and apply on-level factors to a Triangle object.  This
+    f"""
+    Estimator to create and apply on-level factors to a Triangle object. This
     is commonly used for premium vectors expressed as a Triangle object.
 
     Parameters
@@ -21,10 +21,15 @@ class ParallelogramOLF(BaseEstimator, TransformerMixin, EstimatorIO):
         5% decrease should be stated as -0.05
     date_col: str
         A list-like set of effective dates corresponding to each of the changes
-    approximation_grain: str
-        The resolution of the internal calendar used for calculating the on-level factors: 
-        monthly ('M') or daily ('D'). Daily is finer and adjusts for leap years when assigning
-        factors to origin periods.
+    approximation_grain: str {"M", "D"} (default="M")
+        The resolution of the internal calendar spacing used for calculating the 
+        on-level factors: monthly ('M') or daily ('D'). In each `approximation_grain`, 
+        they are treated as a period, and a weighted current rate level is estimated.
+        While in daily mode, each day is treated as a full period. Daily is finer 
+        and adjusts for leap years when assigning factors to origin periods. 
+        The Friedland text uses monthly, but daily is more accurate.
+    policy_length: int (default=12)
+        The length of the policy in months.
     vertical_line:
         Rates are typically stated on an effective date basis and premiums on
         and earned basis.  By default, this argument is False and produces
@@ -45,12 +50,14 @@ def __init__(
         change_col="",
         date_col="",
         approximation_grain="M",
+        policy_length=12,
         vertical_line=False,
     ):
         self.rate_history = rate_history
         self.change_col = change_col
         self.date_col = date_col
         self.approximation_grain = approximation_grain
+        self.policy_length = policy_length
         self.vertical_line = vertical_line
 
     def fit(self, X, y=None, sample_weight=None):
@@ -86,6 +93,7 @@ def fit(self, X, y=None, sample_weight=None):
             start_date=X.origin[0].to_timestamp(how="s"),
             end_date=X.origin[-1].to_timestamp(how="e"),
             grain=X.origin_grain,
+            policy_length=self.policy_length,
             vertical_line=self.vertical_line,
             approximation_grain=self.approximation_grain,
         )

chainladder/core/dunders.py

@@ -45,7 +45,7 @@ def _validate_arithmetic(self, other: Any) -> tuple:
             if isinstance(other, np.ndarray) and self.array_backend != 'numpy':
                 obj = self.copy()
                 other = obj.get_array_module().array(other)
-            elif isinstance(other, sp) and self.array_backend != 'sparse':
+            elif isinstance(other, sp.COO) and self.array_backend != 'sparse':
                 obj = self.set_backend('sparse')
             else:
                 obj = self.copy()

chainladder/core/slice.py

@@ -103,7 +103,7 @@ def _sparse_setitem(self, key, values):
                 (self.obj.values.coords, np.array(key)[:, None]), 1)
             self.obj.values.data = np.concatenate(
                 (self.obj.values.data, np.array([values])), 0)
-            self.obj.values = self.obj.get_array_module()(
+            self.obj.values = self.obj.get_array_module().COO(
                 self.obj.values.coords, self.obj.values.data, prune=True,
                 has_duplicates=False, shape=self.obj.shape,
                 fill_value=self.obj.values.fill_value)
@@ -238,8 +238,8 @@ def __setitem__(self, key, value):
                 value.values.coords[1] = i
                 coords = np.concatenate((before.coords, value.values.coords), axis=1)
                 data = np.concatenate((before.data, value.values.data))
-                self.values = xp(
-                    coords, data, shape=self.shape, prune=True, fill_value=xp.nan
+                self.values = xp.COO(
+                    coords, data, shape=self.shape, prune=True, fill_value=xp.COO.nan
                 )
             else:
                 if isinstance(value, TriangleSlicer):

chainladder/core/triangle.py

@@ -524,7 +524,7 @@ def __init__(
 
         # Construct Sparse multidimensional array.
         self.values: COO = num_to_nan(
-            sp(
+            sp.COO(
                 coords,
                 amts,
                 prune=True,

chainladder/utils/sparse.py

@@ -2,23 +2,13 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import numpy as np
-import sparse
-from sparse import COO as sp
+import sparse as sp
+from sparse import COO as COO
 from sparse import elemwise
-import pandas as pd
-import copy
 
 sp.isnan = np.isnan
-sp.newaxis = np.newaxis
-sp.nan = np.array([1.0, np.nan])[-1]
-sp.testing = np.testing
-sp.nansum = sparse.nansum
-sp.nanmin = sparse.nanmin
-sp.nanmax = sparse.nanmax
-sp.concatenate = sparse.concatenate
-sp.diagonal = sparse.diagonal
-sp.zeros = sparse.zeros
-sp.testing.assert_array_equal = np.testing.assert_equal
+COO.nan = np.array([1.0, np.nan])[-1]
+setattr(sp, 'testing', np.testing)
 sp.sqrt = np.sqrt
 sp.log = np.log
 sp.exp = np.exp
@@ -31,41 +21,41 @@ def nan_to_num(a):
     if hasattr(a, "fill_value"):
         a = a.copy()
         a.data[np.isnan(a.data)] = 0.0
-    return sp(coords=a.coords, data=a.data, fill_value=0.0, shape=a.shape)
+    return COO(coords=a.coords, data=a.data, fill_value=0.0, shape=a.shape)
 
 
 def ones(*args, **kwargs):
-    return sp(np.ones(*args, **kwargs), fill_value=sp.nan)
+    return COO(np.ones(*args, **kwargs), fill_value=COO.nan)
 
 
 def nansum(a, axis=None, keepdims=None, *args, **kwargs):
-    return sp(data=a.data, coords=a.coords, fill_value=0.0, shape=a.shape).sum(
+    return COO(data=a.data, coords=a.coords, fill_value=0.0, shape=a.shape).sum(
         axis=axis, keepdims=keepdims, *args, **kwargs
     )
-sp.nansum = nansum
 
 
-def nanmean(a, axis=None, keepdims=None, *args, **kwargs):
-    n = sp.nansum(a, axis=axis, keepdims=keepdims)
-    d = sp.nansum(sp.nan_to_num(a) != 0, axis=axis, keepdims=keepdims).astype(n.dtype)
-    n = sp(data=n.data, coords=n.coords, fill_value=np.nan, shape=n.shape)
-    d = sp(data=d.data, coords=d.coords, fill_value=np.nan, shape=d.shape)
+
+def nanmean(a, axis=None, keepdims=None):
+    n = nansum(a, axis=axis, keepdims=keepdims)
+    d = nansum(nan_to_num(a) != 0, axis=axis, keepdims=keepdims).astype(n.dtype)
+    n = COO(data=n.data, coords=n.coords, fill_value=np.nan, shape=n.shape)
+    d = COO(data=d.data, coords=d.coords, fill_value=np.nan, shape=d.shape)
     out = n / d
-    return sp(data=out.data, coords=out.coords, fill_value=0, shape=out.shape)
+    return COO(data=out.data, coords=out.coords, fill_value=0, shape=out.shape)
 
 def array(a, *args, **kwargs):
     if kwargs.get("fill_value", None) is not None:
         fill_value = kwargs.pop("fill_value")
     else:
-        fill_value = sp.nan
-    if type(a) == sp:
-        return sp(a, *args, **kwargs, fill_value=fill_value)
+        fill_value = COO.nan
+    if type(a) == sp.COO:
+        return COO(a, *args, **kwargs, fill_value=fill_value)
     else:
-        return sp(np.array(a, *args, **kwargs), fill_value=fill_value)
+        return COO(np.array(a, *args, **kwargs), fill_value=fill_value)
 
 
 def arange(*args, **kwargs):
-    return sparse.COO.from_numpy(np.arange(*args, **kwargs))
+    return COO.from_numpy(np.arange(*args, **kwargs))
 
 
 def where(*args, **kwargs):
@@ -76,12 +66,12 @@ def cumprod(a, axis=None, dtype=None, out=None):
     return array(np.cumprod(a.todense(), axis=axis, dtype=dtype, out=out))
 
 
-def floor(x, *args, **kwargs):
+def floor(x):
     x.data = np.floor(x.data)
     return x
 
 
-
+sp.nansum = nansum
 sp.minimum = np.minimum
 sp.maximum = np.maximum
 sp.floor = floor
@@ -91,4 +81,6 @@ def floor(x, *args, **kwargs):
 sp.nan_to_num = nan_to_num
 sp.ones = ones
 sp.cumprod = cumprod
+COO.cumprod = cumprod
 sp.nanmean = nanmean
+sp.sum = COO.sum

chainladder/utils/tests/test_sparse.py

@@ -0,0 +1,110 @@
+import numpy as np
+
+from chainladder.utils.sparse import (
+    array,
+    floor,
+    COO,
+    where
+)
+
+
+def test_array_from_list_default_fill_value() -> None:
+    """
+    Tests chainladder.utils.sparse.array() when no fill value is provided.
+    Checks whether the default nan is filled.
+
+    Returns
+    -------
+    None
+
+    """
+    result: COO = array([1.0, 2.0, 3.0])
+    assert isinstance(result, COO)
+    assert np.isnan(result.fill_value)
+
+
+def test_array_from_list_explicit_fill_value() -> None:
+    """
+    Tests chainladder.utils.sparse.array() when a fill value of 0 is provided.
+    Checks whether the 0 is filled.
+
+    Returns
+    -------
+
+    """
+    result: COO = array([1, 2, 3], fill_value=0)
+    assert isinstance(result, COO)
+    assert result.fill_value == 0
+
+
+def test_array_from_coo_default_fill_value() -> None:
+    """
+    Tests chainladder.utils.sparse.array() when initializing from a sparse array with a default fill value.
+
+    Returns
+    -------
+    None
+
+    """
+    coo = COO.from_numpy(np.array([1.0, 2.0, 3.0]))
+    result: COO = array(coo)
+    assert isinstance(result, COO)
+    assert np.isnan(result.fill_value)
+
+
+def test_array_from_coo_explicit_fill_value() -> None:
+    """
+    Tests chainladder.utils.sparse.array() when initializing from a sparse array with an explicit fill value.
+
+    Returns
+    -------
+    None
+
+    """
+    coo = COO.from_numpy(np.array([1, 2, 3]))
+    result: COO = array(coo, fill_value=0)
+    assert isinstance(result, COO)
+    assert result.fill_value == 0
+
+
+def test_where_selects_from_two_arrays() -> None:
+    """
+    Tests element-wise where across sparse arrays. Calls np.where on each element triplet
+    (cond[i], a[i], b[i]) - returning a[i] where the condition is True and b[i] where it's False.
+
+    Returns
+    -------
+    None
+    """
+    a: COO = array([1.0, 2.0, 3.0])
+    b: COO = array([10.0, 20.0, 30.0])
+    cond: COO = array([True, False, True])
+    result: COO = where(cond, a, b)
+    assert isinstance(result, COO)
+    np.testing.assert_array_equal(result.todense(), [1.0, 20.0, 3.0])
+
+
+def test_floor_rounds_down() -> None:
+    """
+    Checks floor function rounding down with positive and negative floats.
+
+    Returns
+    -------
+    None
+    """
+    a: COO = array([1.2, 2.7, -0.3])
+    result: COO = floor(a)
+    np.testing.assert_array_equal(result.todense(), [1.0, 2.0, -1.0])
+
+
+def test_floor_mutates_in_place() -> None:
+    """
+    Checks in-place mutation of floor function.
+
+    Returns
+    -------
+    None
+    """
+    a = array([1.2, 2.7, -0.3])
+    result: COO = floor(a)
+    assert result is a