feat!: Require contiguous storage for x values

In my code, I often need to pass x to an evalution procedure that takes &[f64] slice. Therefore I had to collect the values to a newly allocated Vec in order to achieve that. To me, requiring contiguous storage for x is reasonable limitation as it usually is a vector. For fx, contiguous storage is not required at the moment as I haven't encountered a situation where I needed it.
datamole-ai · Apr 12, 2022 · b63317d · b63317d
1 parent e31c75a
commit b63317d
Show file tree

Hide file tree

Showing 14 changed files with 57 additions and 53 deletions.
diff --git a/benches/solvers.rs b/benches/solvers.rs
@@ -1,5 +1,6 @@
 use criterion::{criterion_group, criterion_main, Criterion};
 use gomez::{
+    nalgebra as na,
     prelude::*,
     solver::{NelderMead, TrustRegion},
     testing::*,
@@ -9,7 +10,7 @@ use gsl_wrapper::{
     multiroot::{Solver as GslSolver, SolverType::HybridScaled},
     prelude::*,
 };
-use nalgebra as na;
+use na::IsContiguous;
 
 const MAX_ITERS: usize = 1_000_000;
 const TOLERANCE: f64 = 1e-12;
@@ -275,7 +276,7 @@ where
         fx: &mut na::Vector<F::Scalar, F::Dim, Sfx>,
     ) -> Result<(), Self::Error>
     where
-        Sx: na::storage::StorageMut<F::Scalar, F::Dim>,
+        Sx: na::storage::StorageMut<F::Scalar, F::Dim> + IsContiguous,
         Sfx: na::storage::StorageMut<F::Scalar, F::Dim>,
     {
         let result = self.solver.step().to_result();

diff --git a/examples/rosenbrock.rs b/examples/rosenbrock.rs
@@ -1,7 +1,7 @@
 use gomez::nalgebra as na;
 use gomez::prelude::*;
 use gomez::solver::TrustRegion;
-use na::{Dim, DimName};
+use na::{Dim, DimName, IsContiguous};
 
 // https://en.wikipedia.org/wiki/Rosenbrock_function
 struct Rosenbrock {
@@ -25,7 +25,7 @@ impl System for Rosenbrock {
         fx: &mut na::Vector<Self::Scalar, Self::Dim, Sfx>,
     ) -> Result<(), Error>
     where
-        Sx: na::storage::Storage<Self::Scalar, Self::Dim>,
+        Sx: na::storage::Storage<Self::Scalar, Self::Dim> + IsContiguous,
         Sfx: na::storage::StorageMut<Self::Scalar, Self::Dim>,
     {
         fx[0] = (self.a - x[0]).powi(2);

diff --git a/src/analysis/initial.rs b/src/analysis/initial.rs
@@ -11,7 +11,7 @@ use std::marker::PhantomData;
 
 use nalgebra::{
     allocator::Allocator, convert, storage::StorageMut, ComplexField, DefaultAllocator, DimMin,
-    DimName, OVector, Vector, U1,
+    DimName, IsContiguous, OVector, Vector, U1,
 };
 use thiserror::Error;
 
@@ -52,7 +52,7 @@ where
         fx: &mut Vector<F::Scalar, F::Dim, Sfx>,
     ) -> Result<Self, InitialGuessAnalysisError>
     where
-        Sx: StorageMut<F::Scalar, F::Dim>,
+        Sx: StorageMut<F::Scalar, F::Dim> + IsContiguous,
         Sfx: StorageMut<F::Scalar, F::Dim>,
     {
         let scale_iter = dom.vars().iter().map(|var| var.scale());

diff --git a/src/core/function.rs b/src/core/function.rs
@@ -1,5 +1,6 @@
 use nalgebra::{
-    allocator::Allocator, storage::Storage, storage::StorageMut, DefaultAllocator, Vector,
+    allocator::Allocator, storage::Storage, storage::StorageMut, DefaultAllocator, IsContiguous,
+    Vector,
 };
 use num_traits::Zero;
 
@@ -19,7 +20,7 @@ use super::{
 /// ```rust
 /// use gomez::nalgebra as na;
 /// use gomez::prelude::*;
-/// use na::{Dim, DimName};
+/// use na::{Dim, DimName, IsContiguous};
 ///
 /// // A problem is represented by a type.
 /// struct Rosenbrock {
@@ -46,7 +47,7 @@ use super::{
 ///         x: &na::Vector<Self::Scalar, Self::Dim, Sx>,
 ///     ) -> Result<Self::Scalar, Error>
 ///     where
-///         Sx: na::storage::Storage<Self::Scalar, Self::Dim>,
+///         Sx: na::storage::Storage<Self::Scalar, Self::Dim> + IsContiguous,
 ///     {
 ///         // Compute the function value.
 ///         Ok((self.a - x[0]).powi(2) + self.b * (x[1] - x[0].powi(2)).powi(2))
@@ -57,7 +58,7 @@ pub trait Function: Problem {
     /// Calculate the function value given values of the variables.
     fn apply<Sx>(&self, x: &Vector<Self::Scalar, Self::Dim, Sx>) -> Result<Self::Scalar, Error>
     where
-        Sx: Storage<Self::Scalar, Self::Dim>;
+        Sx: Storage<Self::Scalar, Self::Dim> + IsContiguous;
 
     /// Calculate the norm of residuals of the system given values of the
     /// variable for cases when the function is actually a system of equations.
@@ -71,7 +72,7 @@ pub trait Function: Problem {
         fx: &mut Vector<Self::Scalar, Self::Dim, Sfx>,
     ) -> Result<Self::Scalar, Error>
     where
-        Sx: Storage<Self::Scalar, Self::Dim>,
+        Sx: Storage<Self::Scalar, Self::Dim> + IsContiguous,
         Sfx: StorageMut<Self::Scalar, Self::Dim>,
     {
         let norm = self.apply(x)?;
@@ -87,7 +88,7 @@ where
 {
     fn apply<Sx>(&self, x: &Vector<Self::Scalar, Self::Dim, Sx>) -> Result<Self::Scalar, Error>
     where
-        Sx: Storage<Self::Scalar, Self::Dim>,
+        Sx: Storage<Self::Scalar, Self::Dim> + IsContiguous,
     {
         let mut fx = x.clone_owned();
         self.apply_eval(x, &mut fx)
@@ -99,7 +100,7 @@ where
         fx: &mut Vector<Self::Scalar, Self::Dim, Sfx>,
     ) -> Result<Self::Scalar, Error>
     where
-        Sx: Storage<Self::Scalar, Self::Dim>,
+        Sx: Storage<Self::Scalar, Self::Dim> + IsContiguous,
         Sfx: StorageMut<Self::Scalar, Self::Dim>,
     {
         self.eval(x, fx)?;

diff --git a/src/core/optimizer.rs b/src/core/optimizer.rs
@@ -1,4 +1,4 @@
-use nalgebra::{storage::StorageMut, Vector};
+use nalgebra::{storage::StorageMut, IsContiguous, Vector};
 
 use super::{domain::Domain, function::Function};
 
@@ -22,7 +22,7 @@ use super::{domain::Domain, function::Function};
 /// ```rust
 /// use gomez::nalgebra as na;
 /// use gomez::core::*;
-/// use na::{storage::StorageMut, Vector};
+/// use na::{storage::StorageMut, IsContiguous, Vector};
 /// use rand::Rng;
 /// use rand_distr::{uniform::SampleUniform, Distribution, Uniform};
 ///
@@ -50,7 +50,7 @@ use super::{domain::Domain, function::Function};
 ///         x: &mut Vector<F::Scalar, F::Dim, Sx>,
 ///     ) -> Result<F::Scalar, Self::Error>
 ///     where
-///         Sx: StorageMut<F::Scalar, F::Dim>,
+///         Sx: StorageMut<F::Scalar, F::Dim> + IsContiguous,
 ///     {
 ///         // Randomly sample within the bounds.
 ///         x.iter_mut().zip(dom.vars().iter()).for_each(|(xi, vi)| {
@@ -92,5 +92,5 @@ pub trait Optimizer<F: Function> {
         x: &mut Vector<F::Scalar, F::Dim, Sx>,
     ) -> Result<F::Scalar, Self::Error>
     where
-        Sx: StorageMut<F::Scalar, F::Dim>;
+        Sx: StorageMut<F::Scalar, F::Dim> + IsContiguous;
 }
diff --git a/src/core/solver.rs b/src/core/solver.rs
@@ -1,4 +1,4 @@
-use nalgebra::{storage::StorageMut, Vector};
+use nalgebra::{storage::StorageMut, IsContiguous, Vector};
 
 use super::{domain::Domain, system::System};
 
@@ -22,7 +22,7 @@ use super::{domain::Domain, system::System};
 /// ```rust
 /// use gomez::nalgebra as na;
 /// use gomez::core::*;
-/// use na::{storage::StorageMut, Vector};
+/// use na::{storage::StorageMut, IsContiguous, Vector};
 /// use rand::Rng;
 /// use rand_distr::{uniform::SampleUniform, Distribution, Uniform};
 ///
@@ -51,7 +51,7 @@ use super::{domain::Domain, system::System};
 ///         fx: &mut Vector<F::Scalar, F::Dim, Sfx>,
 ///     ) -> Result<(), Self::Error>
 ///     where
-///         Sx: StorageMut<F::Scalar, F::Dim>,
+///         Sx: StorageMut<F::Scalar, F::Dim> + IsContiguous,
 ///         Sfx: StorageMut<F::Scalar, F::Dim>,
 ///     {
 ///         // Randomly sample within the bounds.
@@ -96,6 +96,6 @@ pub trait Solver<F: System> {
         fx: &mut Vector<F::Scalar, F::Dim, Sfx>,
     ) -> Result<(), Self::Error>
     where
-        Sx: StorageMut<F::Scalar, F::Dim>,
+        Sx: StorageMut<F::Scalar, F::Dim> + IsContiguous,
         Sfx: StorageMut<F::Scalar, F::Dim>;
 }
diff --git a/src/core/system.rs b/src/core/system.rs
@@ -1,7 +1,7 @@
 use nalgebra::{
     allocator::Allocator,
     storage::{Storage, StorageMut},
-    DefaultAllocator, OVector, Vector,
+    DefaultAllocator, IsContiguous, OVector, Vector,
 };
 
 use super::{
@@ -20,7 +20,7 @@ use super::{
 /// ```rust
 /// use gomez::nalgebra as na;
 /// use gomez::prelude::*;
-/// use na::{Dim, DimName};
+/// use na::{Dim, DimName, IsContiguous};
 ///
 /// // A problem is represented by a type.
 /// struct Rosenbrock {
@@ -48,7 +48,7 @@ use super::{
 ///         fx: &mut na::Vector<Self::Scalar, Self::Dim, Sfx>,
 ///     ) -> Result<(), Error>
 ///     where
-///         Sx: na::storage::Storage<Self::Scalar, Self::Dim>,
+///         Sx: na::storage::Storage<Self::Scalar, Self::Dim> + IsContiguous,
 ///         Sfx: na::storage::StorageMut<Self::Scalar, Self::Dim>,
 ///     {
 ///         // Compute the residuals of all equations.
@@ -67,7 +67,7 @@ pub trait System: Problem {
         fx: &mut Vector<Self::Scalar, Self::Dim, Sfx>,
     ) -> Result<(), Error>
     where
-        Sx: Storage<Self::Scalar, Self::Dim>,
+        Sx: Storage<Self::Scalar, Self::Dim> + IsContiguous,
         Sfx: StorageMut<Self::Scalar, Self::Dim>;
 }
 
@@ -150,7 +150,7 @@ where
         fx: &mut Vector<Self::Scalar, Self::Dim, Sfx>,
     ) -> Result<(), Error>
     where
-        Sx: Storage<Self::Scalar, Self::Dim>,
+        Sx: Storage<Self::Scalar, Self::Dim> + IsContiguous,
         Sfx: StorageMut<Self::Scalar, Self::Dim>,
     {
         // TODO: RepulsiveSystem should adjust the residuals of the inner system

diff --git a/src/derivatives.rs b/src/derivatives.rs
@@ -6,7 +6,7 @@ use nalgebra::{
     allocator::Allocator,
     convert,
     storage::{Storage, StorageMut},
-    ComplexField, DefaultAllocator, OMatrix, RealField, Vector,
+    ComplexField, DefaultAllocator, IsContiguous, OMatrix, RealField, Vector,
 };
 use num_traits::{One, Zero};
 use thiserror::Error;
@@ -60,7 +60,7 @@ where
         fx: &Vector<F::Scalar, F::Dim, Sfx>,
     ) -> Result<Self, JacobianError>
     where
-        Sx: StorageMut<F::Scalar, F::Dim>,
+        Sx: StorageMut<F::Scalar, F::Dim> + IsContiguous,
         Sscale: Storage<F::Scalar, F::Dim>,
         Sfx: Storage<F::Scalar, F::Dim>,
     {
@@ -86,7 +86,7 @@ where
         fx: &Vector<F::Scalar, F::Dim, Sfx>,
     ) -> Result<&mut Self, JacobianError>
     where
-        Sx: StorageMut<F::Scalar, F::Dim>,
+        Sx: StorageMut<F::Scalar, F::Dim> + IsContiguous,
         Sscale: Storage<F::Scalar, F::Dim>,
         Sfx: Storage<F::Scalar, F::Dim>,
     {

diff --git a/src/lib.rs b/src/lib.rs
@@ -70,7 +70,7 @@
 //! // Gomez is based on `nalgebra` crate.
 //! use gomez::nalgebra as na;
 //! use gomez::prelude::*;
-//! use na::{Dim, DimName};
+//! use na::{Dim, DimName, IsContiguous};
 //!
 //! // A problem is represented by a type.
 //! struct Rosenbrock {
@@ -98,7 +98,7 @@
 //!         fx: &mut na::Vector<Self::Scalar, Self::Dim, Sfx>,
 //!     ) -> Result<(), Error>
 //!     where
-//!         Sx: na::storage::Storage<Self::Scalar, Self::Dim>,
+//!         Sx: na::storage::Storage<Self::Scalar, Self::Dim> + IsContiguous,
 //!         Sfx: na::storage::StorageMut<Self::Scalar, Self::Dim>,
 //!     {
 //!         // Compute the residuals of all equations.
@@ -161,7 +161,7 @@
 //! use gomez::prelude::*;
 //! // Pick your solver.
 //! use gomez::solver::TrustRegion;
-//! # use na::{Dim, DimName};
+//! # use na::{Dim, DimName, IsContiguous};
 //! #
 //! # struct Rosenbrock {
 //! #     a: f64,
@@ -184,7 +184,7 @@
 //! #         fx: &mut na::Vector<Self::Scalar, Self::Dim, Sfx>,
 //! #     ) -> Result<(), Error>
 //! #     where
-//! #         Sx: na::storage::Storage<Self::Scalar, Self::Dim>,
+//! #         Sx: na::storage::Storage<Self::Scalar, Self::Dim> + IsContiguous,
 //! #         Sfx: na::storage::StorageMut<Self::Scalar, Self::Dim>,
 //! #     {
 //! #         fx[0] = (self.a - x[0]).powi(2);

diff --git a/src/solver/cuckoo.rs b/src/solver/cuckoo.rs
@@ -24,7 +24,7 @@ use nalgebra::{
     allocator::{Allocator, Reallocator},
     convert,
     storage::StorageMut,
-    DefaultAllocator, DimMin, DimName, Dynamic, OVector, Vector, U1,
+    DefaultAllocator, DimMin, DimName, Dynamic, IsContiguous, OVector, Vector, U1,
 };
 use num_traits::{Float, Zero};
 use rand::Rng;
@@ -213,7 +213,7 @@ where
         x: &mut Vector<F::Scalar, F::Dim, Sx>,
     ) -> Result<F::Scalar, CuckooError>
     where
-        Sx: StorageMut<F::Scalar, F::Dim>,
+        Sx: StorageMut<F::Scalar, F::Dim> + IsContiguous,
     {
         let CuckooOptions {
             scale_factor,
@@ -360,7 +360,7 @@ where
         x: &mut Vector<F::Scalar, F::Dim, Sx>,
     ) -> Result<F::Scalar, Self::Error>
     where
-        Sx: StorageMut<F::Scalar, F::Dim>,
+        Sx: StorageMut<F::Scalar, F::Dim> + IsContiguous,
     {
         self.next_inner(f, dom, x)
     }
@@ -387,7 +387,7 @@ where
         fx: &mut Vector<F::Scalar, F::Dim, Sfx>,
     ) -> Result<(), Self::Error>
     where
-        Sx: StorageMut<F::Scalar, F::Dim>,
+        Sx: StorageMut<F::Scalar, F::Dim> + IsContiguous,
         Sfx: StorageMut<F::Scalar, F::Dim>,
     {
         self.next_inner(f, dom, x)

diff --git a/src/solver/nelder_mead.rs b/src/solver/nelder_mead.rs
@@ -23,7 +23,7 @@ use nalgebra::{
     allocator::Allocator,
     convert,
     storage::{Storage, StorageMut},
-    DefaultAllocator, Dim, DimName, OVector, RealField, Vector, U1,
+    DefaultAllocator, Dim, DimName, IsContiguous, OVector, RealField, Vector, U1,
 };
 use num_traits::{One, Zero};
 use thiserror::Error;
@@ -200,7 +200,7 @@ where
         x: &mut Vector<<F>::Scalar, <F>::Dim, Sx>,
     ) -> Result<F::Scalar, NelderMeadError>
     where
-        Sx: StorageMut<<F>::Scalar, <F>::Dim>,
+        Sx: StorageMut<<F>::Scalar, <F>::Dim> + IsContiguous,
     {
         let NelderMeadOptions {
             reflection_coeff,
@@ -488,7 +488,7 @@ where
         x: &mut Vector<F::Scalar, F::Dim, Sx>,
     ) -> Result<F::Scalar, Self::Error>
     where
-        Sx: StorageMut<F::Scalar, F::Dim>,
+        Sx: StorageMut<F::Scalar, F::Dim> + IsContiguous,
     {
         self.next_inner(f, dom, x)
     }
@@ -511,7 +511,7 @@ where
         fx: &mut Vector<<F>::Scalar, <F>::Dim, Sfx>,
     ) -> Result<(), Self::Error>
     where
-        Sx: StorageMut<<F>::Scalar, <F>::Dim>,
+        Sx: StorageMut<<F>::Scalar, <F>::Dim> + IsContiguous,
         Sfx: StorageMut<<F>::Scalar, <F>::Dim>,
     {
         self.next_inner(f, dom, x).map(|_| {

diff --git a/src/solver/steffensen.rs b/src/solver/steffensen.rs
@@ -15,7 +15,7 @@
 use std::marker::PhantomData;
 
 use getset::{CopyGetters, Setters};
-use nalgebra::{storage::StorageMut, Dim, Vector};
+use nalgebra::{storage::StorageMut, Dim, IsContiguous, Vector};
 use thiserror::Error;
 
 use crate::core::{Domain, Error, Problem, Solver, System, VectorDomainExt};
@@ -92,7 +92,7 @@ impl<F: System> Solver<F> for Steffensen<F> {
         fx: &mut Vector<<F>::Scalar, <F>::Dim, Sfx>,
     ) -> Result<(), Self::Error>
     where
-        Sx: StorageMut<<F>::Scalar, <F>::Dim>,
+        Sx: StorageMut<<F>::Scalar, <F>::Dim> + IsContiguous,
         Sfx: StorageMut<<F>::Scalar, <F>::Dim>,
     {
         if f.dim().value() != 1 {