chore: add documentation

src/algorithm/neighbour/fastpair.rs

@@ -54,7 +54,7 @@ pub struct FastPair<'a, T: RealNumber + FloatNumber, M: Array2<T>> {
 impl<'a, T: RealNumber + FloatNumber, M: Array2<T>> FastPair<'a, T, M> {
     ///
     /// Constructor
-    /// Instantiate and inizialise the algorithm
+    /// Instantiate and initialize the algorithm
     ///
     pub fn new(m: &'a M) -> Result<Self, Failed> {
         if m.shape().0 < 3 {

src/linalg/basic/arrays.rs

@@ -1003,7 +1003,7 @@ pub trait Array1<T: Debug + Display + Copy + Sized>: MutArrayView1<T> + Sized +
         result
     }
 
-    ///
+    /// check if two arrays are approximately equal
     fn approximate_eq(&self, other: &Self, error: T) -> bool
     where
         T: Number + RealNumber,

src/optimization/first_order/gradient_descent.rs

@@ -1,5 +1,3 @@
-// TODO: missing documentation
-
 use std::default::Default;
 
 use crate::linalg::basic::arrays::Array1;

src/optimization/first_order/lbfgs.rs

@@ -51,7 +51,6 @@ impl Default for LBFGS {
     }
 }
 
-///
 impl LBFGS {
     ///
     fn two_loops<T: FloatNumber + RealNumber, X: Array1<T>>(&self, state: &mut LBFGSState<T, X>) {

src/optimization/first_order/mod.rs

@@ -1,4 +1,4 @@
-///
+///  
 pub mod gradient_descent;
 ///
 pub mod lbfgs;
@@ -11,9 +11,9 @@ use crate::numbers::floatnum::FloatNumber;
 use crate::optimization::line_search::LineSearchMethod;
 use crate::optimization::{DF, F};
 
-///
+/// First-order optimization is a class of algorithms that use the first derivative of a function to find optimal solutions.
 pub trait FirstOrderOptimizer<T: FloatNumber> {
-    ///
+    /// run first order optimization
     fn optimize<'a, X: Array1<T>, LS: LineSearchMethod<T>>(
         &self,
         f: &F<'_, T, X>,
@@ -23,13 +23,13 @@ pub trait FirstOrderOptimizer<T: FloatNumber> {
     ) -> OptimizerResult<T, X>;
 }
 
-///
+/// Result of optimization
 #[derive(Debug, Clone)]
 pub struct OptimizerResult<T: FloatNumber, X: Array1<T>> {
     ///
     pub x: X,
     ///
     pub f_x: T,
-    ///
+    /// number of iterations
     pub iterations: usize,
 }

src/optimization/line_search.rs

@@ -1,9 +1,7 @@
-// TODO: missing documentation
-
 use crate::optimization::FunctionOrder;
 use num_traits::Float;
 
-///
+/// Line search method is an iterative approach to find a local minimum of a multidimensional nonlinear function using the function's gradients
 pub trait LineSearchMethod<T: Float> {
     ///
     fn search(
@@ -16,7 +14,7 @@ pub trait LineSearchMethod<T: Float> {
     ) -> LineSearchResult<T>;
 }
 
-///
+/// Line search result
 #[derive(Debug, Clone)]
 pub struct LineSearchResult<T: Float> {
     ///

src/optimization/mod.rs

@@ -1,5 +1,3 @@
-// TODO: missing documentation
-
 ///
 pub mod first_order;
 ///