C-WORD-ORDER

Author: ABouttefeux

CHANGELOG.md

@@ -11,4 +11,5 @@ First release
 - correct doctest Su3Adjoint::as_mut_vector
 - migrate to rust 2021
 - use readme in librairies root documentation
-- rename lots of gettet to match C-GETTER convention
+- rename lots of gettet to match C-GETTER convention
+- rename some structure for C-WORD-ORDER

README.md

@@ -83,7 +83,7 @@ implement the trait [`LatticeState`](https://abouttefeux.github.io/lattice-qcd-r
 
 If you want to use your own state with the [hybride Monte Carlo](https://abouttefeux.github.io/lattice-qcd-rs/lattice_qcd_rs/simulation/monte_carlo/hybride_monte_carlo/struct.HybridMonteCarloDiagnostic.html)
 you will have to implement
-[`LatticeStateWithEField`](https://abouttefeux.github.io/lattice-qcd-rs/lattice_qcd_rs/simulation/state/trait.LatticeStateWithEField.html) for [`LatticeStateWithEFieldSyncDefault<YourState>`](https://abouttefeux.github.io/lattice-qcd-rs/lattice_qcd_rs/simulation/state/struct.LatticeStateWithEFieldSyncDefault.html)
+[`LatticeStateWithEField`](https://abouttefeux.github.io/lattice-qcd-rs/lattice_qcd_rs/simulation/state/trait.LatticeStateWithEField.html) for [`LatticeStateEFSyncDefault<YourState>`](https://abouttefeux.github.io/lattice-qcd-rs/lattice_qcd_rs/simulation/state/struct.LatticeStateEFSyncDefault.html)
 
 #### I want to use my own Monte Carlo algorithm.
 

benches/bench.rs

@@ -13,26 +13,24 @@ fn bench_simulation_creation_deterministe(
     rng: &mut rand::rngs::ThreadRng,
     d: &impl rand_distr::Distribution<Real>,
 ) {
-    let _simulation =
-        LatticeStateWithEFieldSyncDefault::<LatticeStateDefault<4>, 4>::new_deterministe(
-            1_f64, 1_f64, size, rng, d,
-        )
-        .unwrap();
+    let _simulation = LatticeStateEFSyncDefault::<LatticeStateDefault<4>, 4>::new_deterministe(
+        1_f64, 1_f64, size, rng, d,
+    )
+    .unwrap();
 }
 
 fn bench_simulation_creation_threaded<D>(size: usize, d: &D, number_of_thread: usize)
 where
     D: rand_distr::Distribution<Real> + Sync,
 {
-    let _simulation =
-        LatticeStateWithEFieldSyncDefault::<LatticeStateDefault<4>, 4>::new_random_threaded(
-            1_f64,
-            1_f64,
-            size,
-            d,
-            number_of_thread,
-        )
-        .unwrap();
+    let _simulation = LatticeStateEFSyncDefault::<LatticeStateDefault<4>, 4>::new_random_threaded(
+        1_f64,
+        1_f64,
+        size,
+        d,
+        number_of_thread,
+    )
+    .unwrap();
 }
 
 fn matrix_exp_old(rng: &mut rand::rngs::ThreadRng, d: &impl rand_distr::Distribution<Real>) {
@@ -87,17 +85,15 @@ fn create_hash_map(
 }
 
 fn simulate_euler(
-    simulation: &mut LatticeStateWithEFieldSyncDefault<LatticeStateDefault<4>, 4>,
+    simulation: &mut LatticeStateEFSyncDefault<LatticeStateDefault<4>, 4>,
     number_of_thread: usize,
 ) {
     *simulation = simulation
         .simulate_sync(&SymplecticEuler::new(number_of_thread), 0.00001)
         .unwrap();
 }
 
-fn simulate_euler_rayon(
-    simulation: &mut LatticeStateWithEFieldSyncDefault<LatticeStateDefault<4>, 4>,
-) {
+fn simulate_euler_rayon(simulation: &mut LatticeStateEFSyncDefault<LatticeStateDefault<4>, 4>) {
     *simulation = simulation
         .simulate_sync(&SymplecticEulerRayon::new(), 0.00001)
         .unwrap();
@@ -149,21 +145,19 @@ fn criterion_benchmark(c: &mut Criterion) {
     groupe_sim.sample_size(10);
     let thread_count: [usize; 5] = [1, 2, 4, 6, 8];
     for n in thread_count.iter() {
-        let mut sim =
-            LatticeStateWithEFieldSyncDefault::<LatticeStateDefault<4>, 4>::new_random_threaded(
-                1_f64, 1_f64, 5, &d, 4,
-            )
-            .unwrap();
+        let mut sim = LatticeStateEFSyncDefault::<LatticeStateDefault<4>, 4>::new_random_threaded(
+            1_f64, 1_f64, 5, &d, 4,
+        )
+        .unwrap();
         groupe_sim.bench_with_input(BenchmarkId::new("thread", n), n, |b, i| {
             b.iter(|| simulate_euler(&mut sim, *i))
         });
     }
 
-    let mut sim =
-        LatticeStateWithEFieldSyncDefault::<LatticeStateDefault<4>, 4>::new_random_threaded(
-            1_f64, 1_f64, 5, &d, 4,
-        )
-        .unwrap();
+    let mut sim = LatticeStateEFSyncDefault::<LatticeStateDefault<4>, 4>::new_random_threaded(
+        1_f64, 1_f64, 5, &d, 4,
+    )
+    .unwrap();
     groupe_sim.bench_function("simulate(20) rayon", |b| {
         b.iter(|| simulate_euler_rayon(&mut sim))
     });

procedural_macro/src/lib.rs

@@ -42,7 +42,7 @@ use quote::quote;
 const MAX_DIM: usize = 127;
 
 /// Implement [`DirectionList`](https://abouttefeux.github.io/lattice-qcd-rs/lattice_qcd_rs/lattice/trait.DirectionList.html)
-/// for [`Direction`](https://abouttefeux.github.io/lattice-qcd-rs/lattice_qcd_rs/lattice/struct.Direction.html) of `1` to `127` the value of [`MAX_DIM`].
+/// for [`Direction`](https://abouttefeux.github.io/lattice-qcd-rs/lattice_qcd_rs/lattice/struct.Direction.html) of `1` to `127` the value of `MAX_DIM`.
 ///
 /// Using const generics might render this unecessary. Waiting for stabilisation of feature(generic_const_exprs).
 #[proc_macro]

src/error.rs

@@ -32,7 +32,8 @@ pub enum ImplementationError {
     Unreachable,
     /// An option contained an unexpected None value.
     ///
-    /// Used when needing to retrun a dyn Error but [`std::option::NoneError`] does not implement [`Error`]
+    /// Used when needing to retrun a dyn Error but `std::option::NoneError` does not implement [`Error`]
+    // TODO NoneError
     OptionWithUnexpectedNone,
 }
 
@@ -130,7 +131,7 @@ impl Error for StateInitializationError {
     }
 }
 
-/// Error while initialising a state
+/// Error while initialising a state using multiple thread or threded function.
 #[non_exhaustive]
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub enum ThreadedStateInitializationError {

src/field.rs

@@ -99,6 +99,7 @@ impl Su3Adjoint {
     /// let su3 = Su3Adjoint::new_from_array([1_f64, 0_f64, 0_f64, 0_f64, 0_f64, 0_f64, 0_f64, 0_f64]);
     /// assert_eq!(su3.to_matrix(), *lattice_qcd_rs::su3::GENERATORS[0]);
     /// ```
+    // TODO self non consomé ?? passé en &self ? TODO bench
     pub fn to_matrix(self) -> Matrix3<na::Complex<Real>> {
         self.data
             .iter()
@@ -167,7 +168,6 @@ impl Su3Adjoint {
     /// It is used for [`su3::su3_exp_i`].
     /// # Example
     /// ```
-    /// # extern crate nalgebra;
     /// # use lattice_qcd_rs::field::Su3Adjoint;
     /// let su3 = Su3Adjoint::from([1_f64; 8]);
     /// let m = su3.to_matrix();
@@ -185,7 +185,6 @@ impl Su3Adjoint {
     /// Used for [`su3::su3_exp_i`]
     /// # Example
     /// ```
-    /// # extern crate nalgebra;
     /// # use lattice_qcd_rs::field::Su3Adjoint;
     /// let su3 = Su3Adjoint::from([1_f64; 8]);
     /// let m = su3.to_matrix();
@@ -557,14 +556,15 @@ impl From<[Real; 8]> for Su3Adjoint {
 }
 
 /// Represents the link matrices
+// TODO more doc
 #[derive(Debug, PartialEq, Clone)]
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 pub struct LinkMatrix {
     data: Vec<Matrix3<na::Complex<Real>>>,
 }
 
 impl LinkMatrix {
-    /// Creat a new link matrix field
+    /// Creat a new link matrix field from preexisting data.
     pub const fn new(data: Vec<Matrix3<na::Complex<Real>>>) -> Self {
         Self { data }
     }
@@ -579,17 +579,17 @@ impl LinkMatrix {
         &mut self.data
     }
 
-    /// Get the link_matrix as a Vec
+    /// Get the link_matrix as a [`Vec`].
     pub const fn as_vec(&self) -> &Vec<Matrix3<na::Complex<Real>>> {
         self.data()
     }
 
-    /// Get the link_matrix as a Vec
+    /// Get the link_matrix as a mutable [`Vec`].
     pub fn as_vec_mut(&mut self) -> &mut Vec<Matrix3<na::Complex<Real>>> {
         self.data_mut()
     }
 
-    /// Get the link_matrix as a Vec
+    /// Get the link_matrix as a slice.
     pub fn as_slice(&self) -> &[Matrix3<na::Complex<Real>>] {
         self.data()
     }
@@ -600,7 +600,8 @@ impl LinkMatrix {
     }
 
     /// Single threaded generation with a given random number generator.
-    /// useful to reproduce a set of data but slower than [`LinkMatrix::new_random_threaded`].
+    /// useful to produce a deterministic set of data but slower than
+    /// [`LinkMatrix::new_random_threaded`].
     /// # Example
     /// ```
     /// use lattice_qcd_rs::{field::LinkMatrix, lattice::LatticeCyclique};
@@ -635,7 +636,8 @@ impl LinkMatrix {
     }
 
     /// Multi threaded generation of random data. Due to the non deterministic way threads
-    /// operate a set cannot be reduced easily, In that case use [`LinkMatrix::new_random_threaded`].
+    /// operate a set cannot be reduced easily. If you want deterministic
+    /// generation you can use [`LinkMatrix::new_random_threaded`].
     ///
     /// # Example
     /// ```
@@ -1199,8 +1201,8 @@ impl<const D: usize> EField<D> {
     /// use lattice_qcd_rs::error::ImplementationError;
     /// use lattice_qcd_rs::integrator::SymplecticEulerRayon;
     /// use lattice_qcd_rs::simulation::{
-    ///     LatticeState, LatticeStateDefault, LatticeStateWithEField,
-    ///     LatticeStateWithEFieldSyncDefault, SimulationStateSynchrone,
+    ///     LatticeState, LatticeStateDefault, LatticeStateEFSyncDefault, LatticeStateWithEField,
+    ///     SimulationStateSynchrone,
     /// };
     /// use rand::SeedableRng;
     ///
@@ -1210,7 +1212,7 @@ impl<const D: usize> EField<D> {
     /// let mut rng = rand::rngs::StdRng::seed_from_u64(0); // change with your seed
     /// let distribution =
     ///     rand::distributions::Uniform::from(-std::f64::consts::PI..std::f64::consts::PI);
-    /// let mut state = LatticeStateWithEFieldSyncDefault::new_random_e_state(
+    /// let mut state = LatticeStateEFSyncDefault::new_random_e_state(
     ///     LatticeStateDefault::<3>::new_deterministe(1_f64, 6_f64, 4, &mut rng).unwrap(),
     ///     &mut rng,
     /// ); // <- here internally when choosing radomly the EField it is projected.

src/integrator/mod.rs

@@ -17,12 +17,12 @@
 //! # fn main() -> Result<(), Box<dyn Error>> {
 //! use lattice_qcd_rs::integrator::{SymplecticEuler, SymplecticIntegrator};
 //! use lattice_qcd_rs::simulation::{
-//!     LatticeStateDefault, LatticeStateWithEField, LatticeStateWithEFieldSyncDefault,
+//!     LatticeStateDefault, LatticeStateEFSyncDefault, LatticeStateWithEField,
 //! };
 //! use rand::SeedableRng;
 //!
 //! let mut rng = rand::rngs::StdRng::seed_from_u64(0); // change with your seed
-//! let state1 = LatticeStateWithEFieldSyncDefault::new_random_e_state(
+//! let state1 = LatticeStateEFSyncDefault::new_random_e_state(
 //!     LatticeStateDefault::<3>::new_deterministe(100_f64, 1_f64, 4, &mut rng)?,
 //!     &mut rng,
 //! );
@@ -39,12 +39,12 @@
 //! # fn main() -> Result<(), Box<dyn Error>> {
 //! # use lattice_qcd_rs::integrator::{SymplecticEuler, SymplecticIntegrator};
 //! # use lattice_qcd_rs::simulation::{
-//! #     LatticeStateDefault, LatticeStateWithEField, LatticeStateWithEFieldSyncDefault,
+//! #     LatticeStateDefault, LatticeStateWithEField, LatticeStateEFSyncDefault,
 //! # };
 //! # use rand::SeedableRng;
 //! #
 //! # let mut rng = rand::rngs::StdRng::seed_from_u64(0); // change with your seed
-//! # let state1 = LatticeStateWithEFieldSyncDefault::new_random_e_state(
+//! # let state1 = LatticeStateEFSyncDefault::new_random_e_state(
 //! #     LatticeStateDefault::<3>::new_deterministe(100_f64, 1_f64, 4, &mut rng)?,
 //! #     &mut rng,
 //! # );
@@ -121,12 +121,12 @@ where
     /// # fn main() -> Result<(), Box<dyn Error>> {
     /// use lattice_qcd_rs::integrator::{SymplecticEulerRayon, SymplecticIntegrator};
     /// use lattice_qcd_rs::simulation::{
-    ///     LatticeStateDefault, LatticeStateWithEField, LatticeStateWithEFieldSyncDefault,
+    ///     LatticeStateDefault, LatticeStateEFSyncDefault, LatticeStateWithEField,
     /// };
     /// use rand::SeedableRng;
     ///
     /// let mut rng = rand::rngs::StdRng::seed_from_u64(0); // change with your seed
-    /// let state = LatticeStateWithEFieldSyncDefault::new_random_e_state(
+    /// let state = LatticeStateEFSyncDefault::new_random_e_state(
     ///     LatticeStateDefault::<3>::new_deterministe(1_f64, 2_f64, 4, &mut rng)?,
     ///     &mut rng,
     /// );
@@ -181,12 +181,12 @@ where
     /// # fn main() -> Result<(), Box<dyn Error>> {
     /// use lattice_qcd_rs::integrator::{SymplecticEulerRayon, SymplecticIntegrator};
     /// use lattice_qcd_rs::simulation::{
-    ///     LatticeStateDefault, LatticeStateWithEField, LatticeStateWithEFieldSyncDefault,
+    ///     LatticeStateDefault, LatticeStateEFSyncDefault, LatticeStateWithEField,
     /// };
     /// use rand::SeedableRng;
     ///
     /// let mut rng = rand::rngs::StdRng::seed_from_u64(0); // change with your seed
-    /// let mut state = LatticeStateWithEFieldSyncDefault::new_random_e_state(
+    /// let mut state = LatticeStateEFSyncDefault::new_random_e_state(
     ///     LatticeStateDefault::<3>::new_deterministe(1_f64, 2_f64, 4, &mut rng)?,
     ///     &mut rng,
     /// );

src/integrator/symplectic_euler_rayon.rs

@@ -30,12 +30,12 @@ use super::{
 /// # fn main() -> Result<(), Box<dyn Error>> {
 /// use lattice_qcd_rs::integrator::{SymplecticEulerRayon, SymplecticIntegrator};
 /// use lattice_qcd_rs::simulation::{
-///     LatticeStateDefault, LatticeStateWithEField, LatticeStateWithEFieldSyncDefault,
+///     LatticeStateDefault, LatticeStateEFSyncDefault, LatticeStateWithEField,
 /// };
 /// use rand::SeedableRng;
 ///
 /// let mut rng = rand::rngs::StdRng::seed_from_u64(0); // change with your seed
-/// let state1 = LatticeStateWithEFieldSyncDefault::new_random_e_state(
+/// let state1 = LatticeStateEFSyncDefault::new_random_e_state(
 ///     LatticeStateDefault::<3>::new_deterministe(1_f64, 2_f64, 4, &mut rng)?,
 ///     &mut rng,
 /// );

src/lattice.rs

@@ -118,14 +118,14 @@ impl<const D: usize> LatticeCyclique<D> {
 
     /// Transform a [`LatticeLink`] into a [`LatticeLinkCanonical`].
     ///
-    /// See [`LatticeCyclique::get_link_canonical`] and [`LatticeLinkCanonical`].
+    /// See [`LatticeCyclique::link_canonical`] and [`LatticeLinkCanonical`].
     pub fn into_canonical(&self, l: LatticeLink<D>) -> LatticeLinkCanonical<D> {
         self.link_canonical(*l.pos(), *l.dir())
     }
 
     /// Get the number of points in a single direction.
     ///
-    /// use [`LatticeCyclique::get_number_of_points`] for the total number of points.
+    /// use [`LatticeCyclique::number_of_points`] for the total number of points.
     /// Not to confuse with [`LatticeCyclique::dim_st`] which is the dimension of space-time.
     pub const fn dim(&self) -> usize {
         self.dim
@@ -803,7 +803,7 @@ pub struct LatticeLinkCanonical<const D: usize> {
 impl<const D: usize> LatticeLinkCanonical<D> {
     /// Try create a LatticeLinkCanonical. If the dir is negative it fails.
     ///
-    /// To guaranty creating an element see [LatticeCyclique::get_link_canonical].
+    /// To guaranty creating an element see [LatticeCyclique::link_canonical].
     /// The creation of an element this ways does not guaranties that the element is inside a lattice.
     /// # Example
     /// ```
@@ -980,7 +980,7 @@ impl<const D: usize> Direction<D> {
     }
 
     /// List all directions.
-    /// This is very slow use [`DirectionList::get_all_directions`] instead
+    /// This is very slow use [`DirectionList::directions`] instead
     pub fn directions_vec() -> Vec<Self> {
         let mut x = Vec::with_capacity(2 * D);
         for i in 0..D {

src/prelude.rs

@@ -10,8 +10,8 @@ pub use super::{
             HybridMonteCarloDiagnostic, McWrapper, MetropolisHastingsDeltaDiagnostic,
             MetropolisHastingsSweep, MonteCarlo, MonteCarloDefault,
         },
-        LatticeState, LatticeStateDefault, LatticeStateNew, LatticeStateWithEField,
-        LatticeStateWithEFieldNew, LatticeStateWithEFieldSyncDefault, SimulationStateLeap,
+        LatticeState, LatticeStateDefault, LatticeStateEFSyncDefault, LatticeStateNew,
+        LatticeStateWithEField, LatticeStateWithEFieldNew, SimulationStateLeap,
         SimulationStateLeapFrog, SimulationStateSynchrone,
     },
     CMatrix3, Complex, ComplexField, Real,