crc-framework 0.2.0__tar.gz → 0.2.1__tar.gz

{crc_framework-0.2.0 → crc_framework-0.2.1}/Cargo.lock

@@ -49,7 +49,7 @@ dependencies = [
 
 [[package]]
 name = "crc-framework-core"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "h3o",
  "phf",
@@ -58,7 +58,7 @@ dependencies = [
 
 [[package]]
 name = "crc-framework-rs"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "crc-framework-core",
  "h3o",

{crc_framework-0.2.0 → crc_framework-0.2.1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "crc-framework-rs"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2024"
 rust-version = "1.85"
 description = "Rust-powered Python bindings for the Climate Risk Commons Framework"

{crc_framework-0.2.0 → crc_framework-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crc-framework
-Version: 0.2.0
+Version: 0.2.1
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
 Classifier: Operating System :: OS Independent
@@ -92,6 +92,7 @@ Choose a distribution according to the form of the available data:
 - `FittedDistribution` for a known parametric family and its parameters.
 - `HurdleDistribution` for a point mass followed by a truncated parametric
   tail.
+- `PointMassDistribution` for a value that is constant at every probability.
 
 `TabulatedDistribution` does not extrapolate by default. Querying outside its
 declared probability range raises an error unless `extrapolate=True` is set.
@@ -307,8 +308,9 @@ continent and intersecting ISO3 country codes.
 The package exports the following primary interfaces:
 
 - Distributions: `EmpiricalDistribution`, `TabulatedDistribution`,
-  `FittedDistribution`, `HurdleDistribution`, `fit_distribution`,
-  `fit_quantiles`, `fit_hurdle_quantiles`, `fit_all`, and `quality_metrics`.
+  `FittedDistribution`, `HurdleDistribution`, `PointMassDistribution`,
+  `fit_distribution`, `fit_quantiles`, `fit_hurdle_quantiles`, `fit_all`, and
+  `quality_metrics`.
 - Transforms: `impacts`, `ImpactRegistry`, `ImpactFunction`, `ClimateImpact`,
   `LinearImpact`, `SigmoidImpact`, `PiecewiseLinearImpact`, `CallableImpact`,
   and `CallableTransform`.

{crc_framework-0.2.0 → crc_framework-0.2.1}/README.md

@@ -69,6 +69,7 @@ Choose a distribution according to the form of the available data:
 - `FittedDistribution` for a known parametric family and its parameters.
 - `HurdleDistribution` for a point mass followed by a truncated parametric
   tail.
+- `PointMassDistribution` for a value that is constant at every probability.
 
 `TabulatedDistribution` does not extrapolate by default. Querying outside its
 declared probability range raises an error unless `extrapolate=True` is set.
@@ -284,8 +285,9 @@ continent and intersecting ISO3 country codes.
 The package exports the following primary interfaces:
 
 - Distributions: `EmpiricalDistribution`, `TabulatedDistribution`,
-  `FittedDistribution`, `HurdleDistribution`, `fit_distribution`,
-  `fit_quantiles`, `fit_hurdle_quantiles`, `fit_all`, and `quality_metrics`.
+  `FittedDistribution`, `HurdleDistribution`, `PointMassDistribution`,
+  `fit_distribution`, `fit_quantiles`, `fit_hurdle_quantiles`, `fit_all`, and
+  `quality_metrics`.
 - Transforms: `impacts`, `ImpactRegistry`, `ImpactFunction`, `ClimateImpact`,
   `LinearImpact`, `SigmoidImpact`, `PiecewiseLinearImpact`, `CallableImpact`,
   and `CallableTransform`.

{crc_framework-0.2.0 → crc_framework-0.2.1}/crates/core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "crc-framework-core"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2024"
 rust-version = "1.85"
 description = "Core distribution and climate-risk algorithms for CRC Framework"

{crc_framework-0.2.0 → crc_framework-0.2.1}/crates/core/src/distribution.rs

@@ -256,6 +256,47 @@ impl Distribution for EmpiricalDistribution {
     }
 }
 
+/// A degenerate distribution whose entire probability mass is at one value.
+#[derive(Debug, Clone, Copy)]
+pub struct PointMassDistribution {
+    location: f64,
+}
+
+impl PointMassDistribution {
+    pub fn new(location: f64) -> Result<Self> {
+        if !location.is_finite() {
+            return Err(CrcError::InvalidInput(
+                "point-mass location must be finite".into(),
+            ));
+        }
+        Ok(Self { location })
+    }
+
+    pub fn location(&self) -> f64 {
+        self.location
+    }
+}
+
+impl Distribution for PointMassDistribution {
+    fn pdf(&self, _x: f64) -> f64 {
+        // A Dirac mass has no finite density with respect to Lebesgue measure.
+        0.0
+    }
+
+    fn cdf(&self, x: f64) -> f64 {
+        if x < self.location { 0.0 } else { 1.0 }
+    }
+
+    fn ppf(&self, probability: f64) -> Result<f64> {
+        validate_probability(probability)?;
+        Ok(self.location)
+    }
+
+    fn sample(&self, size: usize, _seed: Option<u64>) -> Result<Vec<f64>> {
+        Ok(vec![self.location; size])
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum DistributionFamily {
     GenExtreme,
@@ -1129,6 +1170,18 @@ fn erf(x: f64) -> f64 {
 mod tests {
     use super::*;
 
+    #[test]
+    fn point_mass_is_exact_at_every_probability() {
+        let distribution = PointMassDistribution::new(2.5).unwrap();
+        assert_eq!(
+            distribution.quantiles(&[0.0, 0.5, 1.0]).unwrap(),
+            vec![2.5; 3]
+        );
+        assert_eq!(distribution.cdf(2.49), 0.0);
+        assert_eq!(distribution.cdf(2.5), 1.0);
+        assert_eq!(distribution.sample(3, Some(42)).unwrap(), vec![2.5; 3]);
+    }
+
     #[test]
     fn return_periods_convert_to_upper_tail_probabilities() {
         let distribution = TabulatedDistribution::from_return_periods(

{crc_framework-0.2.0 → crc_framework-0.2.1}/crates/core/src/lib.rs

@@ -10,8 +10,8 @@ pub mod transform;
 pub use distribution::{
     DiagnosticMetrics, Distribution, DistributionFamily, EmpiricalDistribution, FitResult,
     FittedDistribution, HurdleDistribution, HurdleQuantileFitDiagnostics, HurdleQuantileFitResult,
-    Interpolation, QuantileFitDiagnostics, QuantileFitResult, TabulatedDistribution, Tail,
-    fit_hurdle_quantiles, fit_quantiles,
+    Interpolation, PointMassDistribution, QuantileFitDiagnostics, QuantileFitResult,
+    TabulatedDistribution, Tail, fit_hurdle_quantiles, fit_quantiles,
 };
 pub use error::{CrcError, Result};
 pub use metrics::{

{crc_framework-0.2.0 → crc_framework-0.2.1}/python/crc_framework/__init__.py

@@ -11,6 +11,7 @@ from .distributions import (
     HurdleDistribution,
     HurdleQuantileFitDiagnostics,
     HurdleQuantileFitResult,
+    PointMassDistribution,
     QuantileFitDiagnostics,
     QuantileFitResult,
     TabulatedDistribution,
@@ -44,34 +45,35 @@ from .transforms import (
 )
 
 __all__ = [
+    "HORIZONS",
+    "PATHWAYS",
+    "RISK_FACTORS",
     "BinaryOutcome",
     "CallableImpact",
     "CallableTransform",
     "ClimateImpact",
     "Distribution",
     "EmpiricalDistribution",
-    "FitDiagnostics",
     "FitConstraints",
+    "FitDiagnostics",
     "FitResult",
     "FittedDistribution",
+    "Geography",
     "HurdleDistribution",
     "HurdleQuantileFitDiagnostics",
     "HurdleQuantileFitResult",
-    "Geography",
-    "HORIZONS",
     "ImpactFunction",
     "ImpactRegistry",
     "LinearImpact",
     "Microscore",
     "MicroscoreSuite",
-    "PATHWAYS",
     "Pathway",
     "PiecewiseLinearImpact",
-    "RISK_FACTORS",
-    "RiskFactor",
-    "RiskResult",
+    "PointMassDistribution",
     "QuantileFitDiagnostics",
     "QuantileFitResult",
+    "RiskFactor",
+    "RiskResult",
     "ScenarioMetadata",
     "SigmoidImpact",
     "TabulatedDistribution",

{crc_framework-0.2.0 → crc_framework-0.2.1}/python/crc_framework/_core.pyi

@@ -100,6 +100,7 @@ class NativeRiskResult:
     branch_count: int
 
 def empirical_distribution(samples: Sequence[float]) -> NativeDistribution: ...
+def point_mass_distribution(location: float) -> NativeDistribution: ...
 def tabulated_distribution(
     probabilities: Sequence[float],
     values: Sequence[float],

{crc_framework-0.2.0 → crc_framework-0.2.1}/python/crc_framework/distributions/__init__.py

@@ -16,24 +16,26 @@ from .fitting import (
     quality_metrics,
 )
 from .hurdle import HurdleDistribution
+from .point_mass import PointMassDistribution
 from .tabulated import Interpolation, TabulatedDistribution, Tail
 
 __all__ = [
     "Distribution",
     "DistributionFamily",
     "EmpiricalDistribution",
-    "FitDiagnostics",
     "FitConstraints",
+    "FitDiagnostics",
     "FitResult",
     "FittedDistribution",
     "HurdleDistribution",
     "HurdleQuantileFitDiagnostics",
     "HurdleQuantileFitResult",
     "Interpolation",
-    "TabulatedDistribution",
-    "Tail",
+    "PointMassDistribution",
     "QuantileFitDiagnostics",
     "QuantileFitResult",
+    "TabulatedDistribution",
+    "Tail",
     "fit_all",
     "fit_distribution",
     "fit_hurdle_quantiles",

crc_framework-0.2.1/python/crc_framework/distributions/point_mass.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import numpy as np
+import numpy.typing as npt
+
+from crc_framework import _core
+
+from .base import ArrayLike
+from .empirical import _evaluate
+
+
+class PointMassDistribution:
+    """A distribution concentrated exactly at one finite value."""
+
+    def __init__(
+        self,
+        location: float,
+        *,
+        _native: _core.NativeDistribution | None = None,
+    ) -> None:
+        self.location = float(location)
+        self._native = _native or _core.point_mass_distribution(self.location)
+
+    def point_mass(self, x: ArrayLike) -> float | npt.NDArray[np.float64]:
+        values = np.asarray(x, dtype=np.float64)
+        masses = np.where(values == self.location, 1.0, 0.0)
+        if values.ndim == 0:
+            return float(masses)
+        return np.asarray(masses, dtype=np.float64)
+
+    def pdf(self, x: ArrayLike) -> float | npt.NDArray[np.float64]:
+        return _evaluate(self._native, "pdf", x)
+
+    def cdf(self, x: ArrayLike) -> float | npt.NDArray[np.float64]:
+        return _evaluate(self._native, "cdf", x)
+
+    def ppf(self, probability: ArrayLike) -> float | npt.NDArray[np.float64]:
+        return _evaluate(self._native, "ppf", probability)
+
+    def quantiles(self, probabilities: ArrayLike) -> npt.NDArray[np.float64]:
+        values = np.asarray(probabilities, dtype=np.float64)
+        return np.asarray(
+            self._native.quantiles(values.reshape(-1).tolist()), dtype=np.float64
+        ).reshape(values.shape)
+
+    def sample(
+        self,
+        size: int,
+        *,
+        rng: np.random.Generator | None = None,
+        seed: int | None = None,
+    ) -> npt.NDArray[np.float64]:
+        if rng is not None and seed is not None:
+            raise ValueError("provide either rng or seed, not both")
+        return np.full(size, self.location, dtype=np.float64)

{crc_framework-0.2.0 → crc_framework-0.2.1}/src/lib.rs

@@ -2,8 +2,8 @@ use std::{collections::HashMap, sync::Arc};
 
 use crc_framework_core::{
     BinaryOutcome, Distribution, DistributionFamily, EmpiricalDistribution, FittedDistribution,
-    HurdleDistribution, ImpactContext, ImpactRegistry, Interpolation, ScenarioMetadata,
-    TabulatedDistribution, Tail, Transform, compute_risk, compute_spanning_set,
+    HurdleDistribution, ImpactContext, ImpactRegistry, Interpolation, PointMassDistribution,
+    ScenarioMetadata, TabulatedDistribution, Tail, Transform, compute_risk, compute_spanning_set,
     fit_hurdle_quantiles as core_fit_hurdle_quantiles, fit_quantiles as core_fit_quantiles,
     generate_microscores,
 };
@@ -246,6 +246,18 @@ fn empirical_distribution(samples: Vec<f64>) -> PyResult<PyDistribution> {
     })
 }
 
+#[pyfunction]
+fn point_mass_distribution(location: f64) -> PyResult<PyDistribution> {
+    let distribution = PointMassDistribution::new(location).map_err(py_error)?;
+    Ok(PyDistribution {
+        inner: Arc::new(distribution),
+        family: None,
+        shape: None,
+        location: Some(location),
+        scale: None,
+    })
+}
+
 fn interpolation(value: &str) -> PyResult<Interpolation> {
     match value {
         "linear_probability" => Ok(Interpolation::LinearProbability),
@@ -365,6 +377,7 @@ fn fit_candidates(samples: Vec<f64>) -> PyResult<Vec<PyFitResult>> {
 #[pyfunction]
 #[pyo3(signature = (probabilities, values, family, weights=None))]
 fn fit_quantiles(
+    py: Python<'_>,
     probabilities: Vec<f64>,
     values: Vec<f64>,
     family: &str,
@@ -372,7 +385,7 @@ fn fit_quantiles(
 ) -> PyResult<PyQuantileFitResult> {
     let family = DistributionFamily::from_name(family)
         .ok_or_else(|| PyValueError::new_err(format!("unknown distribution family {family}")))?;
-    core_fit_quantiles(&probabilities, &values, weights.as_deref(), family)
+    py.detach(move || core_fit_quantiles(&probabilities, &values, weights.as_deref(), family))
         .map(quantile_fit_result_py)
         .map_err(py_error)
 }
@@ -387,6 +400,7 @@ fn fit_quantiles(
     weights=None
 ))]
 fn fit_hurdle_quantiles(
+    py: Python<'_>,
     probabilities: Vec<f64>,
     values: Vec<f64>,
     family: &str,
@@ -396,14 +410,16 @@ fn fit_hurdle_quantiles(
 ) -> PyResult<PyHurdleQuantileFitResult> {
     let family = DistributionFamily::from_name(family)
         .ok_or_else(|| PyValueError::new_err(format!("unknown distribution family {family}")))?;
-    core_fit_hurdle_quantiles(
-        &probabilities,
-        &values,
-        weights.as_deref(),
-        family,
-        atom_location,
-        atom_probability,
-    )
+    py.detach(move || {
+        core_fit_hurdle_quantiles(
+            &probabilities,
+            &values,
+            weights.as_deref(),
+            family,
+            atom_location,
+            atom_probability,
+        )
+    })
     .map(hurdle_quantile_fit_result_py)
     .map_err(py_error)
 }
@@ -869,6 +885,7 @@ fn _core(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<PyRiskLevel>()?;
     m.add_class::<PyRiskResult>()?;
     m.add_function(wrap_pyfunction!(empirical_distribution, m)?)?;
+    m.add_function(wrap_pyfunction!(point_mass_distribution, m)?)?;
     m.add_function(wrap_pyfunction!(tabulated_distribution, m)?)?;
     m.add_function(wrap_pyfunction!(return_period_distribution, m)?)?;
     m.add_function(wrap_pyfunction!(fitted_distribution, m)?)?;

{crc_framework-0.2.0 → crc_framework-0.2.1}/tests/test_sdk.py

@@ -1,13 +1,13 @@
 import unittest
 
 import numpy as np
-
 from crc_framework import (
     BinaryOutcome,
     EmpiricalDistribution,
     FitConstraints,
     FittedDistribution,
     HurdleDistribution,
+    PointMassDistribution,
     RiskFactor,
     ScenarioMetadata,
     TabulatedDistribution,
@@ -27,6 +27,18 @@ from crc_framework import (
 
 
 class DistributionTests(unittest.TestCase):
+    def test_point_mass_is_exact_at_every_probability(self):
+        distribution = PointMassDistribution(0.0)
+
+        np.testing.assert_array_equal(
+            distribution.quantiles([0.0, 0.5, 0.999, 1.0]),
+            np.zeros(4),
+        )
+        self.assertEqual(distribution.cdf(-0.1), 0.0)
+        self.assertEqual(distribution.cdf(0.0), 1.0)
+        self.assertEqual(distribution.point_mass(0.0), 1.0)
+        np.testing.assert_array_equal(distribution.sample(3), np.zeros(3))
+
     def test_return_period_input_uses_canonical_probability(self):
         distribution = TabulatedDistribution.from_return_periods(
             [10, 100, 1000],
@@ -44,7 +56,9 @@ class DistributionTests(unittest.TestCase):
         self.assertEqual(result.distribution.quantiles([0.1, 0.5, 0.9]).shape, (3,))
         self.assertEqual(result.distribution.sample(4, seed=42).shape, (4,))
         diagnostics = quality_metrics(source, result.distribution)
-        self.assertAlmostEqual(diagnostics.ks_statistic, result.diagnostics.ks_statistic)
+        self.assertAlmostEqual(
+            diagnostics.ks_statistic, result.diagnostics.ks_statistic
+        )
         constrained = fit_distribution(
             source,
             constraints=FitConstraints(probability=0.99, maximum_value=100.0),
@@ -72,16 +86,12 @@ class DistributionTests(unittest.TestCase):
         )
 
     def test_sample_fit_rejects_probability_knots(self):
-        tabulated = TabulatedDistribution(
-            [0.1, 0.3, 0.6, 0.9], [0.0, 1.0, 2.0, 3.0]
-        )
+        tabulated = TabulatedDistribution([0.1, 0.3, 0.6, 0.9], [0.0, 1.0, 2.0, 3.0])
         with self.assertRaisesRegex(ValueError, "fit_quantiles"):
             fit_distribution(tabulated)  # type: ignore[arg-type]
 
     def test_hurdle_constructor_preserves_atom_and_truncated_tail(self):
-        base = FittedDistribution.from_parameters(
-            "gumbel_r", location=0.5, scale=1.2
-        )
+        base = FittedDistribution.from_parameters("gumbel_r", location=0.5, scale=1.2)
         hurdle = HurdleDistribution(base, atom_probability=0.4)
         self.assertEqual(hurdle.ppf(0.4), 0.0)
         self.assertEqual(hurdle.point_mass(0.0), 0.4)
@@ -158,9 +168,7 @@ class PipelineTests(unittest.TestCase):
 class SpatialAndConstantTests(unittest.TestCase):
     def test_reference_spatial_tables_are_exposed_without_silent_defaults(self):
         self.assertEqual(lookup_continent(594475228122316799), "Europe")
-        self.assertEqual(
-            lookup_ipcc_region(594479566039285759), "Greenland/Iceland"
-        )
+        self.assertEqual(lookup_ipcc_region(594479566039285759), "Greenland/Iceland")
         geography = lookup_geography(600550049193132031)
         self.assertIsNotNone(geography)
         self.assertEqual(geography.continent, "Africa")