Merge pull request #512 from light-curve/asarray

Cast inputs to a common dtype

Author: hombit

CHANGELOG.md

@@ -11,6 +11,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Mark the module as no-GIL, which enables free-threaded Python (can be built from source, not provided so far via
   PyPI/conda) https://github.com/light-curve/light-curve-python/pull/499
+- Allow non-numpy inputs and casting mismatched f32 arrays to f64 for the feature extractions with newly added
+  `cast: bool = False` argument. We plan to change the default value to `True` in a future 0.x version.
+  https://github.com/light-curve/light-curve-python/issues/509 https://github.com/light-curve/light-curve-python/pull/512
 
 ### Changed
 

light-curve/Cargo.lock

@@ -59,6 +59,7 @@ serde = { version = "1", features = ["derive"] }
 serde-pickle = "1"
 serde_json = "1"
 thiserror = "2"
+unarray = "0.1.4"
 unzip3 = "1.0.0"
 
 [dependencies.light-curve-dmdt]

light-curve/Cargo.toml

@@ -1142,21 +1142,27 @@ impl DmDt {
     ///     Time moments, must be sorted
     /// sorted : bool or None, optional
     ///     `True` guarantees that `t` is sorted
+    /// cast : bool
+    ///     If `False` allow np.ndarray input only, `True` allows casting.
+    ///     Casting provides more flexibility with input types at the cost of
+    //      performance.
     ///
     /// Returns
     /// 1d-array of float
     ///
-    #[pyo3(signature=(t, *, sorted=None))]
+    #[pyo3(signature=(t, *, sorted=None, cast=false))]
     fn count_dt<'py>(
         &self,
         py: Python<'py>,
         t: Bound<'py, PyAny>,
         sorted: Option<bool>,
+        cast: bool,
     ) -> Res<Bound<'py, PyUntypedArray>> {
         dtype_dispatch!(
             |t| self.dmdt_f32.py_count_dt(py, t, sorted),
             |t| self.dmdt_f64.py_count_dt(py, t, sorted),
-            t
+            t;
+            cast=cast
         )
     }
 
@@ -1203,24 +1209,30 @@ impl DmDt {
     ///     Magnitudes
     /// sorted : bool or None, optional
     ///     `True` guarantees that the light curve is sorted
+    /// cast : bool
+    ///     If `False` allow np.ndarray input only, `True` allows casting.
+    ///     Casting provides more flexibility with input types at the cost of
+    //      performance.
     ///
     /// Returns
     /// -------
     /// 2d-ndarray of float
     ///
-    #[pyo3(signature = (t, m, *, sorted=None))]
+    #[pyo3(signature = (t, m, *, sorted=None, cast=false))]
     fn points<'py>(
         &self,
         py: Python<'py>,
         t: Bound<'py, PyAny>,
         m: Bound<'py, PyAny>,
         sorted: Option<bool>,
+        cast: bool,
     ) -> Res<Bound<'py, PyUntypedArray>> {
         dtype_dispatch!(
             |t, m| self.dmdt_f32.py_points(py, t, m, sorted),
             |t, m| self.dmdt_f64.py_points(py, t, m, sorted),
             t,
-            =m
+            =m;
+            cast=cast
         )
     }
 
@@ -1372,26 +1384,31 @@ impl DmDt {
     ///     Uncertainties
     /// sorted : bool or None, optional
     ///     `True` guarantees that the light curve is sorted
-    ///
+    /// cast : bool
+    ///     If `False` allow np.ndarray input only, `True` allows casting.
+    ///     Casting provides more flexibility with input types at the cost of
+    //      performance.
     /// Returns
     /// -------
     /// 2d-array of float
     ///
-    #[pyo3(signature = (t, m, sigma, *, sorted=None))]
+    #[pyo3(signature = (t, m, sigma, *, sorted=None, cast=false))]
     fn gausses<'py>(
         &self,
         py: Python<'py>,
         t: Bound<'py, PyAny>,
         m: Bound<'py, PyAny>,
         sigma: Bound<'py, PyAny>,
         sorted: Option<bool>,
+        cast: bool,
     ) -> Res<Bound<'py, PyUntypedArray>> {
         dtype_dispatch!(
             |t, m, sigma| self.dmdt_f32.py_gausses(py, t, m, sigma, sorted),
             |t, m, sigma| self.dmdt_f64.py_gausses(py, t, m, sigma, sorted),
             t,
             =m,
-            =sigma
+            =sigma;
+            cast=cast
         )
     }
 

light-curve/src/dmdt.rs

@@ -47,49 +47,54 @@ names : list of str
 descriptions : list of str
     Feature descriptions"#;
 
-const METHOD_CALL_DOC: &str = r#"__call__(self, t, m, sigma=None, *, sorted=None, check=True, fill_value=None)
+const METHOD_CALL_DOC: &str = r#"__call__(self, t, m, sigma=None, *, fill_value=None, sorted=None, check=True, cast=False)
     Extract features and return them as a numpy array
 
     Parameters
     ----------
     t : numpy.ndarray of np.float32 or np.float64 dtype
         Time moments
-    m : numpy.ndarray of the same dtype and size as t
+    m : numpy.ndarray
         Signal in magnitude or fluxes. Refer to the feature description to
         decide which would work better in your case
-    sigma : numpy.ndarray of the same dtype and size as t, optional
+    sigma : numpy.ndarray, optional
         Observation error, if None it is assumed to be unity
+    fill_value : float or None, optional
+        Value to fill invalid feature values, for example if count of
+        observations is not enough to find a proper value.
+        None causes exception for invalid features
     sorted : bool or None, optional
         Specifies if input array are sorted by time moments.
         True is for certainly sorted, False is for unsorted.
         If None is specified than sorting is checked and an exception is
         raised for unsorted `t`
     check : bool, optional
         Check all input arrays for NaNs, `t` and `m` for infinite values
-    fill_value : float or None, optional
-        Value to fill invalid feature values, for example if count of
-        observations is not enough to find a proper value.
-        None causes exception for invalid features
-
+    cast : bool, optional
+        Allows non-numpy input and casting of arrays to a common dtype.
+        If `False`, inputs must be `np.ndarray` instances with matched dtypes.
+        Casting provides more flexibility with input types at the cost of
+        performance.
     Returns
     -------
     ndarray of np.float32 or np.float64
         Extracted feature array"#;
 
 macro_const! {
     const METHOD_MANY_DOC: &str = r#"
-many(self, lcs, *, sorted=None, check=True, fill_value=None, n_jobs=-1)
+many(self, lcs, *, fill_value=None, sorted=None, check=True, cast=False, n_jobs=-1)
     Parallel light curve feature extraction
 
     It is a parallel executed equivalent of
-    >>> def many(self, lcs, *, sorted=None, check=True, fill_value=None):
+    >>> def many(self, lcs, *, fill_value=None, sorted=None, check=True):
     ...     return np.stack(
     ...         [
     ...             self(
     ...                 *lc,
+    ...                 fill_value=fill_value,
     ...                 sorted=sorted,
     ...                 check=check,
-    ...                 fill_value=fill_value
+    ...                 cast=False,
     ...             )
     ...             for lc in lcs
     ...         ]
@@ -101,13 +106,13 @@ many(self, lcs, *, sorted=None, check=True, fill_value=None, n_jobs=-1)
         A collection of light curves packed into three-tuples, all light curves
         must be represented by numpy.ndarray of the same dtype. See __call__
         documentation for details
+    fill_value : float or None, optional
+        Fill invalid values by this or raise an exception if None
     sorted : bool or None, optional
         Specifies if input array are sorted by time moments, see __call__
         documentation for details
     check : bool, optional
         Check all input arrays for NaNs, `t` and `m` for infinite values
-    fill_value : float or None, optional
-        Fill invalid values by this or raise an exception if None
     n_jobs : int
         Number of tasks to run in paralell. Default is -1 which means run as
         many jobs as CPU count. See rayon rust crate documentation for
@@ -440,19 +445,21 @@ impl PyFeatureEvaluator {
         m,
         sigma = None,
         *,
+        fill_value = None,
         sorted = None,
         check = true,
-        fill_value = None
+        cast = false,
     ))]
     fn __call__<'py>(
         &self,
         py: Python<'py>,
         t: Bound<'py, PyAny>,
         m: Bound<'py, PyAny>,
         sigma: Option<Bound<'py, PyAny>>,
+        fill_value: Option<f64>,
         sorted: Option<bool>,
         check: bool,
-        fill_value: Option<f64>,
+        cast: bool,
     ) -> Res<Bound<'py, PyUntypedArray>> {
         if let Some(sigma) = sigma {
             dtype_dispatch!(
@@ -484,7 +491,8 @@ impl PyFeatureEvaluator {
                 },
                 t,
                 =m,
-                =sigma
+                =sigma;
+                cast=cast
             )
         } else {
             dtype_dispatch!(
@@ -515,20 +523,21 @@ impl PyFeatureEvaluator {
                     )
                 },
                 t,
-                =m,
+                =m;
+                cast=cast
             )
         }
     }
 
     #[doc = METHOD_MANY_DOC!()]
-    #[pyo3(signature = (lcs, *, sorted=None, check=true, fill_value=None, n_jobs=-1))]
+    #[pyo3(signature = (lcs, *, fill_value=None, sorted=None, check=true, n_jobs=-1))]
     fn many<'py>(
         &self,
         py: Python<'py>,
         lcs: PyLcs<'py>,
+        fill_value: Option<f64>,
         sorted: Option<bool>,
         check: bool,
-        fill_value: Option<f64>,
         n_jobs: i64,
     ) -> Res<Bound<'py, PyUntypedArray>> {
         if lcs.is_empty() {
@@ -766,7 +775,7 @@ const SUPPORTED_ALGORITHMS_CURVE_FIT: [&str; N_ALGO_CURVE_FIT] = [
 ];
 
 macro_const! {
-    const FIT_METHOD_MODEL_DOC: &str = r#"model(t, params)
+    const FIT_METHOD_MODEL_DOC: &str = r#"model(t, params, *, cast=False)
     Underlying parametric model function
 
     Parameters
@@ -777,6 +786,8 @@ macro_const! {
         Parameters of the model, this array can be longer than actual parameter
         list, the beginning part of the array will be used in this case, see
         Examples section in the class documentation.
+    cast : bool, optional
+        Cast inputs to np.ndarray of the same dtype
 
     Returns
     -------
@@ -1015,14 +1026,16 @@ macro_rules! fit_evaluator {
 
             #[doc = FIT_METHOD_MODEL_DOC!()]
             #[staticmethod]
+            #[pyo3(signature = (t, params, *, cast=false))]
             fn model<'py>(
                 py: Python<'py>,
                 t: Bound<'py, PyAny>,
                 params: Bound<'py, PyAny>,
+                cast: bool
             ) -> Res<Bound<'py, PyUntypedArray>> {
                 dtype_dispatch!({
                     |t, params| Ok(Self::model_impl(t, params).into_pyarray(py).as_untyped().clone())
-                }(t, !=params))
+                }(t, !=params; cast=cast))
             }
 
             #[classattr]
@@ -1706,17 +1719,20 @@ impl Periodogram {
     }
 
     /// Angular frequencies and periodogram values
+    #[pyo3(signature = (t, m, *, cast=false))]
     fn freq_power<'py>(
         &self,
         py: Python<'py>,
         t: Bound<PyAny>,
         m: Bound<PyAny>,
+        cast: bool,
     ) -> Res<(Bound<'py, PyUntypedArray>, Bound<'py, PyUntypedArray>)> {
         dtype_dispatch!(
             |t, m| Ok(Self::freq_power_impl(&self.eval_f32, py, t, m)),
             |t, m| Ok(Self::freq_power_impl(&self.eval_f64, py, t, m)),
             t,
-            =m
+            =m;
+            cast=cast
         )
     }
 
@@ -1753,7 +1769,7 @@ transform : None, optional
     constructors
 
 {common}
-freq_power(t, m)
+freq_power(t, m, *, cast=False)
     Get periodogram
 
     Parameters
@@ -1762,6 +1778,8 @@ freq_power(t, m)
         Time array
     m : np.ndarray of np.float32 or np.float64
         Magnitude (flux) array
+    cast : bool, optional
+        Cast inputs to np.ndarray objects of the same dtype
 
     Returns
     -------