Refactor impls and spike for tensor builder

src/comp_graph/mod.rs

@@ -320,7 +320,7 @@ pub enum ComputationGraphError {
 mod test {
     use num::traits::Pow;
 
-    use crate::{engine::{basic::Basic, tensor::{generic::EngineTensorGeneric, Array}}, helper::Shape};
+    use crate::{engine_impl::{basic::Basic, tensor::array::Array}, helper::Shape};
 
     use super::*;
 

src/engine/mod.rs

@@ -1,9 +1,5 @@
 pub mod tensor;
 pub mod unit;
-pub mod basic;
-
-mod shared;
-mod util;
 
 use crate::helper::{Shape, PositionError};
 use self::{tensor::{factory::EngineTensorFactory, EngineTensor}, unit::UnitCompatible};

src/engine/tensor/builder.rs

@@ -1,16 +1,16 @@
 use std::ops::RangeBounds;
 
-use crate::engine::unit::UnitCompatible;
+use crate::{engine::unit::UnitCompatible, helper::Shape};
 
 use super::EngineTensor;
 
-trait EngineTensorBuilder {
+pub trait EngineTensorBuilder {
     type Unit: UnitCompatible;
     type Tensor: EngineTensor;
 
-    fn splice<R: RangeBounds<usize>, I: IntoIterator<Item = Self::Unit>>(range: R, replace_with: I);
+    fn new(shape: Shape) -> Self;
 
-    fn construct() -> Box<dyn EngineTensor<Unit = Self::Unit>>;
-}
+    fn splice<R: RangeBounds<usize>, I: IntoIterator<Item = Self::Unit>>(&mut self, range: R, replace_with: I);
 
-struct ArrayBuilder;
+    fn construct(self) -> Self::Tensor;
+}

src/engine/tensor/factory.rs

@@ -1,51 +1,14 @@
-use std::sync::Arc;
-use crate::helper::{Shape, Stride};
-use super::{allowed_unit::{AllowedArray, AllowedQuant}, generic::EngineTensorGeneric, Array, EngineTensor, Quant};
+use crate::helper::Shape;
+use super::EngineTensor;
 
-pub trait EngineTensorFactory: EngineTensor + EngineTensorGeneric
-where Self: Sized 
+pub trait EngineTensorFactory: EngineTensor
+where Self: Sized + 'static
 {
     fn from_iter(iter: impl Iterator<Item = Self::Unit>, shape: Shape) -> Self;
     fn from_slice(data: &[Self::Unit], shape: Shape) -> Self;
     //fn builder() -> impl EngineTensorBuilder<Unit = Self::Unit>;
-}
 
-impl<T: AllowedArray> EngineTensorFactory for Array<T> {
-    fn from_iter(iter: impl Iterator<Item = T>, shape: Shape) -> Self {
-        Array {
-            stride: Stride::default_from_shape(&shape), 
-            shape, 
-            data: iter.collect(),
-            offset: 0,
-        }
-    }
-
-    fn from_slice(data: &[T], shape: Shape) -> Self {
-        Array {
-            stride: Stride::default_from_shape(&shape), 
-            shape, 
-            data: Arc::from(data),
-            offset: 0,
-        }
-    }
-}
-
-impl<T: AllowedQuant> EngineTensorFactory for Quant<T> {
-    fn from_iter(iter: impl Iterator<Item = T>, shape: Shape) -> Self {
-        Quant {
-            stride: Stride::default_from_shape(&shape), 
-            shape, 
-            data: iter.collect(),
-            offset: 0,
-        }
-    }
-
-    fn from_slice(data: &[T], shape: Shape) -> Self {
-        Quant {
-            stride: Stride::default_from_shape(&shape), 
-            shape, 
-            data: Arc::from(data),
-            offset: 0,
-        }
+    fn generic(self) -> Box<dyn EngineTensor<Unit = Self::Unit>> {
+        Box::from(self)
     }
 }