Added Latex support for doc

Added a html header files, an added metadata line in Cargo.toml and some formatting changes in the doc to have Latex formulas in docs.rs. It works locally, should work online

src/fec.rs

@@ -17,7 +17,7 @@ pub struct Shard<F: PrimeField> {
     ///
     /// this effectively allows support for _recoding_.
     ///
-    /// If we denote the $k$ source shards by $(s_i)_{0 \le i \lt k}$, the linear combination by $k$
+    /// If we denote the $k$ source shards by $(s\_i)\_\{0 \le i \lt k\}$, the linear combination by $k$
     /// coefficients $(\alpha_i)_{0 \le i \lt k}$ and $s$ the shard itself, then
     ///
     /// $$ s = \sum\limits_{i = 0}^{k - 1} \alpha_i s_i$$
@@ -31,6 +31,14 @@ pub struct Shard<F: PrimeField> {
 }
 
 impl<F: PrimeField> Shard<F> {
+    fn dual_combination(this: &Vec<F>, alpha: F, other: &Vec<F>, beta: F) -> Vec<F> {
+        this
+            .iter()
+            .zip(other.iter())
+            .map(|(s, o)| s.mul(alpha) + o.mul(beta))
+            .collect()
+    }
+ 
     /// compute the linear combination between two [`Shard`]s
     ///
     /// if we denote the [`Shard`] itself and the other [`Shard`] by $s$ and $o$ respectively, the
@@ -45,19 +53,9 @@ impl<F: PrimeField> Shard<F> {
 
         Shard {
             k: self.k,
-            linear_combination: self
-                .linear_combination
-                .iter()
-                .zip(other.linear_combination.iter())
-                .map(|(l, r)| l.mul(alpha) + r.mul(beta))
-                .collect(),
+            linear_combination: Self::dual_combination(&self.linear_combination, alpha, &other.linear_combination, beta),
             hash: self.hash.clone(),
-            data: self
-                .data
-                .iter()
-                .zip(other.data.iter())
-                .map(|(es, eo)| es.mul(alpha) + eo.mul(beta))
-                .collect(),
+            data: Self::dual_combination(&self.data, alpha, &other.data, beta),
             size: self.size,
         }
     }
@@ -72,8 +70,8 @@ impl<F: PrimeField> Shard<F> {
 /// > returns [`None`] if the number of shards is not the same as the number of
 /// > coefficients or if no shards are provided.
 ///
-/// if the shards are the $(s_i)_{1 \le i \le n}$ and the coefficients the
-/// $(\alpha_i)_{0 \le i \le n}$, then the output will be
+/// if the shards are the $(s \_i)\_\{1 \le i \le n\}$ and the coefficients the
+/// $(\alpha\_i)\_\{0 \le i \le n\}$, then the output will be
 ///
 /// $$ \sum\limits_{i = 1}^{n} \alpha_i s_i$$
 pub fn recode_with_coeffs<F: PrimeField>(shards: &[Shard<F>], coeffs: &[F]) -> Option<Shard<F>> {
@@ -104,10 +102,7 @@ pub fn recode_with_coeffs<F: PrimeField>(shards: &[Shard<F>], coeffs: &[F]) -> O
 /// > **Note**
 /// >
 /// > this is a wrapper around [`recode_with_coeffs`].
-pub fn recode_random<F: PrimeField>(
-    shards: &[Shard<F>],
-    rng: &mut impl RngCore,
-) -> Result<Option<Shard<F>>, KomodoError> {
+pub fn recode_random<F: PrimeField>(shards: &[Shard<F>], rng: &mut impl RngCore) -> Result<Option<Shard<F>>, KomodoError> {
     for (i, (s1, s2)) in shards.iter().zip(shards.iter().skip(1)).enumerate() {
         if s1.k != s2.k {
             return Err(KomodoError::IncompatibleShards(format!(
@@ -144,10 +139,7 @@ pub fn recode_random<F: PrimeField>(
 /// matrix. (see [`algebra::split_data_into_field_elements`])
 ///
 /// This is the inverse of [`decode`].
-pub fn encode<F: PrimeField>(
-    data: &[u8],
-    encoding_mat: &Matrix<F>,
-) -> Result<Vec<Shard<F>>, KomodoError> {
+pub fn encode<F: PrimeField>(data: &[u8], encoding_mat: &Matrix<F>) -> Result<Vec<Shard<F>>, KomodoError> {
     let hash = Sha256::hash(data).to_vec();
 
     let k = encoding_mat.height;