more clippy

Author: geo-ant

src/basis_function/mod.rs

@@ -9,6 +9,7 @@ use nalgebra::{DVector, Scalar};
 ///
 /// * `$\vec{x}$` is an independent variable, like time, spatial coordinates and so on,
 /// * `$\alpha_j$` are scalar parameter of this function
+///
 /// The functions must have at least one parameter argument additional ot the location parameter, i.e. a function
 /// `$f(\vec{x})$` does not satisfy the trait, but e.g. `$f(\vec{x},\alpha_1)$` does. The function
 /// must be vector valued and should produce a vector of the same size as `\vec{x}`. (If you want to
@@ -18,15 +19,20 @@ use nalgebra::{DVector, Scalar};
 /// If it is violated, then calculations using the basis function will return errors in the [SeparableModel](crate::model::SeparableModel).
 ///
 /// # Variadic Functions
+///
 /// Since Rust does not have variadic functions or generics, this trait is implemented for all functions up to
 /// a maximum number of arguments. Right now this is implemented for up to 10 arguments.
 ///
 /// # Generic Parameters
+///
 /// ## Scalar Type
+///
 /// The functions must have an interface `Fn(&DVector<ScalarType>,ScalarType)-> DVector<ScalarType>`,
 /// `Fn(&DVector<ScalarType>,ScalarType,ScalarType)-> DVector<ScalarType>` and so on.
 /// All numeric types, including the return value must be of the same scalar type.
+///
 /// ## ArgList : The argument list
+///
 /// This type is of no consequence for the user because it will be correctly inferred when
 /// passing a function. It is a [nifty trick](https://geo-ant.github.io/blog/2021/rust-traits-and-variadic-functions/)
 /// that allows us to implement this trait for functions taking different arguments. Just FYI: The
@@ -42,9 +48,10 @@ where
     /// # Arguments
     /// * `x`: the vector `$\vec{x}$`
     /// * `params`: The parameters `$(\alpha_1,...,\alpha_N)$` as a slice. The slice must have
-    /// the correct number of arguments for calling the function (no more, no less).
+    ///    the correct number of arguments for calling the function (no more, no less).
     ///
     /// # Effect and Panics
+    ///
     /// If the slice has fewer elements than the parameter argument list. If the slice has more element,
     /// only the first `$N$` elements are used and dispatched to the parameters in order, i.e.
     /// `$\alpha_1$`=`param[0]`, ..., `$\alpha_N$`=`param[N-1]`. Calling eval will result in evaluating

src/lib.rs

@@ -47,10 +47,11 @@
 //! Lets look at the components of this equation in more detail. The vector valued function
 //! `$\vec{f}(\vec{\alpha},\vec{c}) \in \mathbb{C}^{N_{data}}$` is the model we want to fit. It depends on
 //! two vector valued parameters:
+//!
 //! * `$\vec{\alpha}=(\alpha_1,\dots,\alpha_{N_{params}})^T$` is the vector of nonlinear model parameters.
-//! We will get back to these later.
+//!    We will get back to these later.
 //! * `$\vec{c}=(c_1,\dots,c_{N_{basis}})^T$` is the vector of coefficients for the basis functions.
-//! Those are the linear model parameters.
+//!    Those are the linear model parameters.
 //!
 //! Note that we call `$\vec{\alpha}$` the _nonlinear parameters_ and `$\vec{c}$` the _coefficients_ of the model
 //! just to make the distinction between the two types of parameters clear. The coefficients are
@@ -349,11 +350,11 @@
 //! statement is the following:
 //!
 //!  * We have not only one observation but a set `$\{\vec{y}_s\}$`, `$s=1,...,S$` of
-//! observations.
+//!    observations.
 //!  * We want to fit the separable nonlinear function `$\vec{f}(\vec{\alpha},\vec{c})$`
-//! to all vectors of observations, but in such a way that the linear parameters
-//! are allowed to vary with `$s$`, but the nonlinear parameters
-//! are the same for the whole dataset.
+//!    to all vectors of observations, but in such a way that the linear parameters
+//!    are allowed to vary with `$s$`, but the nonlinear parameters
+//!    are the same for the whole dataset.
 //!
 //! This is called global fitting with multiple right hand sides,
 //! because the nonlinear parameters are not

src/model/builder/mod.rs

@@ -54,9 +54,9 @@ pub mod error;
 /// **Function Arguments and Output**
 ///
 /// * The first argument of the function must be a reference to a `&DVector` type
-/// that accepts the independent variable (the `$\vec{x}$` values) and the other
-/// parameters must be scalars that are the nonlinear parameters that the basis
-/// function depends on.
+///   that accepts the independent variable (the `$\vec{x}$` values) and the other
+///   parameters must be scalars that are the nonlinear parameters that the basis
+///   function depends on.
 ///
 /// So if we want to model a basis function `$\vec{f_1}(\vec{x},\vec{\alpha})$`
 /// where `$\vec{\alpha}=(\alpha_1,\alpha_2)$` we would write the function in Rust as
@@ -129,14 +129,14 @@ pub mod error;
 /// ** Rules You Must Abide By **
 ///
 /// * Basis functions must be **nonlinear** in the parameters they take. If they aren't, you can always
-/// rewrite the problem so that the linear parameters go in the coefficient vector `$\vec{c}$`. This
-/// means that each partial derivative also depend on all the parameters that the basis function depends
-/// on.
+///   rewrite the problem so that the linear parameters go in the coefficient vector `$\vec{c}$`. This
+///   means that each partial derivative also depend on all the parameters that the basis function depends
+///   on.
 ///
 /// * Derivatives must take the same parameter arguments *and in the same order* as the original
-/// basis function. This means if basis function `$\vec{f}_j$` is given as `$\vec{f}_j(\vec{x},a,b)$`,
-/// then the derivatives must also be given with the parameters `$a,b$` in the same order, i.e.
-/// `$\partial/\partial a \vec{f}_j(\vec{x},a,b)$`, `$\partial/\partial b \vec{f}_j(\vec{x},a,b)$`.
+///   basis function. This means if basis function `$\vec{f}_j$` is given as `$\vec{f}_j(\vec{x},a,b)$`,
+///   then the derivatives must also be given with the parameters `$a,b$` in the same order, i.e.
+///   `$\partial/\partial a \vec{f}_j(\vec{x},a,b)$`, `$\partial/\partial b \vec{f}_j(\vec{x},a,b)$`.
 ///
 /// **Rules Enforced at Compile Time**
 ///
@@ -333,8 +333,8 @@ where
     /// * The list of parameters must only contain unique names
     /// * The list of parameter names must not be empty
     /// * Parameter names must not contain a comma. This is a precaution because
-    /// `&["alpha,beta"]` most likely indicates a typo for `&["alpha","beta"]`. Any other form
-    /// of punctuation is allowed.
+    ///   `&["alpha,beta"]` most likely indicates a typo for `&["alpha","beta"]`. Any other form
+    ///   of punctuation is allowed.
     pub fn new<StrCollection>(parameter_names: StrCollection) -> Self
     where
         StrCollection: IntoIterator,

src/model/builder/modelfunction_builder/mod.rs

@@ -16,7 +16,7 @@ use crate::model::model_basis_function::ModelBasisFunction;
 /// * the model parameters are unique and non-empty
 /// * the function parameters are unique, non-empty and a subset of the model params
 /// * a derivative is provided for each parameter that the function depends on
-/// (all other derivatives are zero, because the function does not depends on other params)
+///   (all other derivatives are zero, because the function does not depend on other params)
 ///
 #[doc(hidden)]
 pub struct ModelBasisFunctionBuilder<ScalarType>
@@ -38,13 +38,17 @@ where
     /// begin constructing a modelfunction for a specific model. The modelfunction must take
     /// a subset of the model parameters. This is the first step in creating a function, because
     /// the modelfunction must have partial derivatives specified for each parameter it takes.
+    ///
     /// # Arguments
+    ///
     /// * `model_parameters`: the model parameters of the model to which this function belongs. This is important
-    /// so the builder understands how the parameters of the function relate to the parameters of the model.
+    ///    so the builder understands how the parameters of the function relate to the parameters of the model.
     /// * `function_parameters`: the parameters that the function takes. Those must be in the order
-    /// of the parameter vector. The paramters must not be empty, nor may they contain duplicates
+    ///    of the parameter vector. The paramters must not be empty, nor may they contain duplicates
     /// * `function`: the actual function.
+    ///
     /// # Result
+    ///
     /// A model builder that can be used to add derivatives.
     pub fn new<FuncType, StrCollection, ArgList>(
         model_parameters: Vec<String>,
@@ -88,9 +92,9 @@ where
     /// Add a derivative for the function with respect to the given parameter.
     /// # Arguments
     /// * `parameter`: the parameter with respect to which the derivative is taken.
-    /// The parameter must be inside the set of model parameters. Furthermore the
+    ///    The parameter must be inside the set of model parameters. Furthermore the
     /// * `derivative`: the partial derivative of the function with which the
-    /// builder was created.
+    ///    builder was created.
     pub fn partial_deriv<FuncType, ArgList>(mut self, parameter: &str, derivative: FuncType) -> Self
     where
         FuncType: BasisFunction<ScalarType, ArgList> + 'static,

src/model/detail.rs

@@ -9,7 +9,9 @@ use crate::model::builder::error::ModelBuildError;
 /// * the set of parameters is not empty
 /// * the set of parameters contains only unique elements
 /// * any of the parameter names contains a comma. This indicates most likely a typo when giving the parameter list
+///
 /// # Returns
+///
 /// Ok if the conditions hold, otherwise an error variant.
 pub fn check_parameter_names<StrType>(param_names: &[StrType]) -> Result<(), ModelBuildError>
 where
@@ -80,11 +82,13 @@ where
 /// of model parameters and dispatch them to our model function
 /// # Arguments
 /// * `model_parameters`: the parameters that the complete model that this function belongs to
-/// depends on
+///    depends on
 /// * `function_parameters`: the parameters (in right to left order) that the basisfunction depends
-/// on. Must be a subset of the model parameters.
+///    on. Must be a subset of the model parameters.
 /// * `function` a basis function that depends on a number of parameters
+///
 /// # Result
+///
 /// Say our model depends on parameters `$\vec{p}=(\alpha,\beta,\gamma)$` and the `function` argument
 /// is a basis function `$f(\vec{x},\gamma,\beta)$`. Then calling `create_wrapped_basis_function(&["alpha","beta","gamma"],&["gamma","alpha"],f)`
 /// creates a wrapped function `$\tilde{f}(\vec{x},\vec{p})$` which can be called with `$\tilde{f}(\vec{x},\vec{p})=f(\vec{x},\gamma,\beta$`.

src/model/mod.rs

@@ -312,11 +312,11 @@ where
     /// # Arguments
     ///
     /// * `derivative_index`: The index of the nonlinear parameter with respect to which
-    /// partial derivative should be evaluated. We use _zero based indexing_
-    /// here! Put in more simple terms, say your model has three nonlinear parameters
-    /// `a,b,c`, so your vector of nonlinear parameters is `$\vec{\alpha} = (a,b,c)$`.
-    /// Then index 0 requests `$\partial/\partial_a$`, index 1 requests `$\partial/\partial_b$`
-    /// and index 2 requests `$\partial/\partial_c$`.
+    ///    partial derivative should be evaluated. We use _zero based indexing_
+    ///    here! Put in more simple terms, say your model has three nonlinear parameters
+    ///    `a,b,c`, so your vector of nonlinear parameters is `$\vec{\alpha} = (a,b,c)$`.
+    ///    Then index 0 requests `$\partial/\partial_a$`, index 1 requests `$\partial/\partial_b$`
+    ///    and index 2 requests `$\partial/\partial_c$`.
     ///
     /// # Result
     ///

src/statistics/mod.rs

@@ -224,11 +224,11 @@ where
     /// # Arguments
     ///
     /// * `probability` the confidence level of the confidence interval, expressed
-    /// as a probability value between 0 and 1. Note that it can't be 0 or 1, but
-    /// anything in between. Since least squares fitting assumes Gaussian error
-    /// distributions, we can use the quantiles of the normal distribution to
-    /// relate this to often used "number of sigmas". For example the probability
-    /// `$68.3 \% = 0.683$` corresponds to (approximately) `$1\sigma$`.
+    ///    as a probability value between 0 and 1. Note that it can't be 0 or 1, but
+    ///    anything in between. Since least squares fitting assumes Gaussian error
+    ///    distributions, we can use the quantiles of the normal distribution to
+    ///    relate this to often used "number of sigmas". For example the probability
+    ///    `$68.3 \% = 0.683$` corresponds to (approximately) `$1\sigma$`.
     ///
     /// # Returns
     ///