refactor shard to use a simple vector

this MR uses a simpler Vec of E::ScalarField to represent a linear combination.

the rest of the crate has been fixed accordingly.

the goal is to let Arkworks do as much work as possible, fixing part of #2 (closed).

• one_more removed from field::split_data_into_field_elements in 5531b31a
• one_less removed from field::merge_elements_into_bytes in 5761b784

examples

let's say we have at most k = 3 source shards, called s_0, s_1 and s_2 respectively. this first means that all linear combinations will be at most of length 3.

if a new shard s is a linear combination of the source shards, e.g. s = \alpha s_0 + \beta s_1 + \gamma s_2, where \alpha, \beta and \gamma are scalar elements of an elliptic curve, then the linear combination in the code will be

vec![alpha, beta, gamma]

Note
the right of the vector can be truncated to remove zero elements that are not part of the linear combination and don't add any extra useful information.
the left stays mandatory.

e.g. we create two times a linear combination with a single one set to 1 and the rest to 0 with the following snippet

let mut linear_combination = Vec::new();
linear_combination.resize(i + 1, E::ScalarField::zero());
linear_combination[i] = E::ScalarField::one();

src/fec.rs

@@ -40,13 +40,6 @@ impl<E: Pairing> Shard<E> {
             return self.clone();
         }
 
-        let elements = self
-            .bytes
-            .iter()
-            .zip(other.bytes.iter())
-            .map(|(es, eo)| es.mul(alpha).add(eo.mul(beta)))
-            .collect::<Vec<_>>();
-
         let mut linear_combination = Vec::new();
         linear_combination.resize(
             max(
@@ -55,7 +48,6 @@ impl<E: Pairing> Shard<E> {
             ),
             E::ScalarField::zero(),
         );
-
         for (i, l) in self.linear_combination.iter().enumerate() {
             linear_combination[i] = linear_combination[i] + l.mul(alpha);
         }
@@ -67,7 +59,12 @@ impl<E: Pairing> Shard<E> {
             k: self.k,
             linear_combination,
             hash: self.hash.clone(),
-            bytes: elements,
+            bytes: self
+                .bytes
+                .iter()
+                .zip(other.bytes.iter())
+                .map(|(es, eo)| es.mul(alpha).add(eo.mul(beta)))
+                .collect::<Vec<_>>(),
             size: self.size,
         }
     }