diff --git a/Rust/Cargo.toml b/Rust/Cargo.toml
index 98ce6dbb..b30e2420 100644
--- a/Rust/Cargo.toml
+++ b/Rust/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "rcf"
-version = "3.3.0"
+version = "4.0.0"
 edition = "2021"
 license = "Apache-2.0"
 
@@ -18,11 +18,11 @@ path = "src/example.rs"
 
 
 [dependencies]
-num = "0.4"
-rayon = "1.5"
+num = "0.4.1"
+rayon = "1.7"
 rand = "*" 
-rand_chacha = "0.3.0"
-rand_core = "0.6"
+rand_chacha = "0.3.1"
+rand_core = "0.6.2"
 
 [dev-dependencies]
 parameterized_test = "0.1.0"
diff --git a/Rust/src/common/anomalydescriptor.rs b/Rust/src/common/anomalydescriptor.rs
deleted file mode 100644
index ecafc831..00000000
--- a/Rust/src/common/anomalydescriptor.rs
+++ /dev/null
@@ -1,123 +0,0 @@
-use crate::common::divector::DiVector;
-
-/**
- * This class maintains a simple discounted statistics. Setters are avoided
- * except for discount rate which is useful as initialization from raw scores
- */
-#[repr(C)]
-#[derive(Clone)]
-pub struct AnomalyDescriptor {
-
-    // the current input point; can have missing values
-    pub current_input: Vec<f32>,
-
-    // current timestamp
-    pub current_timestamp: usize,
-
-    // potential missing values in the current input (ideally None)
-    pub missing_values: Option<Vec<i32>>,
-
-    // potentially transformed point used by RCF, can have different dimensions than input
-    pub rcf_point: Option<Vec<f32>>,
-
-    pub score: f32,
-
-    pub internal_timestamp: usize,
-
-    pub threshold: f32,
-
-    pub anomaly_grade: f32,
-
-    pub data_confidence: f32,
-
-    pub forecast_reasonable: bool,
-
-    // present only if grade > 0
-    pub attribution: Option<DiVector>,
-
-    pub expected_rcf_point: Option<Vec<f32>>,
-
-    pub relative_index: Option<i32>,
-
-    // useful for time augmented forests
-    pub expected_timestamp: Option<usize>,
-
-    pub start_of_anomaly: Option<bool>,
-
-    pub in_high_score_region: Option<bool>,
-
-    pub relevant_attribution: Option<Vec<f32>>,
-
-    pub time_attribution: Option<f32>,
-
-    // the values being replaced; may correspond to past
-    pub past_values: Option<Vec<f32>>,
-
-    pub past_timestamp: Option<usize>,
-
-    pub expected_values_list: Option<Vec<Vec<f32>>>,
-
-    pub likelihood_of_values: Option<Vec<f32>>
-
-}
-
-impl AnomalyDescriptor {
-    pub fn new(point: &[f32], timestamp: usize) -> Self {
-        AnomalyDescriptor {
-            current_input: Vec::from(point),
-            current_timestamp: timestamp,
-            missing_values: None,
-            rcf_point: None,
-            score: 0.0,
-            internal_timestamp: 0,
-            threshold: 0.0,
-            anomaly_grade: 0.0,
-            data_confidence: 0.0,
-            forecast_reasonable: false,
-            attribution: None,
-            expected_rcf_point: None,
-            relative_index: None,
-            expected_timestamp: None,
-            start_of_anomaly: None,
-            in_high_score_region: None,
-            relevant_attribution: None,
-            time_attribution: None,
-            past_values: None,
-            past_timestamp: None,
-            expected_values_list: None,
-            likelihood_of_values: None
-        }
-    }
-
-    pub fn new_with_missing_values(point: Vec<f32>, timestamp: usize, missing_values: Vec<i32>) -> Self {
-        assert!(missing_values.len() <= point.len(), "incorrect input");
-        for i in &missing_values {
-            assert!( *i >=0 && (*i as usize) < point.len(), "incorrect input")
-        }
-        AnomalyDescriptor {
-            current_input: point.clone(),
-            current_timestamp: timestamp,
-            missing_values: Some(missing_values.clone()),
-            rcf_point: None,
-            score: 0.0,
-            internal_timestamp: 0,
-            threshold: 0.0,
-            anomaly_grade: 0.0,
-            data_confidence: 0.0,
-            forecast_reasonable: false,
-            attribution: None,
-            expected_rcf_point: None,
-            relative_index: None,
-            expected_timestamp: None,
-            start_of_anomaly: None,
-            in_high_score_region: None,
-            relevant_attribution: None,
-            time_attribution: None,
-            past_values: None,
-            past_timestamp: None,
-            expected_values_list: None,
-            likelihood_of_values: None
-        }
-    }
-}
-
diff --git a/Rust/src/common/cluster.rs b/Rust/src/common/cluster.rs
index 4a433dea..e8463bb1 100644
--- a/Rust/src/common/cluster.rs
+++ b/Rust/src/common/cluster.rs
@@ -1,5 +1,4 @@
 use std::cmp::{max, min};
-use std::f32::NAN;
 use std::ops::{Deref, Index};
 use std::slice;
 use rand::{Rng, SeedableRng};
@@ -42,7 +41,7 @@ pub trait IntermediateCluster<Z, Q, T: ?Sized> {
     // a function that assigns a point indexed by usize from a list of samples to
     // the cluster; note the weight used in the function need not be the entire weight of the
     // sampled point (for example in case of soft assignments)
-    fn add_point(&mut self, index: usize, weight: f32, dist: f64, representative: usize);
+    fn add_point(&mut self, index: usize, weight: f32, dist: f64, representative: usize) -> Result<()>;
     // given a set of previous assignments, recomputes the optimal set of representatives
     // this is the classic optimization step for k-Means; but the analogue exists for every
     // clustering; note that it is possible that recompute does nothing
@@ -56,11 +55,11 @@ pub trait IntermediateCluster<Z, Q, T: ?Sized> {
     // a function that indicates cluster quality
     fn average_radius(&self) -> f64;
     // a function that absorbs another cluster
-    fn absorb<'a>(&mut self, dictionary: &'a [Z], get_point: fn (usize,&'a [Z]) -> &'a T, another: &dyn IntermediateCluster<Z, Q, T>, distance: fn(&T, &T) -> f64);
+    fn absorb<'a>(&mut self, dictionary: &'a [Z], get_point: fn (usize,&'a [Z]) -> &'a T, another: &dyn IntermediateCluster<Z, Q, T>, distance: fn(&T, &T) -> f64) -> Result<()>;
     // a function to return a list of representatives corresponding to pairs (Q,weight)
     fn representatives(&self) -> Vec<(Q, f32)>;
     // a function that helps scale (by multiplication) the cluster weight
-    fn scale_weight(&mut self, factor: f64);
+    fn scale_weight(&mut self, factor: f64) -> Result<()>;
 }
 
 
@@ -102,22 +101,22 @@ pub struct Center {
 }
 
 impl Center {
-    pub fn new(representative: usize, point:&[f32], weight: f32, _params:usize) -> Self {
-        Center {
+    pub fn new(_representative: usize, point:&[f32], weight: f32, _params:usize) -> Result<Self> {
+        Ok(Center {
             representative: Vec::from(point),
             weight: weight as f64,
             points: Vec::new(),
             sum_of_radii: 0.0,
-        }
+        })
     }
 
-    pub fn new_as_vec(representative: usize, point:&Vec<f32>, weight: f32,_params:usize) -> Self {
-        Center {
+    pub fn new_as_vec(_representative: usize, point:&Vec<f32>, weight: f32,_params:usize) -> Result<Self> {
+        Ok(Center {
             representative: point.clone(),
             weight: weight as f64,
             points: Vec::new(),
             sum_of_radii: 0.0,
-        }
+        })
     }
 
     pub fn average_radius(&self) -> f64 {
@@ -217,9 +216,10 @@ impl<Z> IntermediateCluster<Z,Vec<f32>, [f32]> for Center {
         self.weight()
     }
 
-    fn scale_weight(&mut self, factor: f64){
-        assert!(!factor.is_nan() && factor>0.0," has to be positive");
-        self.weight = (self.weight as f64 * factor);
+    fn scale_weight(&mut self, factor: f64) -> Result<()>{
+        check_argument(!factor.is_nan() && factor>0.0," has to be positive")?;
+        self.weight = self.weight as f64 * factor;
+        Ok(())
     }
 
     fn distance_to_point<'a>(&self, _points:&'a [Z],_get_point: fn(usize,&'a [Z]) ->&'a [f32],point: &[f32], distance: fn(&[f32], &[f32]) -> f64) -> (f64,usize) {
@@ -237,10 +237,11 @@ impl<Z> IntermediateCluster<Z,Vec<f32>, [f32]> for Center {
         (tuple.0,0,tuple.1)
     }
 
-    fn add_point(&mut self, index: usize, weight: f32, dist: f64, representative:usize) {
-        assert!(representative==0,"can have only one representative");
-        assert!(!weight.is_nan() && weight >= 0.0f32, "non-negative weight");
+    fn add_point(&mut self, index: usize, weight: f32, dist: f64, representative:usize) -> Result<()> {
+        check_argument(representative==0,"can have only one representative")?;
+        check_argument(!weight.is_nan() && weight >= 0.0f32, "non-negative weight")?;
         self.add_point(index,weight,dist);
+        Ok(())
     }
 
     fn recompute<'a>(&mut self, points:&'a [Z],get_point: fn(usize,&'a [Z]) ->&'a [f32], distance: fn(&[f32], &[f32]) -> f64) -> f64 {
@@ -266,9 +267,10 @@ impl<Z> IntermediateCluster<Z,Vec<f32>, [f32]> for Center {
         get_point: fn(usize,&'a [Z]) ->&'a [f32],
         another: &dyn IntermediateCluster<Z, Vec<f32>, [f32]>,
         distance: fn(&[f32], &[f32]) -> f64,
-    ) {
-        let closest = another.distance_to_point(points,get_point, &self.representative,distance);
-        self.absorb_list(another.weight(),&another.representatives(),closest);
+    ) ->Result<()> {
+        let closest = another.distance_to_point(points, get_point, &self.representative, distance);
+        self.absorb_list(another.weight(), &another.representatives(), closest);
+        Ok(())
     }
 
     fn representatives(&self) -> Vec<(Vec<f32>, f32)> {
@@ -281,9 +283,10 @@ impl<Z> IntermediateCluster<Z,Vec<f32>, Vec<f32>> for Center {
         self.weight()
     }
 
-    fn scale_weight(&mut self, factor: f64){
-        assert!(!factor.is_nan() && factor>0.0," has to be positive");
-        self.weight = (self.weight as f64 * factor);
+    fn scale_weight(&mut self, factor: f64) -> Result<()>{
+        check_argument(!factor.is_nan() && factor>0.0," has to be positive")?;
+        self.weight = self.weight as f64 * factor;
+        Ok(())
     }
 
     fn distance_to_point<'a>(&self, _points:&'a [Z],_get_point: fn(usize,&'a [Z]) ->&'a Vec<f32>,point: &Vec<f32>, distance: fn(&Vec<f32>, &Vec<f32>) -> f64) -> (f64,usize) {
@@ -301,10 +304,11 @@ impl<Z> IntermediateCluster<Z,Vec<f32>, Vec<f32>> for Center {
         (tuple.0,0,tuple.1)
     }
 
-    fn add_point(&mut self, index: usize, weight: f32, dist: f64, representative:usize) {
-        assert!(representative==0,"can have only one representative");
-        assert!(!weight.is_nan() && weight >= 0.0f32, "non-negative weight");
+    fn add_point(&mut self, index: usize, weight: f32, dist: f64, representative:usize) ->Result<()>{
+        check_argument(representative==0,"can have only one representative")?;
+        check_argument(!weight.is_nan() && weight >= 0.0f32, "non-negative weight")?;
         self.add_point(index,weight,dist);
+        Ok(())
     }
 
     fn recompute<'a>(&mut self, points:&'a [Z],get_point: fn(usize,&'a [Z]) ->&'a Vec<f32>, distance: fn(&Vec<f32>, &Vec<f32>) -> f64) -> f64 {
@@ -330,9 +334,10 @@ impl<Z> IntermediateCluster<Z,Vec<f32>, Vec<f32>> for Center {
         get_point: fn(usize,&'a [Z]) ->&'a Vec<f32>,
         another: &dyn IntermediateCluster<Z, Vec<f32>, Vec<f32>>,
         distance: fn(&Vec<f32>, &Vec<f32>) -> f64,
-    ) {
+    ) -> Result<()>{
         let closest = another.distance_to_point(points,get_point, &self.representative,distance);
         self.absorb_list(another.weight(),&another.representatives(),closest);
+        Ok(())
     }
 
     fn representatives(&self) -> Vec<(Vec<f32>, f32)> {
@@ -345,7 +350,7 @@ impl<Z> IntermediateCluster<Z,Vec<f32>, Vec<f32>> for Center {
 fn process_point<'a,Z,U,Q,T :?Sized>(dictionary: &'a [Z], get_point: fn(usize,&'a [Z])->&'a T, index: usize, centers: &mut [U], weight : f32, distance: fn(&T, &T) -> f64) -> Result<()>
     where
         U: IntermediateCluster<Z,Q, T> + Send,
-        T: std::marker::Sync,
+        T: Sync,
 {
     let mut dist = vec![(0.0, 1); centers.len()];
     let mut min_distance = (f64::MAX, 1);
@@ -356,11 +361,11 @@ fn process_point<'a,Z,U,Q,T :?Sized>(dictionary: &'a [Z], get_point: fn(usize,&'
             min_distance = dist[j];
         }
     };
-    //check_argument(min_distance.0>=0.0," distances cannot be negative")?;
+    check_argument(min_distance.0>=0.0," distances cannot be negative")?;
     if min_distance.0 == 0.0 {
         for j in 0..centers.len() {
             if dist[j].0 == 0.0 {
-                centers[j].add_point(index, weight, 0.0, dist[j].1);
+                centers[j].add_point(index, weight, 0.0, dist[j].1)?;
             }
         }
     } else {
@@ -376,7 +381,7 @@ fn process_point<'a,Z,U,Q,T :?Sized>(dictionary: &'a [Z], get_point: fn(usize,&'
                     index,
                     (weight as f64 * min_distance.0 / (sum * dist[j].0)) as f32,
                     dist[j].0, dist[j].1
-                );
+                )?;
             }
         }
     }
@@ -396,14 +401,14 @@ fn assign_and_recompute<'a, Z, Q, U, T: ?Sized>(
 ) -> Result<f64>
     where
         U: IntermediateCluster<Z,Q, T> + Send,
-        T: std::marker::Sync,
-        Z: std::marker::Sync,
+        T: Sync,
+        Z: Sync,
 {
     for j in 0..centers.len() {
         centers[j].reset();
     }
 
-    if (samples.len() == 0){
+    if samples.len() == 0{
         for i in 0..dictionary.len() {
             process_point(dictionary,get_point,i,centers,get_weight(i,dictionary,weights),distance)?;
         }
@@ -487,7 +492,7 @@ pub fn general_iterative_clustering<'a, U, V, Q, Z, T: ?Sized>(
     approximate_bound: usize,
     seed: u64,
     parallel_enabled: bool,
-    create: fn(usize, &'a T, f32, V) -> U,
+    create: fn(usize, &'a T, f32, V) -> Result<U>,
     create_params: V,
     distance: fn(&T, &T) -> f64,
     phase_2_reassign: bool,
@@ -496,8 +501,8 @@ pub fn general_iterative_clustering<'a, U, V, Q, Z, T: ?Sized>(
 ) -> Result<Vec<U>>
 where
     U: IntermediateCluster<Z,Q, T> + Send,
-    T: std::marker::Sync,
-    Z: std::marker::Sync,
+    T: Sync,
+    Z: Sync,
     V: Copy,
 {
     check_argument(max_allowed < 51, " for large number of clusters, other methods may be better, consider recursively removing clusters")?;
@@ -506,7 +511,7 @@ where
 
     let mut centers: Vec<U> = Vec::new();
 
-    let mut samples : Vec<(usize,f32)> = if dictionary.len() > approximate_bound {
+    let samples : Vec<(usize,f32)> = if dictionary.len() > approximate_bound {
         down_sample(dictionary,weights,get_weight,rng.next_u64(),approximate_bound)
     } else {
         Vec::new()
@@ -537,7 +542,7 @@ where
             };
         }
         if min_dist > 0.0 {
-            centers.push(create(index,get_point(index,dictionary), weight,create_params));
+            centers.push(create(index,get_point(index,dictionary), weight,create_params)?);
         }
     }
 
@@ -594,10 +599,10 @@ where
         let inital = centers.len();
         if inital > max_allowed || found_merge || (enable_phase_3 && measure > overlap_parameter) {
             let (small, large) = centers.split_at_mut(second);
-            large.first_mut().unwrap().absorb(&dictionary,get_point, &small[first], distance);
+            large.first_mut().unwrap().absorb(&dictionary,get_point, &small[first], distance)?;
             centers.swap_remove(first);
             if phase_2_reassign && centers.len() <= PHASE2_THRESHOLD * max_allowed + 1{
-                assign_and_recompute(&dictionary, weights,get_point,get_weight, &samples, &mut centers, distance, parallel_enabled);
+                assign_and_recompute(&dictionary, weights,get_point,get_weight, &samples, &mut centers, distance, parallel_enabled)?;
             }
 
             centers.sort_by(|o1, o2| o1.weight().partial_cmp(&o2.weight()).unwrap());
@@ -618,7 +623,7 @@ where
     centers.sort_by(|o1, o2| o2.weight().partial_cmp(&o1.weight()).unwrap()); // decreasing order
     let center_sum: f64 = centers.iter().map(|x| x.weight() as f64).sum();
     for i in 0..centers.len() {
-        centers[i].scale_weight(1.0/center_sum);
+        centers[i].scale_weight(1.0/center_sum)?;
     }
     Ok(centers)
 }
@@ -642,11 +647,11 @@ fn pick_to_slice<'a>(index: usize, entry:&'a [Vec<f32>]) -> &'a [f32]{
 }
 
 
-fn pick_tuple_weight<T>(index:usize, entry:&[(T,f32)], weights: &[f32]) -> f32{
+fn pick_tuple_weight<T>(index:usize, entry:&[(T,f32)], _weights: &[f32]) -> f32{
     entry[index].1
 }
 
-fn pick_weight<T>(index:usize, entry:&[T], weights: &[f32]) -> f32{
+fn pick_weight<T>(index:usize, _entry:&[T], weights: &[f32]) -> f32{
     weights[index]
 }
 
@@ -835,18 +840,18 @@ impl<'b,T :?Sized> MultiCenterRef<'b,T>{
         self.representatives.clone()
     }
 
-    pub fn new(representative: usize, point: &'b T, weight: f32, params : (usize,f32,bool)) -> Self {
+    pub fn new(_representative: usize, point: &'b T, weight: f32, params : (usize,f32,bool)) -> Result<Self> {
         let (number_of_representatives, shrinkage,is_compact) = params;
-        assert!(number_of_representatives>0,"has to be positive");
-        assert!(shrinkage>=0.0 && shrinkage<= 1.0," has to between [0,1]");
-        MultiCenterRef {
+        check_argument(number_of_representatives>0,"has to be positive")?;
+        check_argument(shrinkage>=0.0 && shrinkage<= 1.0," has to between [0,1]")?;
+        Ok(MultiCenterRef {
             representatives: vec![(point, weight as f32);1],
             number_of_representatives,
             shrinkage,
             is_compact,
             weight: weight as f64,
             sum_of_radii: 0.0,
-        }
+        })
     }
 
     pub fn average_radius(&self) -> f64 {
@@ -900,13 +905,14 @@ impl<'b, Z, T:?Sized> IntermediateCluster<Z, &'b T,T> for MultiCenterRef<'b,T> {
         ((closest.0 * (1.0 - self.shrinkage as f64) + self.shrinkage as f64 * original.0), closest.1, closest.2)
     }
 
-    fn add_point(&mut self, index: usize, weight: f32, dist: f64, representative: usize) {
+    fn add_point(&mut self, _index: usize, weight: f32, dist: f64, representative: usize) -> Result<()>{
         self.representatives[representative].1 += weight;
         self.sum_of_radii += weight as f64 * dist;
         self.weight += weight as f64;
+        Ok(())
     }
 
-    fn recompute<'a>(&mut self, points:&'a [Z],get_point: fn(usize,&'a [Z]) ->&'a T, distance: fn(&T, &T) -> f64) -> f64 {
+    fn recompute<'a>(&mut self, _points:&'a [Z],_get_point: fn(usize,&'a [Z]) ->&'a T, _distance: fn(&T, &T) -> f64) -> f64 {
         self.representatives.sort_by(|a,b| a.1.partial_cmp(&b.1).unwrap());
         0.0
     }
@@ -929,11 +935,11 @@ impl<'b, Z, T:?Sized> IntermediateCluster<Z, &'b T,T> for MultiCenterRef<'b,T> {
 
     fn absorb<'a>(
         &mut self,
-        points:&'a [Z],
-        get_point: fn(usize,&'a [Z]) ->&'a T,
+        _points:&'a [Z],
+        _get_point: fn(usize,&'a [Z]) ->&'a T,
         another: &dyn IntermediateCluster<Z, &'b T, T>,
         distance: fn(&T, &T) -> f64,
-    ) {
+    )  -> Result<()> {
         self.sum_of_radii += if self.is_compact {
             another.average_radius()*another.weight()
         } else {
@@ -962,19 +968,19 @@ impl<'b, Z, T:?Sized> IntermediateCluster<Z, &'b T,T> for MultiCenterRef<'b,T> {
          * correspond to a well scattered set. See
          * https://en.wikipedia.org/wiki/CURE_algorithm
          */
-        while (representatives.len() > 0 && self.representatives.len() < self.number_of_representatives) {
+        while representatives.len() > 0 && self.representatives.len() < self.number_of_representatives {
             let mut farthest_weighted_distance = 0.0;
             let mut farthest_index: usize = usize::MAX;
             for j in 0..representatives.len() {
                 if representatives[j].1 as f64 > (weight as f64) / (2.0 * self.number_of_representatives as f64) {
                     let mut new_weighted_distance = (distance)(self.representatives[0].0,
                                                                representatives[j].0) * representatives[j].1 as f64;
-                    assert!(new_weighted_distance >= 0.0, " weights or distances cannot be negative");
+                    check_argument(new_weighted_distance >= 0.0, " weights or distances cannot be negative")?;
                     for i in 1..self.representatives.len() {
                         let t = (distance)(self.representatives[i].0,
                                            representatives[j].0) * representatives[j].1 as f64;
-                        assert!(t >= 0.0, " weights or distances cannot be negative");
-                        if (t < new_weighted_distance) {
+                        check_argument(t >= 0.0, " weights or distances cannot be negative")?;
+                        if t < new_weighted_distance {
                             new_weighted_distance = t;
                         }
                     }
@@ -994,13 +1000,13 @@ impl<'b, Z, T:?Sized> IntermediateCluster<Z, &'b T,T> for MultiCenterRef<'b,T> {
         // absorb the remainder into existing representatives
         for j in 0..representatives.len() {
             let dist = (distance)(representatives[0].0, self.representatives[0].0);
-            assert!(dist >= 0.0, "distance cannot be negative");
+            check_argument(dist >= 0.0, "distance cannot be negative")?;
             let mut min_dist = dist;
             let mut min_index: usize = 0;
             for i in 1..self.representatives.len() {
                 let new_dist = (distance)(self.representatives[i].0, representatives[j].0);
-                assert!(new_dist >= 0.0, "distance cannot be negative");
-                if (new_dist < min_dist) {
+                check_argument(new_dist >= 0.0, "distance cannot be negative")?;
+                if new_dist < min_dist {
                     min_dist = new_dist;
                     min_index = i;
                 }
@@ -1009,16 +1015,19 @@ impl<'b, Z, T:?Sized> IntermediateCluster<Z, &'b T,T> for MultiCenterRef<'b,T> {
             self.sum_of_radii += representatives[j].1 as f64 * min_dist;
         }
         self.representatives.sort_by(|a,b| b.1.partial_cmp(&a.1).unwrap());
+        Ok(())
     }
 
     fn representatives(&self) -> Vec<(&'b T, f32)> {
         self.representatives()
     }
 
-    fn scale_weight(&mut self, factor: f64) {
+    fn scale_weight(&mut self, factor: f64) -> Result<()>{
+        check_argument(!factor.is_nan() && factor>0.0," has to be positive")?;
         for i in 0..self.representatives.len() {
             self.representatives[i].1 = (self.representatives[i].1 as f64 * factor) as f32;
         }
+        Ok(())
     }
 
 }
diff --git a/Rust/src/common/conditionalfieldsummarizer.rs b/Rust/src/common/conditionalfieldsummarizer.rs
index b01dac78..d4081398 100644
--- a/Rust/src/common/conditionalfieldsummarizer.rs
+++ b/Rust/src/common/conditionalfieldsummarizer.rs
@@ -1,6 +1,8 @@
+use std::hash::Hash;
 use crate::{
     common::samplesummary::{summarize, SampleSummary},
     pointstore::PointStore,
+    types::Result
 };
 
 fn project_missing(point: &Vec<f32>, position: &[usize]) -> Vec<f32> {
@@ -52,12 +54,12 @@ impl FieldSummarizer {
         }
     }
 
-    pub fn summarize_list(
+    pub fn summarize_list<Label:Copy + Sync + Send, Attributes : Copy + Sync + Hash + Eq + Send>(
         &self,
-        pointstore: &dyn PointStore,
+        pointstore: &dyn PointStore<Label,Attributes>,
         point_list_with_distance: &[(f64, usize, f64)],
         missing: &[usize]
-    ) -> SampleSummary {
+    ) -> Result<SampleSummary> {
         let mut distance_list: Vec<f64> = point_list_with_distance.iter().map(|a| a.2).collect();
         distance_list.sort_by(|a, b| a.partial_cmp(&b).unwrap());
         let mut threshold = 0.0;
@@ -78,7 +80,7 @@ impl FieldSummarizer {
 
         let total_weight = point_list_with_distance.len() as f64;
         let dimensions = if !self.project || missing.len() == 0 {
-            pointstore.get_copy(point_list_with_distance[0].1).len()
+            pointstore.copy(point_list_with_distance[0].1)?.len()
         } else {
             missing.len()
         };
@@ -89,10 +91,10 @@ impl FieldSummarizer {
         let mut vec = Vec::new();
         for i in 0..point_list_with_distance.len() {
             let point = if !self.project || missing.len() == 0 {
-                pointstore.get_copy(point_list_with_distance[i].1)
+                pointstore.copy(point_list_with_distance[i].1)?
             } else {
                 project_missing(
-                    &pointstore.get_copy(point_list_with_distance[i].1),
+                    &pointstore.copy(point_list_with_distance[i].1)?,
                     &missing,
                 )
             };
@@ -136,7 +138,7 @@ impl FieldSummarizer {
         }
 
         let summary = summarize(&vec, self.distance, self.max_number, false).unwrap();
-        SampleSummary {
+        Ok(SampleSummary {
             summary_points: summary.summary_points.clone(),
             relative_weight: summary.relative_weight.clone(),
             total_weight: summary.total_weight,
@@ -145,6 +147,6 @@ impl FieldSummarizer {
             upper,
             lower,
             deviation,
-        }
+        })
     }
 }
diff --git a/Rust/src/common/descriptor.rs b/Rust/src/common/descriptor.rs
new file mode 100644
index 00000000..a9ce7e2a
--- /dev/null
+++ b/Rust/src/common/descriptor.rs
@@ -0,0 +1,113 @@
+use crate::common::divector::DiVector;
+use crate::common::rangevector::RangeVector;
+use crate::trcf::types::{CorrectionMode, ImputationMethod, ScoringStrategy, TransformMethod};
+use crate::trcf::types::ImputationMethod::USE_RCF;
+use crate::trcf::types::ScoringStrategy::EXPECTED_INVERSE_HEIGHT;
+
+/**
+ * This class maintains a simple discounted statistics. Setters are avoided
+ * except for discount rate which is useful as initialization from raw scores
+ */
+#[repr(C)]
+#[derive(Clone)]
+pub struct Descriptor {
+    pub id: u64,
+    pub current_input: Vec<f32>,
+    pub current_timestamp: u64,
+    pub missing_values: Option<Vec<usize>>,
+    pub rcf_point: Option<Vec<f32>>,
+    pub score: f32,
+    pub correction_mode: CorrectionMode,
+    pub values_seen: usize,
+    pub transform_method : TransformMethod,
+    pub threshold: f32,
+    pub anomaly_grade: f32,
+    pub data_confidence: f32,
+    pub attribution: Option<DiVector>,
+    pub relative_index : i32,
+    pub scale : Option<Vec<f32>>,
+    pub shift : Option<Vec<f32>>,
+    pub difference_deviations: Option<Vec<f32>>,
+    pub deviations_post : Option<Vec<f32>>,
+    pub time_augmented : bool,
+    pub expected_rcf_point: Option<Vec<f32>>,
+    pub last_anomaly : Option<AnomalyInformation>,
+    pub forecast : Option<RangeVector<f32>>,
+    pub error_information : Option<ErrorInformation>,
+    pub scoring_strategy : ScoringStrategy,
+    pub imputation_method : ImputationMethod,
+}
+
+#[repr(C)]
+#[derive(Clone)]
+pub struct AnomalyInformation {
+    // we do not explicitly provide a default so that each of these entires are
+    // considered carefully before declaring an anomaly
+    pub expected_rcf_point: Vec<f32>,
+    pub anomalous_rcf_point: Vec<f32>,
+    pub relative_index: i32,
+    pub values_seen: usize,
+    pub attribution: Option<DiVector>,
+    pub score: f32,
+    pub grade: f32,
+    pub expected_timestamp: u64,
+    pub relevant_attribution: Option<Vec<f32>>,
+    pub time_attribution: f32,
+    pub past_values: Vec<f32>,
+    pub past_timestamp: u64,
+    pub expected_values_list: Vec<Vec<f32>>,
+    pub likelihood_of_values: Vec<f32>
+}
+
+#[repr(C)]
+#[derive(Clone)]
+pub struct ErrorInformation {
+    pub interval_precision: Vec<f32>,
+    pub error_distribution : RangeVector<f32>,
+    pub error_rmse : DiVector,
+    pub error_mean : Vec<f32>
+}
+
+impl Default for Descriptor {
+    fn default() -> Self {
+        Descriptor{
+            id: 0,
+            current_input: vec![],
+            current_timestamp: 0,
+            missing_values: None,
+            rcf_point: None,
+            score: 0.0,
+            correction_mode: CorrectionMode::NONE,
+            values_seen: 0,
+            transform_method: TransformMethod::NONE,
+            threshold: 0.0,
+            anomaly_grade: 0.0,
+            data_confidence: 0.0,
+            attribution: None,
+            relative_index: 0,
+            scale: None,
+            shift: None,
+            difference_deviations: None,
+            deviations_post: None,
+            time_augmented: false,
+            expected_rcf_point: None,
+            last_anomaly: None,
+            forecast: None,
+            error_information: None,
+            scoring_strategy: EXPECTED_INVERSE_HEIGHT,
+            imputation_method: USE_RCF
+        }
+    }
+}
+
+impl Descriptor {
+    pub fn new(id: u64, point: &[f32], current_timestamp: u64,time_augmented: bool, missing_values: Option<Vec<usize>>) -> Self {
+        if missing_values.as_ref().is_some(){
+            for i in missing_values.as_ref().unwrap() {
+                assert!( *i < point.len(), "incorrect input")
+            }
+        }
+        Descriptor { id, current_input: Vec::from(point), current_timestamp, time_augmented, missing_values, ..Default::default()}
+    }
+}
+
diff --git a/Rust/src/common/deviation.rs b/Rust/src/common/deviation.rs
index a75bed6c..900f299e 100644
--- a/Rust/src/common/deviation.rs
+++ b/Rust/src/common/deviation.rs
@@ -1,3 +1,6 @@
+use crate::util::check_argument;
+use crate::types::Result;
+
 /**
  * This class maintains a simple discounted statistics. Setters are avoided
  * except for discount rate which is useful as initialization from raw scores
@@ -13,15 +16,15 @@ pub struct Deviation {
 }
 
 impl Deviation {
-    pub fn new(discount: f64) -> Self {
-        assert!(discount>=0.0 && discount < 1.0, "incorrect discount value");
-        Deviation {
+    pub fn new(discount: f64) -> Result<Self> {
+        check_argument(discount>=0.0 && discount < 1.0, "incorrect discount value")?;
+        Ok(Deviation {
             discount,
             weight: 0.0,
             sum:0.0,
             sum_squared:0.0,
             count:0
-        }
+        })
     }
 
     pub fn default() -> Self {
@@ -44,6 +47,13 @@ impl Deviation {
         }
     }
 
+    pub fn reset(&mut self) {
+        self.weight = 0.0;
+        self.count = 0;
+        self.sum = 0.0;
+        self.sum_squared = 0.0;
+    }
+
     pub fn mean(&self) -> f64 {
         if self.is_empty() {
             0.0
diff --git a/Rust/src/common/directionaldensity.rs b/Rust/src/common/directionaldensity.rs
index 9004abd4..0b29fa15 100644
--- a/Rust/src/common/directionaldensity.rs
+++ b/Rust/src/common/directionaldensity.rs
@@ -1,4 +1,6 @@
 use crate::{common::divector::DiVector, samplerplustree::boundingbox::BoundingBox};
+use crate::types::Result;
+use crate::util::check_argument;
 
 #[repr(C)]
 #[derive(Clone)]
@@ -24,21 +26,21 @@ impl InterpolationMeasure {
         distance: DiVector,
         prob_mass: DiVector,
         sample_size: f32,
-    ) -> Self {
-        assert!(
+    ) -> Result<Self> {
+        check_argument(
             measure.dimensions() == distance.dimensions(),
             " incorrect lengths"
-        );
-        assert!(
+        )?;
+        check_argument(
             measure.dimensions() == prob_mass.dimensions(),
             " incorrect lengths"
-        );
-        InterpolationMeasure {
+        )?;
+        Ok(InterpolationMeasure {
             measure: measure,
             distance: distance,
             probability_mass: prob_mass,
             sample_size,
-        }
+        })
     }
 
     pub fn add_to(&self, other: &mut InterpolationMeasure) {
@@ -98,13 +100,13 @@ impl InterpolationMeasure {
         prob
     }
 
-    pub fn directional_measure(&self, threshold: f64, manifold_dimension: f64) -> DiVector {
-        assert!(
+    pub fn directional_measure(&self, threshold: f64, manifold_dimension: f64) -> Result<DiVector> {
+        check_argument(
             self.sample_size >= 0.0 && self.measure.total() >= 0.0,
             " cannot have negative samples or measure"
-        );
+        )?;
         if self.sample_size == 0.0f32 || self.measure.total() == 0.0 {
-            return DiVector::empty(self.measure.dimensions());
+            return Ok(DiVector::empty(self.measure.dimensions()));
         }
 
         let mut sum_of_factors = 0.0;
@@ -126,14 +128,14 @@ impl InterpolationMeasure {
         let density_factor = 1.0 / (threshold + sum_of_factors);
         let mut answer = self.measure.clone();
         answer.scale(density_factor);
-        answer
+        Ok(answer)
     }
 
-    pub fn directional_density(&self) -> DiVector {
+    pub fn directional_density(&self) -> Result<DiVector> {
         self.directional_measure(1e-3, self.measure.dimensions() as f64)
     }
 
-    pub fn density(&self) -> f64 {
-        self.directional_density().total()
+    pub fn density(&self) -> Result<f64> {
+        Ok(self.directional_density()?.total())
     }
 }
diff --git a/Rust/src/common/divector.rs b/Rust/src/common/divector.rs
index 9583b9d4..6d53270d 100644
--- a/Rust/src/common/divector.rs
+++ b/Rust/src/common/divector.rs
@@ -1,4 +1,6 @@
 use crate::samplerplustree::boundingbox::BoundingBox;
+use crate::util::check_argument;
+use crate::types::Result;
 
 #[repr(C)]
 #[derive(Clone)]
@@ -15,12 +17,12 @@ impl DiVector {
         }
     }
 
-    pub fn new(high: &[f64], low: &[f64]) -> Self {
-        assert!(high.len() == low.len(), " incorrect lengths");
-        DiVector {
+    pub fn new(high: &[f64], low: &[f64]) -> Result<Self> {
+        check_argument(high.len() == low.len(), " incorrect lengths")?;
+        Ok(DiVector {
             high: Vec::from(high),
             low: Vec::from(low),
-        }
+        })
     }
 
     pub fn assign_as_probability_of_cut(&mut self, bounding_box: &BoundingBox, point: &[f32]) {
@@ -177,13 +179,20 @@ impl DiVector {
         self.high[index] + self.low[index]
     }
 
-    pub fn max_contribution(&self, base_dimension: usize) -> usize {
+    pub fn max_contribution(&self, base_dimension: usize) -> Result<usize> {
+        self.max_gap_contribution(base_dimension,self.dimensions())
+    }
+
+    pub fn max_gap_contribution(&self, base_dimension: usize, gap: usize) -> Result<usize> {
+        check_argument(gap>0, "incorrect input")?;
+        check_argument(base_dimension>0, "incorrect input")?;
+        check_argument(self.dimensions()%base_dimension == 0, "incorrect input")?;
         let mut val = 0.0;
-        let mut index = 0;
+        let mut index = if  gap * base_dimension > self.dimensions() {0} else { self.dimensions()/base_dimension - gap};
         for i in 0..base_dimension {
-            val += self.high_low_sum(i);
+            val += self.high_low_sum(index*base_dimension + i);
         }
-        for j in 1..(self.dimensions() / base_dimension) {
+        for j in (index+1)..(self.dimensions() / base_dimension) {
             let mut sum = 0.0;
             for i in 0..base_dimension {
                 sum += self.high_low_sum(j * base_dimension + i);
@@ -193,6 +202,6 @@ impl DiVector {
                 index = j;
             }
         }
-        index
+        Ok(index)
     }
 }
diff --git a/Rust/src/common/intervalstoremanager.rs b/Rust/src/common/intervalstoremanager.rs
index 854cc068..28895c86 100644
--- a/Rust/src/common/intervalstoremanager.rs
+++ b/Rust/src/common/intervalstoremanager.rs
@@ -1,4 +1,6 @@
 use std::fmt::Debug;
+use crate::types::Result;
+use crate::util::check_argument;
 
 #[repr(C)]
 pub struct IntervalStoreManager<T> {
@@ -52,14 +54,11 @@ where
         self.last_in_use == 0
     }
 
-    pub fn get(&mut self) -> usize
+    pub fn get(&mut self) -> Result<usize>
     where
         <T as TryFrom<usize>>::Error: Debug,
     {
-        if self.is_empty() {
-            println!(" no more indices left");
-            panic!();
-        }
+        check_argument(!self.is_empty(),"no more indices left in interval manager")?;
         let answer = self.free_indices_start[self.last_in_use - 1];
         let new_value: usize = answer.into();
         if answer == self.free_indices_end[self.last_in_use - 1] {
@@ -67,10 +66,10 @@ where
         } else {
             self.free_indices_start[self.last_in_use - 1] = (new_value + 1).try_into().unwrap();
         }
-        new_value
+        Ok(new_value)
     }
 
-    pub fn release(&mut self, index: usize)
+    pub fn release(&mut self, index: usize) -> Result<()>
     where
         <T as TryFrom<usize>>::Error: Debug,
     {
@@ -80,10 +79,10 @@ where
             let end: usize = self.free_indices_end[self.last_in_use - 1].into();
             if start == index + 1 {
                 self.free_indices_start[self.last_in_use - 1] = val;
-                return;
+                return Ok(());
             } else if end + 1 == index {
                 self.free_indices_end[self.last_in_use - 1] = val;
-                return;
+                return Ok(());
             }
         }
         if self.last_in_use < self.free_indices_start.len() {
@@ -94,6 +93,7 @@ where
             self.free_indices_end.resize(self.last_in_use + 1, val);
         }
         self.last_in_use += 1;
+        Ok(())
     }
 
     pub fn used(&self) -> usize {
diff --git a/Rust/src/common/mod.rs b/Rust/src/common/mod.rs
index 10954539..d174034c 100644
--- a/Rust/src/common/mod.rs
+++ b/Rust/src/common/mod.rs
@@ -6,5 +6,5 @@ pub mod intervalstoremanager;
 pub mod multidimdatawithkey;
 pub mod samplesummary;
 pub mod deviation;
-pub mod anomalydescriptor;
 pub mod rangevector;
+pub mod descriptor;
diff --git a/Rust/src/common/multidimdatawithkey.rs b/Rust/src/common/multidimdatawithkey.rs
index d2aa84a6..d1e13784 100644
--- a/Rust/src/common/multidimdatawithkey.rs
+++ b/Rust/src/common/multidimdatawithkey.rs
@@ -8,6 +8,8 @@ use rand_chacha::ChaCha20Rng;
 use rand_core::RngCore;
 
 use crate::rand::Rng;
+use crate::util::check_argument;
+use crate::types::Result;
 
 pub struct MultiDimDataWithKey {
     pub data: Vec<Vec<f32>>,
@@ -24,15 +26,15 @@ impl MultiDimDataWithKey {
         noise: f32,
         seed: u64,
         base_dimension: usize,
-    ) -> Self {
-        assert!(
+    ) -> Result<Self> {
+        check_argument(
             period.len() == base_dimension,
             " need a period for each dimension "
-        );
-        assert!(
+        )?;
+        check_argument(
             amplitude.len() == base_dimension,
             " need an amplitude for each dimension"
-        );
+        )?;
         let mut rng = ChaCha20Rng::seed_from_u64(seed);
         let mut noiserng = ChaCha20Rng::seed_from_u64(seed + 1);
         let mut phase: Vec<usize> = Vec::new();
@@ -71,12 +73,12 @@ impl MultiDimDataWithKey {
                 changes.push(new_change);
             }
         }
-        MultiDimDataWithKey {
+        Ok(MultiDimDataWithKey {
             data,
             change_indices,
             labels: Vec::new(),
             changes,
-        }
+        })
     }
 
     pub fn mixture(
@@ -85,29 +87,29 @@ impl MultiDimDataWithKey {
         scale: &[Vec<f32>],
         weight: &[f32],
         seed: u64,
-    ) -> Self {
+    ) -> Result<Self> {
         let mut rng = ChaCha20Rng::seed_from_u64(seed);
-        assert!(num > 0, " number of elements cannot be 0");
-        assert!(mean.len() > 0, " cannot be null");
+        check_argument(num > 0, " number of elements cannot be 0")?;
+        check_argument(mean.len() > 0, " cannot be null")?;
         let base_dimension = mean[0].len();
-        assert!(
+        check_argument(
             mean.len() == scale.len(),
             " need scales and means to be 1-1"
-        );
-        assert!(
+        )?;
+        check_argument(
             weight.len() == mean.len(),
             " need weights and means to be 1-1"
-        );
+        )?;
         for i in 0..mean.len() {
-            assert!(
+            check_argument(
                 mean[i].len() == base_dimension,
                 " must have the same dimensions"
-            );
-            assert!(
+            )?;
+            check_argument(
                 scale[i].len() == base_dimension,
                 "sclaes must have the same dimension as the mean"
-            );
-            assert!(weight[i] >= 0.0, " weights cannot be negative");
+            )?;
+            check_argument(weight[i] >= 0.0, " weights cannot be negative")?;
         }
         let sum: f32 = weight.iter().sum();
 
@@ -124,12 +126,12 @@ impl MultiDimDataWithKey {
             labels.push(i);
         }
 
-        MultiDimDataWithKey {
+        Ok(MultiDimDataWithKey {
             data,
             labels,
             change_indices: vec![],
             changes: vec![],
-        }
+        })
     }
 }
 
diff --git a/Rust/src/common/rangevector.rs b/Rust/src/common/rangevector.rs
index 240cf5be..b370437d 100644
--- a/Rust/src/common/rangevector.rs
+++ b/Rust/src/common/rangevector.rs
@@ -1,4 +1,5 @@
-
+use crate::util::check_argument;
+use crate::types::Result;
 
 /**
  * A RangeVector is used when we want to track a quantity and its upper and
@@ -6,13 +7,23 @@
  */
 #[repr(C)]
 #[derive(Clone)]
-pub struct RangeVector {
-    pub values: Vec<f32>,
-    pub upper: Vec<f32>,
-    pub lower: Vec<f32>
+pub struct RangeVector<T> {
+    pub values: Vec<T>,
+    pub upper: Vec<T>,
+    pub lower: Vec<T>
+}
+
+impl RangeVector<f32> {
+    pub fn new(dimensions: usize) -> Self {
+        RangeVector {
+            values: vec![0.0; dimensions],
+            upper: vec![0.0; dimensions],
+            lower: vec![0.0; dimensions]
+        }
+    }
 }
 
-impl RangeVector {
+impl RangeVector<f64> {
     pub fn new(dimensions: usize) -> Self {
         RangeVector {
             values: vec![0.0; dimensions],
@@ -20,8 +31,11 @@ impl RangeVector {
             lower: vec![0.0; dimensions]
         }
     }
+}
+
 
-    pub fn from(values : Vec<f32>) -> Self {
+impl<T: PartialOrd + Clone + Copy  + std::ops::AddAssign + std::ops::MulAssign> RangeVector<T> {
+    pub fn from(values : Vec<T>) -> Self {
         RangeVector{
             values : values.clone(),
             upper : values.clone(),
@@ -29,20 +43,20 @@ impl RangeVector {
         }
     }
 
-    pub fn create(values: &[f32], upper: &[f32], lower:&[f32]) -> Self {
-        assert!(values.len() == upper.len() && upper.len() == lower.len(), " incorrect lengths");
+    pub fn create(values: &[T], upper: &[T], lower:&[T]) -> Result<Self> {
+        check_argument(values.len() == upper.len() && upper.len() == lower.len(), " incorrect lengths")?;
         for i in 0..values.len() {
-            assert!(values[i] <= upper[i], " incorrect upper bound at {}", i);
-            assert!(lower[i] <= values [i], "incorrect lower bounds at {}",i);
+            check_argument(values[i] <= upper[i], " incorrect upper bound")?;
+            check_argument(lower[i] <= values [i], "incorrect lower bounds")?;
         }
-        RangeVector{
+        Ok(RangeVector{
             values :Vec::from(values),
             upper : Vec::from(upper),
             lower : Vec::from(lower)
-        }
+        })
     }
 
-    pub fn shift(&mut self, i:usize, shift: f32) {
+    pub fn shift(&mut self, i:usize, shift: T) {
         self.values[i] += shift;
         self.upper[i] += shift;
         self.lower[i] += shift;
@@ -55,7 +69,22 @@ impl RangeVector {
         }
     }
 
-    pub fn scale(&mut self, i:usize, scale: f32) {
+    pub fn cascaded_add(&mut self, base: &[T]) -> Result<()>{
+        check_argument(base.len() >0 , "must be of positive length")?;
+        let horizon = self.values.len()/base.len();
+        check_argument(horizon * base.len() == self.values.len(), " incorrect function call")?;
+        for j in 0..base.len() {
+            self.shift(j,base[j]);
+        }
+        for i in 1..horizon {
+            for j in 0..base.len() {
+                self.shift(i * base.len() + j, self.values[(i-1)*base.len() + j]);
+            }
+        }
+        Ok(())
+    }
+
+    pub fn scale(&mut self, i:usize, scale: T) {
         self.values[i] *= scale;
         self.upper[i] *= scale;
         self.lower[i] *= scale;
diff --git a/Rust/src/common/samplesummary.rs b/Rust/src/common/samplesummary.rs
index d7be012f..b11852b2 100644
--- a/Rust/src/common/samplesummary.rs
+++ b/Rust/src/common/samplesummary.rs
@@ -1,11 +1,7 @@
 use std::cmp::min;
 use std::ops::Index;
-use std::slice::SliceIndex;
 use crate::types::Result;
-use crate::errors;
 use crate::util::check_argument;
-use rand::{Rng, SeedableRng};
-use rand_chacha::ChaCha20Rng;
 use rayon::range;
 
 use crate::common::cluster::{Center, multi_cluster_as_weighted_obj, multi_cluster_as_weighted_ref, single_centroid_cluster_weighted_vec_with_distance_over_slices};
diff --git a/Rust/src/example.rs b/Rust/src/example.rs
index 31eaa15e..75cb1358 100644
--- a/Rust/src/example.rs
+++ b/Rust/src/example.rs
@@ -5,8 +5,9 @@ use rand::{Rng, SeedableRng};
 use rand_chacha::ChaCha20Rng;
 use rcflib::{
     common::multidimdatawithkey,
-    rcf::{create_rcf, RCF},
+    rcf::{RCF},
 };
+use rcflib::rcf::{RCFBuilder, RCFOptionsBuilder};
 
 fn main() {
     let shingle_size = 8;
@@ -15,7 +16,6 @@ fn main() {
     let number_of_trees = 30;
     let capacity = 256;
     let initial_accept_fraction = 0.1;
-    let dimensions = shingle_size * base_dimension;
     let _point_store_capacity = capacity * number_of_trees + 1;
     let time_decay = 0.1 / capacity as f64;
     let bounding_box_cache_fraction = 1.0;
@@ -26,20 +26,12 @@ fn main() {
     let internal_rotation = false;
     let noise = 5.0;
 
-    let mut forest: Box<dyn RCF> = create_rcf(
-        dimensions,
-        shingle_size,
-        capacity,
-        number_of_trees,
-        random_seed,
-        store_attributes,
-        parallel_enabled,
-        internal_shingling,
-        internal_rotation,
-        time_decay,
-        initial_accept_fraction,
-        bounding_box_cache_fraction,
-    );
+    let mut forest = RCFBuilder::<u64,u64>::new(base_dimension,shingle_size)
+        .tree_capacity(capacity).number_of_trees(number_of_trees).random_seed(random_seed)
+        .store_attributes(store_attributes).parallel_enabled(parallel_enabled).internal_shingling(internal_shingling)
+        .time_decay(time_decay).initial_accept_fraction(initial_accept_fraction)
+        .internal_rotation(internal_rotation)
+        .bounding_box_cache_fraction(bounding_box_cache_fraction).build_default().unwrap();
 
     let mut rng = ChaCha20Rng::seed_from_u64(42);
     let mut amplitude = Vec::new();
@@ -54,7 +46,7 @@ fn main() {
         noise,
         0,
         base_dimension.into(),
-    );
+    ).unwrap();
 
     let mut score: f64 = 0.0;
     let _next_index = 0;
@@ -64,7 +56,7 @@ fn main() {
     for i in 0..data_with_key.data.len() {
         if i > 200 {
             let next_values = forest.extrapolate(1).unwrap().values;
-            assert!(next_values.len() == base_dimension);
+            assert_eq!(next_values.len(), base_dimension);
             error += next_values
                 .iter()
                 .zip(&data_with_key.data[i])
diff --git a/Rust/src/glad.rs b/Rust/src/glad.rs
index 6a75d429..bd1dbc5c 100644
--- a/Rust/src/glad.rs
+++ b/Rust/src/glad.rs
@@ -2,10 +2,9 @@
 use rand::{Rng, SeedableRng};
 use rand_chacha::ChaCha20Rng;
 use rand_core::RngCore;
-use crate::common::cluster::{multi_cluster_as_object_with_weight_array, multi_cluster_as_weighted_obj, MultiCenter, persist};
+use crate::common::cluster::{multi_cluster_as_weighted_obj, MultiCenter, persist};
 use crate::util::check_argument;
 use crate::trcf::basicthresholder::BasicThresholder;
-use crate::common::intervalstoremanager;
 use crate::common::intervalstoremanager::IntervalStoreManager;
 use crate::types::Result;
 
@@ -52,13 +51,13 @@ pub struct GlobalLocalAnomalyDetector<T:Clone + Sync> {
 }
 
 impl<T:Clone + Sync> GlobalLocalAnomalyDetector<T> {
-    pub fn new(capacity: usize, random_seed: u64, time_decay: f64, number_of_representatives: usize, shrinkage: f32, is_compact: bool) -> Self{
-        let mut basic_thresholder = BasicThresholder::new_adjustible(time_decay as f32,false);
+    pub fn new(capacity: usize, random_seed: u64, time_decay: f64, number_of_representatives: usize, shrinkage: f32, is_compact: bool) -> Result<Self>{
+        let mut basic_thresholder = BasicThresholder::new_adjustible(time_decay,false)?;
         basic_thresholder.set_absolute_threshold(1.2);
         if !is_compact {
             basic_thresholder.set_z_factor(2.5);
         }
-        GlobalLocalAnomalyDetector{
+        Ok(GlobalLocalAnomalyDetector{
             capacity,
             current_size: 0,
             random_seed,
@@ -83,7 +82,7 @@ impl<T:Clone + Sync> GlobalLocalAnomalyDetector<T> {
             ignore_below: DEFAULT_IGNORE_SMALL_CLUSTER_REPRESENTATIVE,
             initial_accept_fraction: 0.125,
             //global_distance: ()
-        }
+        })
     }
 
     fn initial_accept_probability(&self, fill_fraction: f64) -> f64 {
@@ -101,7 +100,7 @@ impl<T:Clone + Sync> GlobalLocalAnomalyDetector<T> {
         if self.current_size == self.capacity {
             return 1.0;
         };
-        (self.current_size as f64 / self.capacity as f64)
+        self.current_size as f64 / self.capacity as f64
     }
 
     fn compute_weight(&self, random_number: f64, weight: f32) -> f64 {
@@ -144,7 +143,7 @@ impl<T:Clone + Sync> GlobalLocalAnomalyDetector<T> {
         evicted_point
     }
 
-    fn sample(&mut self, object: &T, weight: f32) -> bool {
+    fn sample(&mut self, object: &T, weight: f32) -> Result<bool> {
         self.sequence_number += 1;
         self.entries_seen += 1;
         let mut initial = false;
@@ -160,15 +159,15 @@ impl<T:Clone + Sync> GlobalLocalAnomalyDetector<T> {
             if !initial {
                 let old_index = self.evict_max().1;
                 self.evicted = Some(self.object_list[old_index].clone());
-                self.interval_manager.release(old_index);
+                self.interval_manager.release(old_index)?;
             }
-            let index = self.interval_manager.get();
+            let index = self.interval_manager.get()?;
             if index < self.object_list.len() {
                 self.object_list[index] = (object.clone(), weight);
             } else {
                 self.object_list.push((object.clone(), weight));
             }
-            if (self.heap.len() == self.current_size){
+            if self.heap.len() == self.current_size {
                 self.heap.push((heap_weight, index));
             } else {
                 self.heap[self.current_size] = (heap_weight, index);
@@ -185,9 +184,9 @@ impl<T:Clone + Sync> GlobalLocalAnomalyDetector<T> {
                     break;
                 }
             }
-            return true;
+            return Ok(true);
         };
-        false
+        Ok(false)
     }
 
     pub fn set_z_factor(&mut self, z_factor : f32){
@@ -195,7 +194,7 @@ impl<T:Clone + Sync> GlobalLocalAnomalyDetector<T> {
     }
 
     pub fn score(&self, current: &T, local_distance: fn(&T, &T) -> f64, consider_occlusion: bool) -> Result<Vec<(T, f32)>> {
-        if (self.clusters.len() == 0) {
+        if self.clusters.len() == 0 {
             return Ok(Vec::new());
         } else {
             let mut candidate_list: Vec<(usize, (f64, &T), f64)> = Vec::new();
@@ -204,15 +203,16 @@ impl<T:Clone + Sync> GlobalLocalAnomalyDetector<T> {
                 let close = self.clusters[j].distance_to_point_and_ref(current, self.ignore_below, local_distance)?;
                 candidate_list.push((j, close, rad));
             }
-            candidate_list.sort_by(|a, b| a.1.0.partial_cmp(&b.1.0).unwrap());
+            candidate_list.sort_by(|a, b| a.1.0.partial_cmp(&b.1.0)
+                .expect("should not have NaN/Infinities"));
 
-            if (candidate_list[0].1.0 == 0.0) {
+            if candidate_list[0].1.0 == 0.0 {
                 return Ok(vec![(candidate_list[0].1.1.clone(), 0.0)]);
             }
             let mut index = 0;
-            while (index < candidate_list.len()) {
+            while index < candidate_list.len() {
                 let head = candidate_list[index];
-                if (consider_occlusion) {
+                if consider_occlusion {
                     for j in index + 1..candidate_list.len() {
                         let occlude = (local_distance)(head.1.1, candidate_list[j].1.1);
                         check_argument(occlude>=0.0, "distances cannot be negative")?;
@@ -243,10 +243,10 @@ impl<T:Clone + Sync> GlobalLocalAnomalyDetector<T> {
                    -> Result<GenericAnomalyDescriptor<T>> {
         check_argument(weight >= 0.0, "weight cannot be negative")?;
         // recompute clusters first; this enables easier merges and deserialization
-        if (self.sequence_number > self.last_cluster + self.do_not_recluster_within) {
+        if self.sequence_number > self.last_cluster + self.do_not_recluster_within {
             let current_mean = self.basic_thresholder.primary_mean() as f32;
-            if (f32::abs(current_mean - self.last_mean) > 0.1 || current_mean > 1.7f32
-                || self.sequence_number > self.last_cluster + 20 * self.do_not_recluster_within) {
+            if f32::abs(current_mean - self.last_mean) > 0.1 || current_mean > 1.7f32
+                || self.sequence_number > self.last_cluster + 20 * self.do_not_recluster_within {
                 self.last_cluster = self.sequence_number;
                 self.last_mean = current_mean;
                 let temp = multi_cluster_as_weighted_obj(&self.object_list,
@@ -258,7 +258,9 @@ impl<T:Clone + Sync> GlobalLocalAnomalyDetector<T> {
         let threshold = self.basic_thresholder.threshold();
         let mut grade: f32 = 0.0;
         let score: f32 = if score_list.len() == 0 { 0.0 } else {
-            score_list.iter().map(|a| a.1).min_by(|a,b| a.partial_cmp(b).unwrap()).unwrap()
+            score_list.iter().map(|a| a.1).min_by(|a, b| a.partial_cmp(b)
+                .expect("should not contain NaN, corrupt state"))
+                .expect("should be total order, corrupt state")
         };
 
         if score_list.len() > 0 {
@@ -266,7 +268,7 @@ impl<T:Clone + Sync> GlobalLocalAnomalyDetector<T> {
                 // an exponential attribution
                 let sum: f64 = score_list.iter().map(|a|
                     if a.1 == SCORE_MAX { 0.0f64 } else {
-                        f64::exp(-( a.1 * a.1) as f64)
+                        f64::exp(-(a.1 * a.1) as f64)
                     }
                 ).sum();
                 for mut item in &mut score_list {
@@ -281,13 +283,13 @@ impl<T:Clone + Sync> GlobalLocalAnomalyDetector<T> {
                     item.1 = 1.0 / (y as f32);
                 }
             }
-            grade = self.basic_thresholder.anomaly_grade(score, false);
+            grade = self.basic_thresholder.primary_grade(score);
             let other = self.basic_thresholder.z_factor();
             self.basic_thresholder.update_both(score, f32::min(score, other));
         }
-        self.sample(object, weight);
+        self.sample(object, weight)?;
 
-        return Ok(GenericAnomalyDescriptor {
+        Ok(GenericAnomalyDescriptor {
             representative_list: score_list,
             score: score as f64,
             threshold,
diff --git a/Rust/src/pointstore.rs b/Rust/src/pointstore.rs
index f6ed3d5b..f0c71f0a 100644
--- a/Rust/src/pointstore.rs
+++ b/Rust/src/pointstore.rs
@@ -1,49 +1,78 @@
 extern crate num;
 use std::{collections::HashMap, convert::TryFrom, fmt::Debug};
-
+use std::hash::Hash;
+use std::ptr::hash;
+use crate::types::{Result};
 use crate::{common::intervalstoremanager::IntervalStoreManager, types::Location};
+use crate::errors::RCFError;
+use crate::util::check_argument;
+
+pub const MAX_ATTRIBUTES: usize = 10;
 
-pub trait PointStore {
-    fn get_shingled_point(&self, point: &[f32]) -> Vec<f32>;
-    fn get_size(&self) -> usize;
-    fn get_missing_indices(&self, look_ahead: usize, values: &[usize]) -> Vec<usize>;
-    fn get_next_indices(&self, look_ahead: usize) -> Vec<usize>;
-    fn get_copy(&self, index: usize) -> Vec<f32>;
-    fn is_equal(&self, point: &[f32], index: usize) -> bool;
-    fn get_reference_and_offset(&self, index: usize) -> (&[f32], usize);
-
-    fn add(&mut self, point: &[f32]) -> usize;
-    fn inc(&mut self, index: usize);
-    fn dec(&mut self, index: usize);
-    fn adjust_count(&mut self, result: &[(usize, usize)]);
-    fn compact(&mut self);
+pub trait PointStore<Label,Attributes> where Label: Copy + Sync, Attributes: Copy + Sync + Hash + Eq + Send {
+    fn shingled_point(&self, point: &[f32]) -> Result<Vec<f32>>;
+    fn size(&self) -> usize;
+    fn missing_indices(&self, look_ahead: usize, values: &[usize]) -> Result<Vec<usize>>;
+    fn next_indices(&self, look_ahead: usize) -> Result<Vec<usize>>;
+    fn copy(&self, index: usize) -> Result<Vec<f32>>;
+    fn is_equal(&self, point: &[f32], index: usize) -> Result<bool>;
+    fn reference_and_offset(&self, index: usize) -> Result<(&[f32], usize)>;
+    fn entries_seen(&self) -> u64;
+    fn add(&mut self, point: &[f32], label:Label) -> Result<(usize,usize,Option<Vec<f32>>)>;
+    fn inc(&mut self, index: usize,attribute_index: usize) -> Result<()>;
+    fn dec(&mut self, index: usize,attribute_index: usize) -> Result<()>;
+    fn adjust_count(&mut self, result: &[((usize, usize),(usize,usize))]) -> Result<()>;
+    fn compact(&mut self) -> Result<()>;
+    fn label(&self, index: usize) -> Result<Label>;
+    fn attribute(&self, index: usize) -> Result<Attributes>;
+    fn point_sum(&self, list:&[(usize,usize)]) -> Result<Vec<f32>>;
+    fn attribute_vec(&self, index: usize) -> Result<Vec<f32>>;
 }
 
 #[repr(C)]
-pub struct VectorizedPointStore<L>
+pub struct VectorizedPointStore<L,Label,Attributes>
 where
     L: Location,
+    Label: Copy + Sync,
+    Attributes: Copy + Sync + Hash + Eq + Send,
 {
     internal_shingling: bool,
     internal_rotation: bool,
+    store_labels: bool,
+    store_attributes: bool,
+    propagate_attributes: bool,
     last_known_shingle: Vec<f32>,
     dimensions: usize,
     shingle_size: usize,
     capacity: usize,
     store: Vec<f32>,
+    labels: HashMap<usize,(Label,usize)>,
+    attribute_reverse_map: HashMap<Attributes,usize>,
+    attributes: Vec<Attributes>,
+    label_shingle: Vec<Label>,
     reference_count: Vec<u8>,
+    label_count: Vec<u8>,
+    attribute_count: Vec<u8>,
     location: Vec<L>,
     next_sequence_index: usize,
     start_free_region: usize,
     index_manager: IntervalStoreManager<usize>,
+    label_manager: IntervalStoreManager<usize>,
+    attribute_manager: IntervalStoreManager<usize>,
     hash_reference_counts: HashMap<usize, usize>,
-    entries_seen: i32,
+    hash_label_counts: HashMap<usize, usize>,
+    hash_attribute_counts: HashMap<usize, usize>,
+    entries_seen: u64,
+    attribute_creator: fn(_label_shingle: &[Label], _current_label : Label) -> Result<Attributes>,
+    attribute_to_vec: Option<fn( _attribute :&Attributes) -> Result<Vec<f32>>>
 }
 
-impl<L> VectorizedPointStore<L>
+impl<L,Label,Attributes> VectorizedPointStore<L,Label,Attributes>
 where
     L: Location,
     usize: From<L>,
+    Label : Copy + Sync + Send,
+    Attributes: Copy + Sync + Hash + Eq + Send,
     <L as TryFrom<usize>>::Error: Debug,
 {
     pub fn new(
@@ -53,23 +82,42 @@ where
         initial_capacity: usize,
         internal_shingling: bool,
         internal_rotation: bool,
-    ) -> Self {
-        VectorizedPointStore {
+        store_attributes: bool,
+        propagate_attributes: bool,
+        attribute_creator: fn(_label_shingle: &[Label], _current_label : Label) -> Result<Attributes>,
+        attribute_to_vec: Option<fn( _attribute :&Attributes) -> Result<Vec<f32>>>
+    ) -> Result<Self> {
+        Ok(VectorizedPointStore {
             internal_shingling,
             internal_rotation,
+            store_labels: store_attributes,
+            store_attributes,
             dimensions,
             shingle_size,
             capacity,
             store: vec![0.0; initial_capacity * dimensions],
+            labels: HashMap::new(),
+            attribute_reverse_map: HashMap::new(),
             location: vec![L::MAX; initial_capacity],
             reference_count: vec![0; initial_capacity],
             start_free_region: 0,
             index_manager: IntervalStoreManager::<usize>::new(initial_capacity),
+            label_manager: IntervalStoreManager::<usize>::new(capacity),
+            attribute_manager: IntervalStoreManager::<usize>::new(capacity),
             last_known_shingle: vec![0.0; dimensions],
             hash_reference_counts: HashMap::new(),
+            hash_label_counts: HashMap::new(),
+            hash_attribute_counts: HashMap::new(),
             entries_seen: 0,
             next_sequence_index: 0,
-        }
+            attribute_count: Vec::new(),
+            label_count: Vec::new(),
+            label_shingle: Vec::new(),
+            attribute_creator,
+            attribute_to_vec,
+            propagate_attributes,
+            attributes: Vec::new()
+        })
     }
 
     fn ready_to_copy(&self, point: &[f32]) -> bool {
@@ -87,26 +135,49 @@ where
         }
         answer
     }
+
+    fn inc_helper(index : usize, reference_counts: &mut [u8], hashmap: &mut HashMap<usize,usize>) -> Result<()>{
+        check_argument(index < reference_counts.len(), "incorrect range of index at insert")?;
+        if reference_counts[index] == u8::MAX {
+            if let Some(a) = hashmap.remove(&index) {
+                hashmap.insert(index, a + 1);
+            } else {
+                hashmap.insert(index, 1);
+            }
+        } else {
+            reference_counts[index] += 1;
+        };
+        Ok(())
+    }
+
+    fn dec_helper(index : usize, reference_counts: &mut [u8], hashmap: &mut HashMap<usize,usize>) -> Result<()>{
+        check_argument(index < reference_counts.len(), "incorrect range of index at delete")?;
+        check_argument(reference_counts[index] != 0, "index not in use for delete")?;
+
+        if let Some(a) = hashmap.remove(&index) {
+            if a > 1 {
+                hashmap.insert(index, a - 1);
+            }
+        } else {
+            reference_counts[index] -= 1;
+        }
+        Ok(())
+    }
 }
 
-impl<L> PointStore for VectorizedPointStore<L>
+impl<L,Label,Attributes> PointStore<Label,Attributes> for VectorizedPointStore<L,Label,Attributes>
 where
     L: Location,
     usize: From<L>,
+    Label: Copy + Sync + Send,
+    Attributes : Copy + Sync + Eq + Hash + Send,
     <L as TryFrom<usize>>::Error: Debug,
 {
-    fn get_shingled_point(&self, point: &[f32]) -> Vec<f32> {
+    fn shingled_point(&self, point: &[f32]) -> Result<Vec<f32>> {
         let mut new_point = vec![0.0; self.dimensions];
         let base = self.dimensions / self.shingle_size;
         if point.len() == base && self.shingle_size > 1 {
-            if !self.internal_shingling {
-                println!(
-                    "The point must be '{}' floats long, got {} ",
-                    self.dimensions,
-                    point.len()
-                );
-                panic!();
-            }
+            check_argument(self.internal_shingling, "expecting input corresponding to internal shingling")?;
             if !self.internal_rotation {
                 for i in 0..(self.dimensions - base) {
                     new_point[i] = self.last_known_shingle[i + base];
@@ -123,41 +194,35 @@ where
                     new_point[offset + i] = point[i];
                 }
             }
-            return new_point;
-        } else if point.len() != self.dimensions {
-            println!(
-                "The point must be '{}' floats long, got {}",
-                self.dimensions,
-                point.len()
-            );
-            panic!();
+            return Ok(new_point);
+        } else {
+            check_argument(point.len() == self.dimensions, " expecting externally shingled input")?;
         }
         for i in 0..self.dimensions {
             new_point[i] = point[i];
         }
-        new_point
+        Ok(new_point)
     }
 
-    fn get_size(&self) -> usize {
+    fn size(&self) -> usize {
         self.store.len() * std::mem::size_of::<f32>()
             + self.location.len() * std::mem::size_of::<L>()
             + self.reference_count.len() * std::mem::size_of::<u8>()
             + self.index_manager.get_size()
-            + std::mem::size_of::<VectorizedPointStore<L>>()
+            + std::mem::size_of::<VectorizedPointStore<L,Label,Attributes>>()
     }
 
-    fn get_missing_indices(&self, look_ahead: usize, values: &[usize]) -> Vec<usize> {
+    fn missing_indices(&self, look_ahead: usize, values: &[usize]) -> Result<Vec<usize>> {
         if !self.internal_shingling {
-            assert!(
-                look_ahead == 0,
-                "look ahead is meaningless for external shingling"
-            );
-            return Vec::from(values);
+            for x in values {
+                check_argument(*x<self.dimensions, "incorrect input")?;
+            }
+            return Ok(Vec::from(values));
         }
         let mut answer = Vec::new();
         let base = self.dimensions / self.shingle_size;
         for i in 0..values.len() {
-            assert!(values[i] < base);
+            check_argument(values[i] < base, "incorrect input")?;
             if self.internal_rotation {
                 answer.push(
                     ((self.next_sequence_index + look_ahead) * base + values[i]) % self.dimensions,
@@ -166,18 +231,18 @@ where
                 answer.push(self.dimensions - base + values[i]);
             }
         }
-        answer
+        Ok(answer)
     }
 
-    fn get_next_indices(&self, look_ahead: usize) -> Vec<usize> {
+    fn next_indices(&self, look_ahead: usize) -> Result<Vec<usize>> {
         let base = self.dimensions / self.shingle_size;
         let vec: Vec<usize> = (0..base).collect();
-        self.get_missing_indices(look_ahead, &vec)
+        self.missing_indices(look_ahead, &vec)
     }
 
-    fn get_copy(&self, index: usize) -> Vec<f32> {
+    fn copy(&self, index: usize) -> Result<Vec<f32>> {
         let mut new_point = vec![0.0; self.dimensions];
-        let (reference, offset) = self.get_reference_and_offset(index);
+        let (reference, offset) = self.reference_and_offset(index)?;
         if self.internal_rotation {
             for i in 0..self.dimensions {
                 new_point[(i + offset) % self.dimensions] = reference[i];
@@ -187,63 +252,108 @@ where
                 new_point[i] = reference[i];
             }
         }
-        new_point
+        Ok(new_point)
     }
 
-    fn is_equal(&self, point: &[f32], index: usize) -> bool {
-        let (reference, offset) = self.get_reference_and_offset(index);
+    fn is_equal(&self, point: &[f32], index: usize) -> Result<bool> {
+        let (reference, offset) = self.reference_and_offset(index)?;
         if self.internal_rotation {
             for i in 0..self.dimensions {
                 if point[(i + offset) % self.dimensions] != reference[i] {
-                    return false;
+                    return Ok(false);
                 }
             }
-            return true;
+            return Ok(true);
         } else {
-            return point.eq(reference);
+            return Ok(point.eq(reference));
         }
     }
 
-    fn get_reference_and_offset(&self, index: usize) -> (&[f32], usize) {
+    fn reference_and_offset(&self, index: usize) -> Result<(&[f32], usize)> {
         let base = self.dimensions / self.shingle_size;
-        if self.reference_count[index] == 0 {
-            println!(" Index '{}' not in use", index);
-            panic!();
-        }
-        let locn: usize = self.location[index].try_into().unwrap(); // because of u32
+        check_argument(self.reference_count[index] != 0 , "index not in use")?;
+
+        let locn : usize = self.location[index].try_into().expect("corrupt state");
         let adj_locn = locn * base;
         let offset = if !self.internal_rotation {
             0
         } else {
             adj_locn % self.dimensions
         };
-        (&self.store[adj_locn..(adj_locn + self.dimensions)], offset)
+        Ok((&self.store[adj_locn..(adj_locn + self.dimensions)], offset))
     }
 
-    fn add(&mut self, point: &[f32]) -> usize {
+    fn entries_seen(&self) -> u64 {
+        self.entries_seen
+    }
+
+    fn add(&mut self, point: &[f32], label:Label) -> Result<(usize,usize,Option<Vec<f32>>)> {
         let base = self.dimensions / self.shingle_size;
         self.next_sequence_index += 1;
+
         if self.internal_shingling {
-            if point.len() != base {
-                println!("The point must be '{}' floats long", self.dimensions);
-                panic!();
-            }
+            check_argument(point.len() == base, "incorrect length")?;
             for i in 0..(self.dimensions - base) {
                 self.last_known_shingle[i] = self.last_known_shingle[i + base];
             }
             for i in 0..base {
                 self.last_known_shingle[self.dimensions - base + i] = point[i];
             }
+            if self.store_labels {
+                if self.next_sequence_index <= self.shingle_size {
+                    self.label_shingle.push(label);
+                } else {
+                    for i in 0..self.shingle_size - 1 {
+                        self.label_shingle[i] = self.label_shingle[i + 1];
+                    }
+                    self.label_shingle[self.shingle_size - 1] = label;
+                }
+            }
             if self.next_sequence_index < self.shingle_size {
-                return usize::MAX;
+                return Ok((usize::MAX,usize::MAX,None));
             }
-        } else if point.len() != self.dimensions {
-            println!("The point must be '{}' floats long", self.dimensions);
-            panic!();
+        } else {
+            check_argument(point.len() == self.dimensions, "incorrect lengths")?;
         }
 
+        let mut attrib_vec = None;
+        let attrib_pos = if self.store_attributes {
+            let new_attribute = (self.attribute_creator)(&self.label_shingle, label)?;
+            let a_pos = *self.attribute_reverse_map.get(&new_attribute).unwrap_or(&self.attributes.len());
+            let b_pos = if a_pos >= self.attributes.len() {
+                let y = self.attribute_manager.get()?;
+                self.attribute_reverse_map.insert(new_attribute, y);
+                y
+            } else {
+                a_pos
+            };
+            if b_pos == self.attribute_count.len() {
+                    self.attributes.push(new_attribute);
+                    self.attribute_count.push(1);
+            } else {
+                self.attributes[b_pos] = new_attribute;
+                Self::inc_helper(b_pos,&mut self.attribute_count,&mut self.hash_attribute_counts)?;
+            };
+            b_pos
+        } else {usize::MAX};
+
+        let label_pos = if self.store_labels {
+            let y = self.label_manager.get()?;
+            if y >= self.labels.len() {
+                check_argument(y == self.labels.len(), " incorrect behavior in labels")?;
+                self.labels.insert(y,(label,attrib_pos));
+                self.label_count.push(1);
+            } else {
+                check_argument(self.label_count[y] == 0, " incorrect state in label management")?;
+                self.labels.insert(y,(label,attrib_pos));
+                self.label_count[y] = 1;
+            };
+            y
+        } else {usize::MAX};
+
+
         if self.dimensions + self.start_free_region > self.store.len() {
-            self.compact();
+            self.compact()?;
             if self.dimensions + self.start_free_region > self.store.len() {
                 let mut new_size = self.store.len() + self.store.len() / 5;
                 if new_size > self.capacity * self.dimensions {
@@ -254,7 +364,7 @@ where
         }
 
         if self.index_manager.is_empty() {
-            assert!(self.reference_count.len() == self.location.len());
+            check_argument(self.reference_count.len() == self.location.len(), "incorrect state")?;
             let mut new_size = self.location.len() + self.location.len() / 5;
             if new_size > self.capacity {
                 new_size = self.capacity;
@@ -263,8 +373,8 @@ where
             self.reference_count.resize(new_size, 0);
             self.index_manager.change_capacity(new_size);
         }
-        let position: usize = self.index_manager.get();
-        assert!(self.reference_count[position] == 0);
+        let position: usize = self.index_manager.get()?;
+        check_argument(self.reference_count[position] == 0, "incorrect state")?;
         self.reference_count[position] = 1;
         let new_point: &[f32] = if self.internal_shingling {
             &self.last_known_shingle
@@ -277,7 +387,7 @@ where
             let mut index: usize = self.start_free_region;
             let extra = self.dimensions - base;
             let idx_value: usize = (index - extra) / base;
-            self.location[position] = idx_value.try_into().unwrap();
+            self.location[position] = idx_value.try_into().expect("incorrect range");
             for i in 0..base {
                 self.store[index] = new_point[extra + i];
                 index += 1;
@@ -286,66 +396,83 @@ where
         } else {
             let mut index: usize = self.start_free_region;
             let idx_value: usize = index / base;
-            self.location[position] = idx_value.try_into().unwrap();
+            self.location[position] = idx_value.try_into().expect("range error");
             for i in 0..self.dimensions {
                 self.store[index] = new_point[i];
                 index += 1;
             }
             self.start_free_region += self.dimensions;
         }
-        position
-    }
-
-    fn inc(&mut self, index: usize) {
-        if self.reference_count[index] == 0 {
-            println!(" Index '{}' not in use", index);
-            panic!();
-        } else if self.reference_count[index] == u8::MAX {
-            if let Some(a) = self.hash_reference_counts.remove(&index) {
-                self.hash_reference_counts.insert(index, a + 1);
-            } else {
-                self.hash_reference_counts.insert(index, 1);
-            }
+        if self.store_labels {
+            Ok((position, label_pos, attrib_vec))
         } else {
-            self.reference_count[index] += 1;
+            Ok((position,attrib_pos,attrib_vec))
         }
     }
 
-    fn dec(&mut self, index: usize) {
-        if self.reference_count[index] == 0 {
-            println!(" Index '{}' not in use", index);
-            panic!();
-        } else if let Some(a) = self.hash_reference_counts.remove(&index) {
-            if a > 1 {
-                self.hash_reference_counts.insert(index, a - 1);
+    fn inc(&mut self, index: usize, secondary_index: usize) -> Result<()>{
+        Self::inc_helper(index,&mut self.reference_count,&mut self.hash_reference_counts)?;
+        if self.store_labels {
+            let attrib_index = (*self.labels.get(&secondary_index).expect("not found")).1;
+            if attrib_index != usize::MAX {
+                Self::inc_helper(attrib_index,&mut self.attribute_count, &mut self.hash_attribute_counts)?;
             }
-        } else {
-            self.reference_count[index] -= 1;
+            Self::inc_helper(secondary_index, &mut self.label_count, &mut self.hash_label_counts)?;
+        } else if self.store_attributes {
+            Self::inc_helper(secondary_index,&mut self.attribute_count, &mut self.hash_attribute_counts)?;
         }
+        Ok(())
+    }
 
+    fn dec(&mut self, index: usize,secondary_index: usize) -> Result<()> {
+        Self::dec_helper(index,&mut self.reference_count,&mut self.hash_reference_counts)?;
         if self.reference_count[index] == 0 {
-            self.index_manager.release(index);
+            self.index_manager.release(index)?;
             self.location[index] = L::MAX;
         }
+        if self.store_labels {
+            let attribute_index = (*self.labels.get(&secondary_index).expect("not found")).1;
+            if attribute_index != usize::MAX {
+                Self::dec_helper(attribute_index,&mut self.attribute_count, &mut self.hash_attribute_counts)?;
+                if self.attribute_count[attribute_index] == 0 {
+                    self.attribute_manager.release(attribute_index)?;
+                }
+            }
+            Self::dec_helper(secondary_index, &mut self.label_count, &mut self.hash_label_counts)?;
+            if self.label_count[secondary_index] == 0 {
+                self.label_manager.release(secondary_index)?;
+            }
+        } else {
+            if secondary_index !=usize::MAX {
+                Self::dec_helper(secondary_index,&mut self.attribute_count, &mut self.hash_attribute_counts)?;
+                let x = self.attribute_reverse_map.remove(&self.attributes[secondary_index]).expect(" error in secondary");
+                check_argument(x == secondary_index, "attribute index accounting is incorrect")?;
+                if self.attribute_count[secondary_index] == 0 {
+                    self.attribute_manager.release(secondary_index)?;
+                }
+            }
+        }
+        Ok(())
     }
 
-    fn adjust_count(&mut self, result: &[(usize, usize)]) {
+    fn adjust_count(&mut self, result: &[((usize, usize),(usize,usize))]) -> Result<()> {
         for (insert, delete) in result {
-            if *insert != usize::MAX {
-                self.inc(*insert);
-                if *delete != usize::MAX {
-                    self.dec(*delete);
+            if (*insert).0 != usize::MAX {
+                self.inc((*insert).0,(*insert).1)?;
+                if (*delete).0 != usize::MAX {
+                    self.dec((*delete).0,(*delete).1)?;
                 }
             }
         }
+        Ok(())
     }
 
-    fn compact(&mut self) {
+    fn compact(&mut self) -> Result<()>{
         let base = self.dimensions / self.shingle_size;
         let mut reverse_reference: Vec<(usize, usize)> = Vec::new();
         for i in 0..self.location.len() {
             if self.location[i] != L::MAX {
-                reverse_reference.push((self.location[i].try_into().unwrap(), i));
+                reverse_reference.push((self.location[i].try_into().expect("range error"), i));
             }
         }
         reverse_reference.sort();
@@ -387,28 +514,68 @@ where
 
             for i in block_start..block_end {
                 self.store[fresh_start] = self.store[i];
-                assert!(
-                    !self.internal_rotation || fresh_start % self.dimensions == i % self.dimensions
-                );
+                check_argument(!self.internal_rotation || fresh_start % self.dimensions == i % self.dimensions, "corrupt state in compaction")?;
                 if j_static < end {
                     let locn: usize = reverse_reference[j_static].0;
                     if i == base * locn {
                         let new_idx: usize = reverse_reference[j_static].1;
-                        self.location[new_idx] = (fresh_start / base).try_into().unwrap();
+                        self.location[new_idx] = (fresh_start / base).try_into().expect("range error");
                         j_static += 1;
                     }
                 }
                 fresh_start += 1;
             }
 
-            if j_static != j_dynamic {
-                println!(
-                    "There is discrepancy in indices between '{}' versus '{}'",
-                    j_static, j_dynamic
-                );
-                panic!();
+            check_argument(j_static == j_dynamic, "There is discrepancy in indices")?;
+        }
+        self.start_free_region = fresh_start.try_into().expect("range error");
+        Ok(())
+    }
+
+    fn label(&self, index: usize) -> Result<Label> {
+        check_argument(self.store_labels && index < self.labels.len() && self.label_count[index] != 0, " cannot access the label")?;
+        let (label,attribute_index) = *self.labels.get(&index).expect("unexpected index");
+        Ok(label)
+    }
+
+    fn attribute(&self, index: usize) -> Result<Attributes> {
+        check_argument(self.store_attributes, " attributes not stored")?;
+        if self.store_labels {
+            let y = *self.labels.get(&index).expect("label not in use");
+            check_argument(y.1<self.attributes.len()," not in use")?;
+            Ok(self.attributes[y.1])
+        } else {
+            check_argument(index<self.attributes.len()," not in use")?;
+            Ok(self.attributes[index])
+        }
+    }
+
+    fn point_sum(&self, list:&[(usize,usize)]) -> Result<Vec<f32>> {
+        let mut answer = vec![0.0; self.dimensions];
+        for (a,b) in list {
+            let (point, offset) = self.reference_and_offset(*a)?;
+            for (x,&y) in answer.iter_mut().zip(point) {
+                *x += y * (*b) as f32;
             }
         }
-        self.start_free_region = fresh_start.try_into().unwrap();
+        Ok(answer)
+    }
+
+    fn attribute_vec(&self, index: usize) -> Result<Vec<f32>> {
+        check_argument(self.store_attributes, " need to store attributes first")?;
+        let y = if self.store_labels {
+            let x = *self.labels.get(&index).expect("label not in use");
+            x.1
+        } else {
+            index
+        };
+        if let Some(function) = self.attribute_to_vec {
+            check_argument(index < self.attributes.len(), " out of range")?;
+            (function) (&self.attributes[index])
+        } else {
+            let mut answer = vec![0.0f32; MAX_ATTRIBUTES];
+            answer[y % MAX_ATTRIBUTES] = 1.0;
+            Ok(answer)
+        }
     }
 }
diff --git a/Rust/src/rcf.rs b/Rust/src/rcf.rs
index 81281e26..121f4a32 100644
--- a/Rust/src/rcf.rs
+++ b/Rust/src/rcf.rs
@@ -3,8 +3,10 @@ extern crate rand;
 extern crate rand_chacha;
 
 use core::fmt::Debug;
+use std::collections::HashMap;
+use std::hash::Hash;
 
-use rand::SeedableRng;
+use rand::{Rng, SeedableRng};
 use rand_chacha::ChaCha20Rng;
 use rand_core::RngCore;
 use rayon::prelude::*;
@@ -17,7 +19,7 @@ use crate::{
     l1distance,
     pointstore::{PointStore, VectorizedPointStore},
     samplerplustree::{
-        nodestore::VectorNodeStore, nodeview::UpdatableNodeView, samplerplustree::SamplerPlusTree,
+        nodeview::UpdatableNodeView, samplerplustree::SamplerPlusTree,
     },
     types::{Location, Result},
     util::{add_nbr, add_to, check_argument, divide, nbr_finish},
@@ -30,6 +32,8 @@ use crate::{
     },
 };
 use crate::common::rangevector::RangeVector;
+use crate::errors::RCFError;
+use crate::errors::RCFError::InvalidArgument;
 
 pub(crate) fn score_seen(x: usize, y: usize) -> f64 {
     1.0 / (x as f64 + f64::log2(1.0 + y as f64))
@@ -68,16 +72,17 @@ pub(crate) fn identity(x: f64, _y: usize) -> f64 {
     x
 }
 
-pub trait RCF {
-    fn update(&mut self, point: &[f32], timestamp: u64) -> Result<()>;
-
+pub trait AugmentedRCF<Label,Attributes> {
+    fn update(&mut self, point: &[f32], label: Label) -> Result<()>;
+    fn id(&self) -> u64;
     fn dimensions(&self) -> usize;
     fn shingle_size(&self) -> usize;
     fn is_internal_shingling_enabled(&self) -> bool;
+    fn is_output_ready(&self) -> bool;
     fn entries_seen(&self) -> u64;
     fn size(&self) -> usize;
     fn point_store_size(&self) -> usize;
-    fn shingled_point(&self,point:&[f32]) -> Vec<f32>;
+    fn shingled_point(&self,point:&[f32]) -> Result<Vec<f32>>;
 
     fn score(&self, point: &[f32]) -> Result<f64> {
         self.score_visitor_traversal(point, &VisitorInfo::default())
@@ -130,13 +135,13 @@ pub trait RCF {
     ) -> Result<DiVector>;
 
     fn density(&self, point: &[f32]) -> Result<f64> {
-        self.interpolation_visitor_traversal(point, &VisitorInfo::density())
-            .map(|meas| meas.density())
+        self.interpolation_visitor_traversal(point, &VisitorInfo::density())?
+            .density()
     }
 
     fn directional_density(&self, point: &[f32]) -> Result<DiVector> {
-        self.interpolation_visitor_traversal(point, &VisitorInfo::density())
-            .map(|meas| meas.directional_density())
+        self.interpolation_visitor_traversal(point, &VisitorInfo::density())?
+            .directional_density()
     }
 
     fn density_interpolant(&self, point: &[f32]) -> Result<InterpolationMeasure> {
@@ -166,12 +171,12 @@ pub trait RCF {
     ) -> Result<Vec<(f64, Vec<f32>, f64)>>;
 
     fn impute_missing_values(&self, positions: &[usize], point: &[f32]) -> Result<Vec<f32>> {
-        assert!(positions.len() > 0, "nothing to impute");
+        check_argument(positions.len() > 0, "nothing to impute")?;
         self.conditional_field(positions, point, 1.0, true, 0)
             .map(|summary| summary.median)
     }
 
-    fn extrapolate(&self, look_ahead: usize) -> Result<RangeVector>;
+    fn extrapolate(&self, look_ahead: usize) -> Result<RangeVector<f32>>;
 
     fn conditional_field(
         &self,
@@ -201,20 +206,30 @@ pub trait RCF {
         visitor_info: &VisitorInfo,
     ) -> Result<SampleSummary>;
 
-    // to be extended to match Java version
 }
 
-pub struct RCFStruct<C, L, P, N>
+//pub trait LabeledRCF<Update> : AugmentedRCF<Update,u64> {}
+//impl<Update: Sync + Copy + Send, U> LabeledRCF<Update> for U where U : AugmentedRCF<Update,u64> {}
+
+
+pub trait RCF : AugmentedRCF<u64,u64> + Send + Sync {}
+impl<U> RCF for U where U : AugmentedRCF<u64,u64> + Send + Sync {}
+
+
+pub struct RCFStruct<C, L, P, N, Label,Attributes>
 where
     C: Location,
     usize: From<C>,
     L: Location,
     usize: From<L>,
-    P: Location,
+    P: Location + Eq + Hash,
     usize: From<P>,
     N: Location,
     usize: From<N>,
+    Label: Copy + Sync + Send,
+    Attributes : Copy + Sync+ Hash + Eq + Send,
 {
+    id : u64,
     dimensions: usize,
     capacity: usize,
     number_of_trees: usize,
@@ -225,41 +240,42 @@ where
     internal_shingling: bool,
     internal_rotation: bool,
     store_attributes: bool,
+    propagate_attributes: bool,
     initial_accept_fraction: f64,
     bounding_box_cache_fraction: f64,
     parallel_enabled: bool,
     random_seed: u64,
     output_after: usize,
-    point_store: VectorizedPointStore<L>,
+    point_store: VectorizedPointStore<L,Label,Attributes>,
 }
 
-pub type RCFTiny = RCFStruct<u8, u16, u16, u8>; // sampleSize <= 256 for these and shingleSize * { max { base_dimensions, (number_of_trees + 1) } <= 256
-pub type RCFSmall = RCFStruct<u8, usize, u16, u8>; // sampleSize <= 256 and (number_of_trees + 1) <= 256 and dimensions = shingle_size*base_dimensions <= 256
-pub type RCFMedium = RCFStruct<u16, usize, usize, u16>; // sampleSize, dimensions <= u16::MAX
-pub type RCFLarge = RCFStruct<usize, usize, usize, usize>; // as large as the machine would allow
-
-impl<C, L, P, N> RCFStruct<C, L, P, N>
+impl<C, L, P, N, Label, Attributes> RCFStruct<C, L, P, N, Label, Attributes>
 where
     C: Location,
     usize: From<C>,
     L: Location,
     usize: From<L>,
-    P: Location,
+    P: Location + Eq + Hash,
     usize: From<P>,
     N: Location,
     usize: From<N>,
+    Label: Copy + Sync + Send,
+    Attributes : Copy + Sync + Eq + Hash + Send,
     <C as TryFrom<usize>>::Error: Debug,
     <L as TryFrom<usize>>::Error: Debug,
     <P as TryFrom<usize>>::Error: Debug,
     <N as TryFrom<usize>>::Error: Debug,
 {
     pub fn new(
+        id : u64,
         dimensions: usize,
         shingle_size: usize,
         capacity: usize,
         number_of_trees: usize,
         random_seed: u64,
         store_attributes: bool,
+        store_pointsum: bool,
+        propagate_attributes : bool,
         parallel_enabled: bool,
         internal_shingling: bool,
         internal_rotation: bool,
@@ -267,20 +283,17 @@ where
         initial_accept_fraction: f64,
         bounding_box_cache_fraction: f64,
         output_after: usize,
-    ) -> Self {
-        let mut point_store_capacity: usize = (capacity * number_of_trees + 1).try_into().unwrap();
+        attribute_creator : fn(&[Label], Label) -> Result<Attributes>,
+        attribute_to_vec : Option<fn(&Attributes) -> Result<Vec<f32>>>
+    ) -> Result<Self> {
+        let mut point_store_capacity= capacity * number_of_trees + 1;
         if point_store_capacity < 2 * capacity {
             point_store_capacity = 2 * capacity;
         }
         let initial_capacity = 2 * capacity;
-        if shingle_size != 1 && dimensions % shingle_size != 0 {
-            println!("Shingle size must divide dimensions.");
-            panic!();
-        }
-        assert!(
-            !internal_rotation || internal_shingling,
-            " internal shingling required for rotations"
-        );
+        check_argument(shingle_size==1 || dimensions % shingle_size == 0, "Shingle size must divide dimensions")?;
+        check_argument(!internal_rotation || internal_shingling,
+            " internal shingling required for rotations")?;
         let mut rng = ChaCha20Rng::seed_from_u64(random_seed);
         let _new_random_seed = rng.next_u64();
         let mut models: Vec<SamplerPlusTree<C, P, N>> = Vec::new();
@@ -292,12 +305,15 @@ where
                 using_transforms,
                 rng.next_u64(),
                 store_attributes,
+                store_pointsum,
+                propagate_attributes,
                 time_decay,
                 initial_accept_fraction,
                 bounding_box_cache_fraction,
-            ));
+            )?);
         }
-        RCFStruct {
+        Ok(RCFStruct {
+            id,
             random_seed,
             dimensions,
             capacity,
@@ -310,18 +326,23 @@ where
             initial_accept_fraction,
             bounding_box_cache_fraction,
             parallel_enabled,
-            point_store: VectorizedPointStore::<L>::new(
+            point_store: VectorizedPointStore::<L,Label,Attributes>::new(
                 dimensions.into(),
                 shingle_size.into(),
                 point_store_capacity,
                 initial_capacity,
                 internal_shingling,
                 internal_rotation,
-            ),
+                store_attributes,
+                propagate_attributes,
+                attribute_creator,
+                attribute_to_vec
+            )?,
             internal_shingling,
             internal_rotation,
-            output_after
-        }
+            output_after,
+            propagate_attributes
+        })
     }
 
     pub fn generic_conditional_field_point_list_and_distances(
@@ -330,8 +351,8 @@ where
         point: &[f32],
         centrality: f64,
         visitor_info: &VisitorInfo,
-    ) -> Vec<(f64, usize, f64)> {
-        let new_point = self.point_store.get_shingled_point(point);
+    ) -> Result<Vec<(f64, usize, f64)>> {
+        let new_point = self.point_store.shingled_point(point)?;
         let mut list: Vec<(f64, usize, f64)> = if self.parallel_enabled {
             self.sampler_plus_trees
                 .par_iter()
@@ -344,7 +365,7 @@ where
                         visitor_info,
                     )
                 })
-                .collect()
+                .collect::<Result<Vec<(f64, usize, f64)>>>()?
         } else {
             self.sampler_plus_trees
                 .iter()
@@ -357,10 +378,10 @@ where
                         visitor_info,
                     )
                 })
-                .collect()
+                .collect::<Result<Vec<(f64, usize, f64)>>>()?
         };
-        list.sort_by(|&o1, &o2| o1.2.partial_cmp(&o2.2).unwrap());
-        list
+        list.sort_by(|&o1, &o2| o1.2.partial_cmp(&o2.2).expect("should be total order"));
+        Ok(list)
     }
 
     pub fn simple_traversal<NodeView, V, R, S>(
@@ -375,9 +396,9 @@ where
         finish: fn(&mut S, usize),
     ) -> Result<S>
     where
-        NodeView: UpdatableNodeView<VectorNodeStore<C, P, N>, VectorizedPointStore<L>>,
+        NodeView: UpdatableNodeView<Label,Attributes>,
         V: Visitor<NodeView, R>,
-        R: Clone + std::marker::Send + std::marker::Sync,
+        R: Clone + Send + Sync,
         S: Clone,
     {
         check_argument(
@@ -386,11 +407,10 @@ where
         )?;
 
         let mut answer = initial.clone();
-        let new_point = self.point_store.get_shingled_point(point);
+        let new_point = self.point_store.shingled_point(point)?;
 
-        if self.parallel_enabled {
-            let list: Vec<R> = self
-                .sampler_plus_trees
+        let list: Vec<R> = if self.parallel_enabled {
+             self.sampler_plus_trees
                 .par_iter()
                 .map(|m| {
                     //m.generic_visitor_traversal(
@@ -403,11 +423,7 @@ where
                         default,
                     )
                 })
-                .collect();
-            // given the overhead of parallelism, it seems appropriate to collect()
-            // the below transformation is single threaded and the same function can be used
-            // as is used in the single threaded case
-            list.iter().for_each(|m| (collect_to)(m, &mut answer));
+                .collect::<Result<Vec<R>>>()?
         } else {
             self.sampler_plus_trees
                 .iter()
@@ -420,14 +436,15 @@ where
                         visitor_factory,
                         default,
                     )
-                })
-                .for_each(|m| collect_to(&m, &mut answer));
-        }
+                }).collect::<Result<Vec<R>>>()?
+        };
+        list.iter().for_each(|m| (collect_to)(m, &mut answer));
         (finish)(&mut answer, self.sampler_plus_trees.len());
         Ok(answer)
     }
 }
 
+#[deprecated]
 pub fn create_rcf(
     dimensions: usize,
     shingle_size: usize,
@@ -441,112 +458,62 @@ pub fn create_rcf(
     time_decay: f64,
     initial_accept_fraction: f64,
     bounding_box_cache_fraction: f64
-) -> Box<dyn RCF> {
-    if (dimensions < u8::MAX as usize) && (capacity - 1 <= u8::MAX as usize) {
-        if capacity * (1 + number_of_trees) * shingle_size <= u16::MAX as usize {
-            Box::new(RCFTiny::new(
-                dimensions,
-                shingle_size,
-                capacity,
-                number_of_trees,
-                random_seed,
-                store_attributes,
-                parallel_enabled,
-                internal_shingling,
-                internal_rotation,
-                time_decay,
-                initial_accept_fraction,
-                bounding_box_cache_fraction,
-                capacity/4
-            ))
-        } else {
-            Box::new(RCFSmall::new(
-                dimensions,
-                shingle_size,
-                capacity,
-                number_of_trees,
-                random_seed,
-                store_attributes,
-                parallel_enabled,
-                internal_shingling,
-                internal_rotation,
-                time_decay,
-                initial_accept_fraction,
-                bounding_box_cache_fraction,
-                capacity/4
-            ))
-        }
-    } else if (dimensions < u16::MAX as usize) && (capacity - 1 <= u16::MAX as usize) {
-        Box::new(RCFMedium::new(
-            dimensions,
-            shingle_size,
-            capacity,
-            number_of_trees,
-            random_seed,
-            store_attributes,
-            parallel_enabled,
-            internal_shingling,
-            internal_rotation,
-            time_decay,
-            initial_accept_fraction,
-            bounding_box_cache_fraction,
-            capacity/4
-        ))
-    } else {
-        Box::new(RCFLarge::new(
-            dimensions,
-            shingle_size,
-            capacity,
-            number_of_trees,
-            random_seed,
-            store_attributes,
-            parallel_enabled,
-            internal_shingling,
-            internal_rotation,
-            time_decay,
-            initial_accept_fraction,
-            bounding_box_cache_fraction,
-            capacity/4
-        ))
-    }
+) -> Box<dyn RCF + Sync + Send> {
+    RCFBuilder::<u64,u64>::new(dimensions/shingle_size,shingle_size)
+        .tree_capacity(capacity)
+        .number_of_trees(number_of_trees)
+        .random_seed(random_seed)
+        .store_attributes(store_attributes)
+        .parallel_enabled(parallel_enabled)
+        .internal_shingling(internal_shingling)
+        .internal_rotation(internal_rotation)
+        .time_decay(time_decay)
+        .initial_accept_fraction(initial_accept_fraction)
+        .bounding_box_cache_fraction(bounding_box_cache_fraction)
+        .build_default().unwrap() //unwrap kept for deprecated function
 }
 
-impl<C, L, P, N> RCF for RCFStruct<C, L, P, N>
+impl<C, L, P, N,Label,Attributes> AugmentedRCF<Label,Attributes> for RCFStruct<C, L, P, N,Label, Attributes>
 where
     C: Location,
     usize: From<C>,
     L: Location,
     usize: From<L>,
-    P: Location,
+    P: Location + Eq + Hash,
     usize: From<P>,
     N: Location,
     usize: From<N>,
+    Label: Copy + Sync + Send,
+    Attributes : Copy + Sync+ Hash + Eq + Send,
     <C as TryFrom<usize>>::Error: Debug,
     <L as TryFrom<usize>>::Error: Debug,
     <P as TryFrom<usize>>::Error: Debug,
     <N as TryFrom<usize>>::Error: Debug,
 {
-    fn shingled_point(&self,point:&[f32]) -> Vec<f32> {
-        assert!(self.is_internal_shingling_enabled(), " incorrect function call");
-        self.point_store.get_shingled_point(point)
+    fn shingled_point(&self,point:&[f32]) -> Result<Vec<f32>> {
+        self.point_store.shingled_point(point)
     }
 
-    fn update(&mut self, point: &[f32], _timestamp: u64) -> Result<()> {
-        let point_index = self.point_store.add(&point);
+    fn id(&self) -> u64 {
+        self.id
+    }
+
+    fn update(&mut self, point: &[f32], label : Label) -> Result<()> {
+        let (point_index,point_attribute,vector) = self.point_store.add(&point,label)?;
         if point_index != usize::MAX {
-            let result: Vec<(usize, usize)> = if self.parallel_enabled {
+            let result: Vec<((usize, usize),(usize,usize))> = if self.parallel_enabled {
                 self.sampler_plus_trees
                     .par_iter_mut()
-                    .map(|m| m.update(point_index, usize::MAX, &self.point_store))
-                    .collect()
+                    .map(|m| m.update(point_index, point_attribute, &self.point_store))
+                    .collect::<Result<Vec<((usize, usize), (usize, usize))>>>()?
             } else {
-                self.sampler_plus_trees
-                    .iter_mut()
-                    .map(|m| m.update(point_index, usize::MAX, &self.point_store))
-                    .collect()
+                    self.sampler_plus_trees
+                        .iter_mut()
+                        .map(|m| m.update(point_index, point_attribute, &self.point_store))
+                        .collect::<Result<Vec<((usize,usize),(usize,usize))>>>()?
             };
-            self.point_store.adjust_count(&result);
-            self.point_store.dec(point_index);
+            self.point_store.adjust_count(&result)?;
+            self.point_store.dec(point_index,point_attribute)?;
             self.entries_seen += 1;
         }
         Ok(())
@@ -564,6 +531,10 @@ where
         self.internal_shingling
     }
 
+    fn is_output_ready(&self) -> bool {
+        ((self.output_after + if self.is_internal_shingling_enabled() {self.shingle_size - 1} else {0}) as u64) < self.entries_seen
+    }
+
     fn entries_seen(&self) -> u64 {
         self.entries_seen
     }
@@ -646,7 +617,7 @@ where
         )?;
         let mut answer = Vec::new();
         for e in list.iter() {
-            answer.push((e.0, self.point_store.get_copy(e.1), e.2));
+            answer.push((e.0, self.point_store.copy(e.1)?, e.2));
         }
         Ok(answer)
     }
@@ -668,7 +639,7 @@ where
             Vec::from(positions)
         } else {
             // internal shingling
-            self.point_store.get_missing_indices(0, positions)
+            self.point_store.missing_indices(0, positions)?
         };
 
         let raw_list = self.generic_conditional_field_point_list_and_distances(
@@ -676,12 +647,12 @@ where
             point,
             centrality,
             visitor_info,
-        );
+        )?;
         let field_summarizer = FieldSummarizer::new(centrality, project, max_number, l1distance);
-        Ok(field_summarizer.summarize_list(&self.point_store, &raw_list, &new_positions))
+        field_summarizer.summarize_list(&self.point_store, &raw_list, &new_positions)
     }
 
-    fn extrapolate(&self, look_ahead: usize) -> Result<RangeVector> {
+    fn extrapolate(&self, look_ahead: usize) -> Result<RangeVector<f32>> {
         check_argument(
             self.internal_shingling,
             "look ahead is not meaningful without internal shingling mechanism",
@@ -694,11 +665,11 @@ where
         let mut upper = Vec::new();
         let mut lower = Vec::new();
         let base = self.dimensions / self.shingle_size;
-        let mut fictitious_point = self.point_store.get_shingled_point(&vec![0.0f32; base]);
+        let mut fictitious_point = self.point_store.shingled_point(&vec![0.0f32; base])?;
         for i in 0..look_ahead {
-            let missing = self.point_store.get_next_indices(i);
-            assert!(missing.len() == base, "incorrect imputation");
-            let iterate = self.conditional_field(&missing, &fictitious_point, 1.0, true, 0).unwrap();
+            let missing = self.point_store.next_indices(i)?;
+            check_argument(missing.len() == base, "incorrect imputation")?;
+            let iterate = self.conditional_field(&missing, &fictitious_point, 1.0, true, 0)?;
             for j in 0..base {
                 values.push(iterate.median[j]);
                 lower.push(iterate.lower[j]);
@@ -706,7 +677,7 @@ where
                 fictitious_point[missing[j]] = values[j];
             }
         }
-        Ok(RangeVector::create(&values,&upper,&lower))
+        RangeVector::create(&values,&upper,&lower)
     }
 
     fn size(&self) -> usize {
@@ -714,10 +685,394 @@ where
         for model in &self.sampler_plus_trees {
             sum += model.get_size();
         }
-        sum + self.point_store.get_size() + std::mem::size_of::<RCFStruct<C, L, P, N>>()
+        sum + self.point_store.size() + std::mem::size_of::<RCFStruct<C, L, P, N,Label,Attributes>>()
     }
 
     fn point_store_size(&self) -> usize {
-        self.point_store.get_size()
+        self.point_store.size()
+    }
+}
+
+
+
+pub type RCFTiny<Update,Operate> = RCFStruct<u8, u16, u16, u8,Update,Operate>; // sampleSize <= 256 for these and shingleSize * { max { base_dimensions, (number_of_trees + 1) } <= 256
+pub type RCFSmall<Update,Operate> = RCFStruct<u8, usize, u16, u8,Update,Operate>; // sampleSize <= 256 and (number_of_trees + 1) <= 256 and dimensions = shingle_size*base_dimensions <= 256
+pub type RCFMedium<Update,Operate> = RCFStruct<u16, usize, usize, u16,Update,Operate>; // sampleSize, dimensions <= u16::MAX
+pub type RCFLarge<Update,Operate> = RCFStruct<usize, usize, usize, usize,Update,Operate>; // as large as the machine would allow
+
+pub fn copy_label_as_attribute<Label>(_x: &[Label],y:Label) -> Result<Label> {
+    Ok(y)
+}
+
+pub struct RCFBuilder<Label : Send + Sync + Copy + 'static, Attributes : Send + Sync + Copy + Eq + Hash + 'static> {
+    input_dimensions: usize,
+    shingle_size: usize,
+    pub(crate) rcf_options : RCFOptions<Label,Attributes>,
+}
+
+
+impl<Label : Send + Sync + Copy + 'static, Attributes : Send + Sync + Copy + Eq + Hash + 'static> RCFBuilder<Label,Attributes> {
+    pub fn new(input_dimensions: usize, shingle_size: usize) -> Self {
+        RCFBuilder {input_dimensions, shingle_size, rcf_options: RCFOptions::default()}
+    }
+
+    pub fn validate(&self) -> Result<()> {
+        check_argument( self.input_dimensions > 0, "input_dimensions cannot be 0")?;
+        check_argument( self.shingle_size > 0, "shingle size cannot be 0")?;
+        self.rcf_options.validate()?;
+        Ok(())
+    }
+
+    // coresion reasons
+    pub fn build_default(&self) -> Result<Box<dyn RCF + Sync + Send>> {
+        check_argument(self.rcf_options.attribute_to_vec.is_none(), "remove function options for default")?;
+        check_argument(self.rcf_options.attribute_creator.is_none(), "remove function options fro default")?;
+
+        let x =self.build_tiny_simple::<u64>();
+        if x.is_ok() {
+            Ok(Box::new(x?))
+        } else {
+            let y = self.build_small_simple::<u64>();
+            if y.is_ok() {
+                Ok(Box::new(y?))
+            } else {
+                let z = self.build_medium_simple::<u64>();
+                if z.is_ok() {
+                    Ok(Box::new(z?))
+                } else {
+                    Ok(Box::new(self.build_large_simple::<u64>()?))
+                }
+            }
+        }
+    }
+
+    pub fn build_to_u64<Update: Send + Sync + Copy + 'static>(
+        &self,
+        attribute_creator : fn(&[Update],Update) -> Result<u64>
+    ) -> Result<Box<dyn AugmentedRCF<Update,u64> + Sync + Send>> {
+        let x =self.build_tiny::<Update,u64>(attribute_creator,None);
+        if x.is_ok() {
+            Ok(Box::new(x?))
+        } else {
+            let y = self.build_small::<Update,u64>(attribute_creator,None);
+            if y.is_ok() {
+                Ok(Box::new(y?))
+            } else {
+                let z = self.build_medium::<Update,u64>(attribute_creator, None);
+                if z.is_ok() {
+                    Ok(Box::new(z?))
+                } else {
+                    Ok(Box::new(self.build_large::<Update,u64>(attribute_creator,None)?))
+                }
+            }
+        }
+    }
+
+    pub fn build(&self) -> Result<Box<dyn AugmentedRCF<Label,Attributes> + Sync + Send + 'static>> {
+        check_argument(!self.rcf_options.store_attributes || self.rcf_options.attribute_creator.is_some(),
+                       "need an attribute_creator function to create the attributes")?;
+        let attribute_creator = self.rcf_options.attribute_creator.unwrap_or( |x,y |
+            {Err(RCFError::InvalidArgument {msg : "function not provided, should not be invoked"})});
+        let x =self.build_tiny::<Label,Attributes>(attribute_creator,self.rcf_options.attribute_to_vec);
+        if x.is_ok() {
+            Ok(Box::new(x?))
+        } else {
+            let y = self.build_small::<Label,Attributes>(attribute_creator,self.rcf_options.attribute_to_vec);
+            if y.is_ok() {
+                Ok(Box::new(y?))
+            } else {
+                let z = self.build_medium::<Label,Attributes>(attribute_creator, self.rcf_options.attribute_to_vec);
+                if z.is_ok() {
+                    Ok(Box::new(z?))
+                } else {
+                    Ok(Box::new(self.build_large::<Label,Attributes>(attribute_creator,self.rcf_options.attribute_to_vec)?))
+                }
+            }
+        }
+    }
+
+    pub fn build_tiny<Update: Send + Sync + Copy, Operate:  Send + Sync + Copy + Eq + Hash>(
+        &self,
+        attribute_creator : fn(&[Update],Update) -> Result<Operate>,
+        attribute_to_vec: Option<fn(&Operate) -> Result<Vec<f32>>>
+    ) -> Result<RCFTiny<Update,Operate>> {
+        self.validate()?;
+        let dimensions = self.input_dimensions * self.shingle_size;
+        let output_after = self.rcf_options.output_after.unwrap_or(1 + self.rcf_options.capacity / 4);
+        let time_decay = self.rcf_options.time_decay.unwrap_or(0.1/self.rcf_options.capacity as f64);
+        let random_seed = self.rcf_options.random_seed.unwrap_or( ChaCha20Rng::from_entropy().gen::<u64>());
+        check_argument(dimensions < (u8::MAX as usize) && (self.rcf_options.capacity - 1 <= u8::MAX as usize),"incorrect parameters")?;
+        check_argument(self.rcf_options.capacity * (1 + self.rcf_options.number_of_trees) * self.shingle_size <= u16::MAX as usize, " incorrect parameters")?;
+        Ok(RCFTiny::<Update,Operate>::new(
+            self.rcf_options.id,
+            dimensions,
+            self.shingle_size,
+            self.rcf_options.capacity,
+            self.rcf_options.number_of_trees,
+            random_seed,
+            self.rcf_options.store_attributes,
+            self.rcf_options.store_pointsum,
+            self.rcf_options.propagate_attributes,
+            self.rcf_options.parallel_enabled,
+            self.rcf_options.internal_shingling,
+            self.rcf_options.internal_rotation,
+            time_decay,
+            self.rcf_options.initial_accept_fraction,
+            self.rcf_options.bounding_box_cache_fraction,
+            output_after,
+            attribute_creator,
+            attribute_to_vec
+        )?)
+    }
+
+    pub fn build_tiny_simple<Operate: Send + Sync + Copy + Eq + Hash>(&self) -> Result<RCFTiny<Operate,Operate>> {
+        self.build_tiny(copy_label_as_attribute::<Operate>,None)
+    }
+
+    pub fn build_small<Update: Send + Sync + Copy, Operate:  Send + Sync + Copy + Eq + Hash>(
+        &self,
+        attribute_creator : fn(&[Update],Update) -> Result<Operate>,
+        attribute_to_vec: Option<fn(&Operate) -> Result<Vec<f32>>>
+    ) -> Result<RCFSmall<Update,Operate>> {
+        self.validate()?;
+        let dimensions = self.input_dimensions * self.shingle_size;
+        let output_after = self.rcf_options.output_after.unwrap_or(1 + self.rcf_options.capacity / 4);
+        let time_decay = self.rcf_options.time_decay.unwrap_or(0.1 / self.rcf_options.capacity as f64);
+        let random_seed = self.rcf_options.random_seed.unwrap_or(ChaCha20Rng::from_entropy().gen::<u64>());
+        check_argument(dimensions < (u8::MAX as usize) && (self.rcf_options.capacity - 1 <= u8::MAX as usize), "incorrect parameters")?;
+        Ok(RCFSmall::<Update,Operate>::new(
+            self.rcf_options.id,
+            dimensions,
+            self.shingle_size,
+            self.rcf_options.capacity,
+            self.rcf_options.number_of_trees,
+            random_seed,
+            self.rcf_options.store_attributes,
+            self.rcf_options.store_pointsum,
+            self.rcf_options.propagate_attributes,
+            self.rcf_options.parallel_enabled,
+            self.rcf_options.internal_shingling,
+            self.rcf_options.internal_rotation,
+            time_decay,
+            self.rcf_options.initial_accept_fraction,
+            self.rcf_options.bounding_box_cache_fraction,
+            output_after,
+            attribute_creator,
+            attribute_to_vec
+        )?)
+    }
+
+    pub fn build_small_simple<Operate: Send + Sync + Copy + Eq + Hash>(&self) -> Result<RCFSmall<Operate,Operate>> {
+        self.build_small(copy_label_as_attribute::<Operate>,None)
+    }
+
+    pub fn build_medium<Update: Send + Sync + Copy, Operate:  Send + Sync + Copy + Eq + Hash>(
+        &self,
+        attribute_creator : fn(&[Update],Update) -> Result<Operate>,
+        attribute_to_vec: Option<fn(&Operate) -> Result<Vec<f32>>>
+    ) -> Result<RCFMedium<Update,Operate>> {
+        self.validate()?;
+        let dimensions = self.input_dimensions * self.shingle_size;
+        let output_after = self.rcf_options.output_after.unwrap_or(1 + self.rcf_options.capacity / 4);
+        let time_decay = self.rcf_options.time_decay.unwrap_or(0.1 / self.rcf_options.capacity as f64);
+        let random_seed = self.rcf_options.random_seed.unwrap_or(ChaCha20Rng::from_entropy().gen::<u64>());
+        check_argument((dimensions < u16::MAX as usize) && (self.rcf_options.capacity - 1 <= u16::MAX as usize), " incorrect parameters")?;
+        Ok(RCFMedium::<Update,Operate>::new(
+            self.rcf_options.id,
+            dimensions,
+            self.shingle_size,
+            self.rcf_options.capacity,
+            self.rcf_options.number_of_trees,
+            random_seed,
+            self.rcf_options.store_attributes,
+            self.rcf_options.store_pointsum,
+            self.rcf_options.propagate_attributes,
+            self.rcf_options.parallel_enabled,
+            self.rcf_options.internal_shingling,
+            self.rcf_options.internal_rotation,
+            time_decay,
+            self.rcf_options.initial_accept_fraction,
+            self.rcf_options.bounding_box_cache_fraction,
+            output_after,
+            attribute_creator,
+            attribute_to_vec
+        )?)
+    }
+
+    pub fn build_medium_simple<Operate: Send + Sync + Copy + Eq + Hash>(&self) -> Result<RCFMedium<Operate,Operate>> {
+        self.build_medium(copy_label_as_attribute::<Operate>,None)
+    }
+
+    pub fn build_large<Update: Send + Sync + Copy, Operate:  Send + Sync + Copy + Eq + Hash>(
+        &self,
+        attribute_creator : fn(&[Update],Update) -> Result<Operate>,
+        attribute_to_vec: Option<fn(&Operate) -> Result<Vec<f32>>>
+    ) -> Result<RCFLarge<Update,Operate>> {
+        self.validate()?;
+        let dimensions = self.input_dimensions * self.shingle_size;
+        let output_after = self.rcf_options.output_after.unwrap_or(1 + self.rcf_options.capacity / 4);
+        let time_decay = self.rcf_options.time_decay.unwrap_or(0.1/self.rcf_options.capacity as f64);
+        let random_seed = self.rcf_options.random_seed.unwrap_or( ChaCha20Rng::from_entropy().gen::<u64>());
+        Ok(RCFLarge::<Update,Operate>::new(
+            self.rcf_options.id,
+            dimensions,
+            self.shingle_size,
+            self.rcf_options.capacity,
+            self.rcf_options.number_of_trees,
+            random_seed,
+            self.rcf_options.store_attributes,
+            self.rcf_options.store_pointsum,
+            self.rcf_options.propagate_attributes,
+            self.rcf_options.parallel_enabled,
+            self.rcf_options.internal_shingling,
+            self.rcf_options.internal_rotation,
+            time_decay,
+            self.rcf_options.initial_accept_fraction,
+            self.rcf_options.bounding_box_cache_fraction,
+            output_after,
+            attribute_creator,
+            attribute_to_vec
+        )?)
+    }
+
+    pub fn build_large_simple<Operate: Send + Sync + Copy + Eq + Hash>(&self) -> Result<RCFLarge<Operate,Operate>> {
+        self.build_large(copy_label_as_attribute::<Operate>,None)
+    }
+
+}
+
+pub struct RCFOptions<Label,Attributes> {
+    pub(crate) id: u64,
+    pub(crate) capacity: usize,
+    pub(crate) number_of_trees: usize,
+    pub(crate) time_decay: Option<f64>,
+    pub(crate) internal_shingling: bool,
+    pub(crate) internal_rotation: bool,
+    pub(crate) store_labels: bool,
+    pub(crate) store_attributes: bool,
+    pub(crate) propagate_attributes: bool,
+    pub(crate) store_pointsum: bool,
+    pub(crate) initial_accept_fraction: f64,
+    pub(crate) bounding_box_cache_fraction: f64,
+    pub(crate) parallel_enabled: bool,
+    pub(crate) random_seed: Option<u64>,
+    pub(crate) output_after: Option<usize>,
+    pub(crate) attribute_creator: Option<fn(&[Label],Label) -> Result<Attributes>>,
+    pub(crate) attribute_to_vec: Option<fn(&Attributes) -> Result<Vec<f32>>>
+}
+
+impl<Label : Send + Sync + Copy, Attributes : Send + Sync + Copy + Eq + Hash> RCFOptions<Label,Attributes> {
+    pub fn validate(&self) -> Result<()> {
+        check_argument(self.capacity > 0, "capacity cannot be 0")?;
+        check_argument( self.number_of_trees > 0, "number of trees cannot be 0")?;
+        check_argument(self.time_decay.unwrap_or(0.0)>=0.0, "time decay cannot be negative")?;
+        check_argument(self.bounding_box_cache_fraction >=0.0
+                           && self.bounding_box_cache_fraction <=1.0,
+                       "bounding box cache fraction is in [0,1]")?;
+        check_argument(!self.propagate_attributes || self.store_attributes,
+        "need to store attributes to propagate them")?;
+        check_argument(self.initial_accept_fraction > 0.0 && self.initial_accept_fraction <= 1.0,
+                       "initial accept fraction has to be in (0,1]")?;
+        Ok(())
+    }
+}
+
+impl<Label : Send + Sync + Copy, Attributes : Send + Sync + Copy + Eq + Hash> Default for RCFOptions<Label,Attributes> {
+    fn default() -> Self {
+        RCFOptions{
+            id : u64::MAX, // a default tag that this was not set
+            capacity: 256,
+            number_of_trees: 50,
+            time_decay: None,
+            internal_shingling: true,
+            internal_rotation: false,
+            store_labels: false,
+            store_attributes: false,
+            propagate_attributes: false,
+            initial_accept_fraction: 0.125,
+            bounding_box_cache_fraction: 1.0,
+            parallel_enabled: false,
+            store_pointsum : false,
+            random_seed: None,
+            output_after: None,
+            attribute_creator: Option::<fn( &[Label], Label) -> Result<Attributes>>::None,
+            attribute_to_vec: Option::<fn( &Attributes) -> Result<Vec<f32>>>::None
+        }
+    }
+}
+
+pub trait RCFOptionsBuilder<Label : Send + Sync + Copy, Attributes : Send + Sync + Copy + Eq + Hash> {
+    fn get_rcf_options(&mut self) -> &mut RCFOptions<Label,Attributes>;
+
+    fn id(&mut self,id:u64) -> &mut Self{
+        self.get_rcf_options().id = id;
+        self
+    }
+    fn parallel_enabled(&mut self,parallel_enabled: bool) -> &mut Self {
+        self.get_rcf_options().parallel_enabled = parallel_enabled;
+        self
+    }
+    fn output_after(&mut self,output_after: usize) -> &mut Self {
+        self.get_rcf_options().output_after = Some(output_after);
+        self
+    }
+    fn random_seed(&mut self,random_seed: u64) -> &mut Self {
+        self.get_rcf_options().random_seed = Some(random_seed);
+        self
+    }
+    fn internal_rotation(&mut self, internal_rotation: bool) -> &mut Self {
+        self.get_rcf_options().internal_rotation = internal_rotation;
+        self
+    }
+    fn internal_shingling(&mut self, internal_shingling: bool) -> &mut Self {
+        self.get_rcf_options().internal_shingling = internal_shingling;
+        self
+    }
+    fn propagate_attribute_vectors(&mut self, propagarate_attribute_vectors : bool) -> &mut Self {
+        self.get_rcf_options().propagate_attributes = propagarate_attribute_vectors;
+        self
+    }
+    fn store_pointsum(&mut self, store_pointsum : bool) -> &mut Self {
+        self.get_rcf_options().store_pointsum = store_pointsum;
+        self
+    }
+    fn store_attributes(&mut self, store_attributes : bool) -> &mut Self {
+        self.get_rcf_options().store_attributes = store_attributes;
+        self
+    }
+    fn initial_accept_fraction(&mut self, initial_accept_fraction : f64) -> &mut Self {
+        self.get_rcf_options().initial_accept_fraction = initial_accept_fraction;
+        self
+    }
+    fn bounding_box_cache_fraction(&mut self, bounding_box_cache_fraction : f64) -> &mut Self {
+        self.get_rcf_options().bounding_box_cache_fraction = bounding_box_cache_fraction;
+        self
+    }
+    fn tree_capacity(&mut self, capacity: usize) -> &mut Self {
+        self.get_rcf_options().capacity = capacity;
+        self
+    }
+
+    fn number_of_trees(&mut self, number_of_trees : usize) -> &mut Self {
+        self.get_rcf_options().number_of_trees = number_of_trees;
+        self
+    }
+    fn time_decay(&mut self, time_decay : f64) -> &mut Self{
+        self.get_rcf_options().time_decay = Some(time_decay);
+        self
+    }
+    fn attribute_creator(&mut self, function: fn( &[Label],Label) -> Result<Attributes>) -> &mut Self{
+        self.get_rcf_options().attribute_creator = Some(function);
+        self
+    }
+    fn attribute_to_vec(&mut self, function: fn( _attribute :&Attributes) -> Result<Vec<f32>>) -> &mut Self{
+        self.get_rcf_options().attribute_to_vec = Some(function);
+        self
+    }
+}
+
+impl<Label : Send + Sync + Copy, Attributes : Send + Sync + Copy + Eq + Hash> RCFOptionsBuilder<Label,Attributes> for RCFBuilder<Label,Attributes> {
+    fn get_rcf_options(&mut self) -> &mut RCFOptions<Label,Attributes> {
+        &mut self.rcf_options
     }
 }
diff --git a/Rust/src/samplerplustree/boundingbox.rs b/Rust/src/samplerplustree/boundingbox.rs
index 7dbac31e..3f113798 100644
--- a/Rust/src/samplerplustree/boundingbox.rs
+++ b/Rust/src/samplerplustree/boundingbox.rs
@@ -1,4 +1,8 @@
+use crate::util::check_argument;
+use crate::types::Result;
+
 #[repr(C)]
+#[derive(Clone)]
 pub struct BoundingBox {
     range_sum: f64,
     min_values: Vec<f32>,
@@ -6,8 +10,8 @@ pub struct BoundingBox {
 }
 
 impl BoundingBox {
-    pub fn new(first_values: &[f32], second_values: &[f32]) -> Self {
-        assert!(first_values.len() == second_values.len());
+    pub fn new(first_values: &[f32], second_values: &[f32]) -> Result<Self> {
+        check_argument(first_values.len() == second_values.len(), " mismatched lengths")?;
         let minv: Vec<f32> = first_values
             .iter()
             .zip(second_values)
@@ -20,11 +24,11 @@ impl BoundingBox {
             .collect();
 
         let sum = minv.iter().zip(&maxv).map(|(x, y)| (y - x) as f64).sum();
-        BoundingBox {
+        Ok(BoundingBox {
             min_values: minv,
             max_values: maxv,
             range_sum: sum,
-        }
+        })
     }
 
     pub fn check_contains_and_add_point(&mut self, values: &[f32]) -> bool {
@@ -51,9 +55,7 @@ impl BoundingBox {
             .zip(self.get_max_values())
             .map(|(x, y)| (y - x) as f64)
             .sum();
-        if old_sum > self.range_sum {
-            panic!();
-        }
+
         old_sum == self.range_sum
     }
 
@@ -61,10 +63,6 @@ impl BoundingBox {
         self.range_sum
     }
 
-    pub fn copy(&self) -> BoundingBox {
-        BoundingBox::new(&self.min_values, &self.max_values)
-    }
-
     pub fn get_min_values(&self) -> &[f32] {
         &self.min_values
     }
diff --git a/Rust/src/samplerplustree/cut.rs b/Rust/src/samplerplustree/cut.rs
index 6c12c3bc..84683073 100644
--- a/Rust/src/samplerplustree/cut.rs
+++ b/Rust/src/samplerplustree/cut.rs
@@ -1,4 +1,8 @@
+use rand::Rng;
+use rand_chacha::ChaCha20Rng;
+use rand_core::SeedableRng;
 use crate::samplerplustree::boundingbox::BoundingBox;
+use crate::util::{maxf32, minf32};
 
 /**
 *  this is a class that helps manage the cut information; the nodes do not store information in
@@ -15,6 +19,12 @@ impl Cut {
         Cut { dimension, value }
     }
 
+    // factor should be in [0,1) in the follwoing; but we would not rule that
+    // out so that use out-of-range values to test the function
+    // the only invariant we must satisfy is that:
+    // if the range_sum of the input bounding box is 0 (single point) and
+    // the point is not equal to the point defining the box then the cut must
+    // be nontrivial
     pub fn random_cut_and_separation(
         bounding_box: &BoundingBox,
         factor: f64,
@@ -22,6 +32,8 @@ impl Cut {
     ) -> (Cut, bool) {
         let min_values = bounding_box.get_min_values();
         let max_values = bounding_box.get_max_values();
+        let mut first_gap = point.len();
+        let mut last_gap = 0;
         let mut range: f64 = min_values
             .iter()
             .zip(max_values)
@@ -46,34 +58,71 @@ impl Cut {
         let mut new_cut: f32 = f32::MAX;
 
         while dim < point.len() {
-            let minv = if point[dim] < min_values[dim] {
-                point[dim]
-            } else {
-                min_values[dim]
-            };
-            let maxv = if point[dim] > max_values[dim] {
-                point[dim]
-            } else {
-                max_values[dim]
-            };
+            let minv = minf32(min_values[dim], point[dim]);
+            let maxv = maxf32(max_values[dim], point[dim]);
 
             let gap: f32 = maxv - minv;
-            if gap > range as f32 || (gap == range as f32 && gap > 0.0) {
-                new_cut = minv + range as f32; // precision lost here
-                if new_cut <= minv || new_cut >= maxv {
-                    new_cut = minv;
+
+            if gap > 0.0 {
+                last_gap = dim;
+                if first_gap == point.len() {
+                    first_gap = dim; // will not change subsequently
                 }
-                break;
+                let new_range = range - gap as f64;
+                if new_range <= 0.0 {
+                    new_cut = minv + range as f32; // precision lost here
+                    if new_cut <= minv || new_cut >= maxv {
+                        new_cut = minv;
+                    }
+                    break;
+                    // this implies that gap > 0; which means that there will be no issues
+                    // because either min == max both not equal to the point
+                    // or rangesum of the original box is not 0.0
+                }
+                range = new_range;
             }
-            range = range - gap as f64;
             dim += 1;
         }
 
-        let minvalue = min_values[dim];
-        let maxvalue = max_values[dim];
+        if dim != point.len() {
+            let minvalue = min_values[dim];
+            let maxvalue = max_values[dim];
+
+            let separation: bool = ((point[dim] <= new_cut) && (new_cut < minvalue))
+                || ((maxvalue <= new_cut) && (new_cut < point[dim]));
+
+            if bounding_box.get_range_sum() != 0.0 || separation {
+                return (Cut::new(dim.try_into().unwrap(), new_cut), separation);
+            };
+        };
+
+        let mut rng = ChaCha20Rng::seed_from_u64(17);//ChaCha20Rng::from_entropy();
+        let index = if rng.gen::<f32>() < 0.5 { first_gap } else { last_gap };
 
-        let separation: bool = ((point[dim] <= new_cut) && (new_cut < minvalue))
-            || ((maxvalue <= new_cut) && (new_cut < point[dim]));
-        (Cut::new(dim.try_into().unwrap(), new_cut), separation)
+        let new_cut = minf32(min_values[index], point[index]);
+        let separation: bool = ((point[index] == new_cut) && (new_cut < min_values[index]))
+            || ((min_values[index] == new_cut) && (new_cut < point[index]));
+        // note it is possible that range is positive due to max_value[index] == point[index]
+        // not being the same as min_value[index]; but that is not a problematic scenario
+        return (Cut::new(index.try_into().unwrap(), new_cut), separation);
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::samplerplustree::boundingbox::BoundingBox;
+    use crate::samplerplustree::cut::Cut;
+
+    #[test]
+    fn test_floating_point() {
+        let vec1 = vec![0.0001f32, 0.00001f32];
+        let vec2 = vec![0.0001f32, 0.000011f32];
+
+        // using unwrap in test
+        let b_box= BoundingBox::new(&vec1,&vec1).unwrap();
+        Cut::random_cut_and_separation(&b_box,2.0,&vec2); // exagegration
+        Cut::random_cut_and_separation(&b_box,-2.0,&vec2); // exaggeration
+        Cut::random_cut_and_separation(&b_box,1.0,&vec2); // should not happen
+        Cut::random_cut_and_separation(&b_box,0.0,&vec2); // can happen
+    }
+}
\ No newline at end of file
diff --git a/Rust/src/samplerplustree/nodestore.rs b/Rust/src/samplerplustree/nodestore.rs
index 41d990db..a2540ce8 100644
--- a/Rust/src/samplerplustree/nodestore.rs
+++ b/Rust/src/samplerplustree/nodestore.rs
@@ -1,4 +1,6 @@
 use std::{collections::HashMap, fmt::Debug, mem};
+use std::hash::Hash;
+use crate::types::Result;
 
 use crate::{
     common::{divector::DiVector, intervalstoremanager::IntervalStoreManager},
@@ -6,6 +8,8 @@ use crate::{
     samplerplustree::{boundingbox::BoundingBox, cut::Cut},
     types::Location,
 };
+use crate::errors::RCFError;
+use crate::util::check_argument;
 
 ///
 /// capacity is the number of leaves in the tree
@@ -27,7 +31,7 @@ pub struct VectorNodeStore<C, P, N>
 where
     C: Location,
     usize: From<C>,
-    P: Location,
+    P: Location + Eq + Hash + Send,
     usize: From<P>,
     N: Location,
     usize: From<N>,
@@ -46,77 +50,128 @@ where
     bounding_box_data: Vec<f32>,
     range_sum_data: Vec<f64>,
     hash_mass_leaves: HashMap<usize, usize>,
-    pub internal_node_manager: IntervalStoreManager<usize>,
+    internal_node_manager: IntervalStoreManager<usize>,
+    store_attributes: bool,
+    propagate_attributes: bool,
+    store_pointsum: bool,
+    pointsum : Vec<f32>,
+    attributes: HashMap<P,HashMap<P,N>>,
+    propagated_attributes: HashMap<N,Vec<f32>>
 }
 
 const SWITCH_THRESHOLD: f64 = 0.5;
 
-pub trait NodeStore {
-    fn get_mass(&self, index: usize) -> usize;
-    fn get_box(&self, index: usize, point_store: &dyn PointStore) -> BoundingBox;
-    fn get_probability_of_cut(
+pub trait NodeStore<Label: Sync + Copy, Attributes: Sync + Copy+ Hash + Eq + Send> : BasicStore + BoxStore<Label,Attributes> {}
+
+pub trait BasicStore {
+    fn mass(&self, index: usize) -> usize;
+    fn sibling(&self, node: usize, parent: usize) -> usize;
+    fn leaf_point_index(&self, index: usize) -> Result<usize>;
+    fn cut_dimension(&self, index: usize) -> usize;
+    fn left_index(&self, index: usize) -> usize;
+    fn right_index(&self, index: usize) -> usize;
+    fn cut_value(&self, index: usize) -> f32;
+    fn is_leaf(&self, index: usize) -> bool;
+    fn is_left_of(&self, index: usize, point: &[f32]) -> bool;
+    fn use_path_for_box(&self) -> bool;
+    fn distribution(&self, index: usize) -> (usize, f32, usize, usize);
+    fn cut_and_children(&self, index: usize) -> (usize, f32, usize, usize);
+    fn set_path(&self, answer: &mut Vec<(usize, usize)>, root: usize, point: &[f32]);
+    fn null_node(&self) -> usize;
+    fn attribute_at_leaf(&self,point_index: usize) -> Result<Vec<(usize,usize)>>;
+}
+
+pub trait BoxStore<Label: Sync + Copy, Attributes: Sync + Copy + Hash + Eq + Send> : BasicStore {
+    fn attribut_vec<PS: PointStore<Label, Attributes>>(&self, index: usize, point_store: &PS) -> Result<Vec<f32>>;
+    fn recompute_attribute_vec<PS: PointStore<Label, Attributes>>(&mut self, index: usize, point_store: &PS) -> Result<()>;
+    fn pointsum<PS: PointStore<Label, Attributes>>(&self, index: usize, point_store: &PS) -> Result<Vec<f32>>;
+    fn recompute_pointsum<PS: PointStore<Label, Attributes>>(&mut self, index: usize, point_store: &PS) -> Result<()>;
+    fn manage_ancestors_add<PS: PointStore<Label,Attributes>>(
+        &mut self,
+        path: &mut Vec<(usize, usize)>,
+        point: &[f32],
+        _point_store: &PS,
+        box_resolved: bool,
+    ) -> Result<()>;
+    fn manage_ancestors_delete<PS: PointStore<Label, Attributes>>(
+        &mut self,
+        path: &mut Vec<(usize, usize)>,
+        point: &[f32],
+        point_store: &PS,
+        box_resolved: bool,
+    ) -> Result<()>;
+    fn reconstruct_box<PS: PointStore<Label, Attributes>>(&self, index: usize, point_store: &PS) -> Result<BoundingBox>;
+    fn check_contains_and_rebuild_box<PS: PointStore<Label, Attributes>>(
+        &mut self,
+        index: usize,
+        point: &[f32],
+        point_store: &PS,
+    ) -> Result<bool>;
+    fn bounding_box<PS: PointStore<Label,Attributes>>(&self, index: usize, point_store: &PS) -> Result<BoundingBox>;
+    fn probability_of_cut<PS: PointStore<Label,Attributes>>(
         &self,
         index: usize,
         point: &[f32],
-        point_store: &dyn PointStore,
-    ) -> f64;
-    fn get_probability_of_cut_with_missing_coordinates(
+        point_store: &PS,
+    ) -> Result<f64>;
+    fn probability_of_cut_with_missing_coordinates<PS: PointStore<Label,Attributes>>(
         &self,
         index: usize,
         point: &[f32],
         missing_coordinates: &[bool],
-        point_store: &dyn PointStore,
-    ) -> f64;
-    fn modify_in_place_probability_of_cut_di_vector(
+        point_store: &PS,
+    ) -> Result<f64>;
+    fn modify_in_place_probability_of_cut_di_vector<PS: PointStore<Label,Attributes>>(
         &self,
         index: usize,
         point: &[f32],
-        point_store: &dyn PointStore,
+        point_store: &PS,
         di_vector: &mut DiVector,
-    );
-    fn modify_in_place_probability_of_cut_di_vector_with_missing_coordinates(
+    ) -> Result<()>;
+    fn modify_in_place_probability_of_cut_di_vector_with_missing_coordinates<PS: PointStore<Label,Attributes>>(
         &self,
         index: usize,
         point: &[f32],
         missing_coordinates: &[bool],
-        point_store: &dyn PointStore,
+        point_store: &PS,
         di_vector: &mut DiVector,
-    );
-    fn grow_node_box_pair(
+    ) -> Result<()>;
+    fn grow_node_box_pair<PS: PointStore<Label,Attributes>>(
         &self,
         first: &mut BoundingBox,
         second: &mut BoundingBox,
-        point_store: &dyn PointStore,
+        point_store: &PS,
         node: usize,
         sibling: usize,
-    );
-    fn grow_node_box(
+    ) -> Result<()>;
+    fn grow_node_box<PS: PointStore<Label,Attributes>>(
         &self,
         bounding_box: &mut BoundingBox,
-        point_store: &dyn PointStore,
+        point_store: &PS,
         node: usize,
         sibling: usize,
-    );
-    fn get_sibling(&self, node: usize, parent: usize) -> usize;
-    fn get_leaf_point_index(&self, index: usize) -> usize;
-    fn get_cut_dimension(&self, index: usize) -> usize;
-    fn get_left_index(&self, index: usize) -> usize;
-    fn get_right_index(&self, index: usize) -> usize;
-    fn get_cut_value(&self, index: usize) -> f32;
-    fn is_leaf(&self, index: usize) -> bool;
-    fn is_left_of(&self, index: usize, point: &[f32]) -> bool;
-    fn use_path_for_box(&self) -> bool;
-    fn get_distribution(&self, index: usize) -> (usize, f32, usize, usize);
-    fn get_cut_and_children(&self, index: usize) -> (usize, f32, usize, usize);
-    fn set_path(&self, answer: &mut Vec<(usize, usize)>, root: usize, point: &[f32]);
-    fn null_node(&self) -> usize;
+    ) -> Result<()>;
+    fn check_left<PS: PointStore<Label,Attributes>>(
+        &self,
+        index: usize,
+        dim: usize,
+        value: f32,
+        point_store: &PS
+    ) -> Result<bool>;
+    fn check_right<PS: PointStore<Label,Attributes>>(
+        &self,
+        index: usize,
+        dim: usize,
+        value: f32,
+        point_store: &PS
+    ) -> Result<bool>;
 }
 
 impl<C, P, N> VectorNodeStore<C, P, N>
 where
     C: Location,
     usize: From<C>,
-    P: Location,
+    P: Location+ Eq + Hash + Send,
     usize: From<P>,
     N: Location,
     usize: From<N>,
@@ -128,19 +183,22 @@ where
         capacity: usize,
         dimensions: usize,
         using_transforms: bool,
+        store_attributes: bool,
+        store_pointsum: bool,
+        propagate_attributes: bool,
         project_to_tree: fn(Vec<f32>) -> Vec<f32>,
         bounding_box_cache_fraction: f64,
-    ) -> Self {
-        if capacity - 1 > N::MAX.into() {
-            println!(
-                " invalid parameter, increase size of N to represent {}",
-                capacity
-            );
-            panic!();
-        }
+    ) -> Result<Self> {
+        check_argument( capacity - 1 <= N::MAX.into() ,
+                " invalid parameter, increase size of N to represent {}")?;
         let cache_limit: usize = (bounding_box_cache_fraction * capacity as f64) as usize;
         let null_node = Self::null_value(capacity);
-        VectorNodeStore {
+        let pointsum = if store_pointsum {
+            vec![0.0f32;(capacity - 1)*dimensions]
+        } else {
+            Vec::new()
+        };
+        Ok(VectorNodeStore {
             capacity,
             dimensions,
             using_transforms,
@@ -160,11 +218,63 @@ where
             range_sum_data: vec![0.0; cache_limit],
             hash_mass_leaves: HashMap::new(),
             internal_node_manager: IntervalStoreManager::<usize>::new(capacity - 1),
-        }
+            attributes: HashMap::new(),
+            store_attributes,
+            propagate_attributes: propagate_attributes,
+            store_pointsum,
+            pointsum,
+            propagated_attributes : HashMap::new()
+        })
     }
 
     /// 0 is indicative of null given unsigned representation
     /// otherwise index X uses slot X-1
+    pub fn invalidate_pointsum(&mut self,index: usize) -> Result<()>{
+        check_argument(self.store_pointsum, "incorrct invocation")?;
+        for x in self.pointsum[(index*self.dimensions).. ((index+1)*self.dimensions)].iter_mut() {
+            *x=0.0;
+        };
+        Ok(())
+    }
+
+    pub fn add_attrib_at_leaf(&mut self,point_index: usize, point_attribute: usize) -> Result<()>{
+        if self.store_attributes {
+            let p: P = point_index.try_into().unwrap();
+            let v: P = point_attribute.try_into().unwrap();
+            if let Some(x) = self.attributes.get_mut(&p) {
+                let a: usize = if let Some(y) = x.remove(&v) {
+                    usize::from(y) + 1
+                } else {
+                    1
+                };
+                x.insert(v, a.try_into().unwrap());
+            } else {
+                let mut x = HashMap::new();
+                let a: usize = 1;
+                x.insert(v, a.try_into().unwrap());
+                self.attributes.insert(p, x);
+            };
+        }
+        Ok(())
+    }
+
+    pub fn del_attrib_at_leaf(&mut self,point_index: usize, point_attribute: usize) -> Result<()> {
+        if self.store_attributes {
+            let p: P = point_index.try_into().unwrap();
+            let v: P = point_attribute.try_into().unwrap();
+            if let Some(x) = self.attributes.get_mut(&p) {
+                if let Some(y) = x.remove(&v) {
+                    check_argument(usize::from(y) > 0, " error")?;
+                    if usize::from(y) > 1 {
+                        x.insert(v, (usize::from(y) - 1).try_into().unwrap());
+                    }
+                    return Ok(());
+                }
+            }
+            return Err(RCFError::InvalidArgument { msg: "element should be present" });
+        }
+        Ok(())
+    }
 
     fn translate(&self, index: usize) -> usize {
         if index != self.null_node() && self.range_sum_data.len() <= index {
@@ -237,43 +347,13 @@ where
         false
     }
 
-    fn get_box_from_data(&self, idx: usize) -> BoundingBox {
+    fn box_from_data(&self, idx: usize) -> BoundingBox {
         let dimensions = self.dimensions;
         let base = 2 * idx * dimensions;
         return BoundingBox::new(
             &self.bounding_box_data[base..base + dimensions],
             &self.bounding_box_data[base + dimensions..base + 2 * dimensions],
-        );
-    }
-
-    pub fn reconstruct_box(&self, index: usize, point_store: &dyn PointStore) -> BoundingBox {
-        let mut mutated_bounding_box = self.get_box(self.left_index[index].into(), point_store);
-        self.grow_node_box(
-            &mut mutated_bounding_box,
-            point_store,
-            index,
-            self.right_index[index].into(),
-        );
-        mutated_bounding_box
-    }
-
-    pub fn check_contains_and_rebuild_box(
-        &mut self,
-        index: usize,
-        point: &[f32],
-        point_store: &dyn PointStore,
-    ) -> bool {
-        let idx = self.translate(index);
-        if idx != usize::MAX {
-            if !self.check_strictly_contains(index, point) {
-                let mutated_bounding_box = self.reconstruct_box(index, point_store);
-                self.copy_box_to_data(index, &mutated_bounding_box);
-                return false;
-            }
-            true
-        } else {
-            false
-        }
+        ).unwrap();
     }
 
     pub fn add_node(
@@ -284,8 +364,8 @@ where
         point_index: usize,
         cut: Cut,
         saved_box: &BoundingBox,
-    ) -> usize {
-        let index: usize = self.internal_node_manager.get().into();
+    ) -> Result<usize> {
+        let index = self.internal_node_manager.get()?.into();
         self.cut_value[index] = cut.value;
         self.cut_dimension[index] = cut.dimension.try_into().unwrap();
         if point[cut.dimension] <= cut.value {
@@ -296,7 +376,7 @@ where
             self.right_index[index] = self.leaf_index(point_index).try_into().unwrap();
         }
 
-        self.mass[index] = (self.get_mass(child)).try_into().unwrap();
+        self.mass[index] = (self.mass(child)).try_into().unwrap();
         // Not adding 1 to the above (new leaf) since all mass is represented as mass- 1
         if self.bounding_box_cache_fraction > 0.0 {
             self.copy_box_to_data(index, saved_box);
@@ -311,7 +391,7 @@ where
         if parent_index != self.null_node() {
             self.replace_node(parent_index, child, index);
         }
-        index
+        Ok(index)
     }
 
     pub fn leaf_index(&self, point_index: usize) -> usize {
@@ -319,8 +399,8 @@ where
     }
 
     pub fn set_root(&mut self, index: usize)
-    where
-        <N as TryFrom<usize>>::Error: Debug,
+        where
+            <N as TryFrom<usize>>::Error: Debug,
     {
         if !self.is_leaf(index) && self.bounding_box_cache_fraction > 0.0 {
             self.parent_index[index] = 0.try_into().unwrap();
@@ -328,7 +408,7 @@ where
     }
 
     // capacity is the number of leaves
-    pub fn increase_leaf_mass(&mut self, index: usize) {
+    pub fn increase_leaf_mass(&mut self, index: usize) -> Result<()> {
         if index >= self.capacity {
             let y = index - self.capacity;
             if let Some(a) = self.hash_mass_leaves.remove(&y) {
@@ -336,62 +416,28 @@ where
             } else {
                 self.hash_mass_leaves.insert(y, 1);
             }
-        } else {
-            panic!(" incorrect call with a non-leaf index");
+            return Ok(());
         }
+        Err(RCFError::InvalidArgument { msg: " incorrect call with a non-leaf index" })
     }
 
-    pub fn decrease_leaf_mass(&mut self, index: usize) -> usize {
+    pub fn decrease_leaf_mass(&mut self, index: usize) -> Result<usize> {
+        check_argument(self.is_leaf(index), "incorrect leaf index")?;
         let y = index - self.capacity;
-        return if let Some(a) = self.hash_mass_leaves.remove(&y) {
+        if let Some(a) = self.hash_mass_leaves.remove(&y) {
             if a > 1 {
                 self.hash_mass_leaves.insert(y, a - 1);
-                a
+                Ok(a)
             } else {
-                1 //default
+                Ok(1) //default
             }
         } else {
-            0
-        };
-    }
-
-    pub fn manage_ancestors_add(
-        &mut self,
-        path: &mut Vec<(usize, usize)>,
-        point: &[f32],
-        _point_store: &dyn PointStore,
-        box_resolved: bool,
-    ) {
-        let mut resolved = box_resolved;
-        while path.len() != 0 {
-            let index = path.pop().unwrap().0;
-            let val: usize = self.mass[index].into();
-            self.mass[index] = (val + 1).try_into().unwrap();
-            if self.bounding_box_cache_fraction > 0.0 && !resolved {
-                resolved = self.check_contains_and_add_point(index.into(), point);
-            }
+            Ok(0)
         }
     }
 
-    pub fn manage_ancestors_delete(
-        &mut self,
-        path: &mut Vec<(usize, usize)>,
-        point: &[f32],
-        point_store: &dyn PointStore,
-        box_resolved: bool,
-    ) {
-        let mut resolved = box_resolved;
-        while path.len() != 0 {
-            let index = path.pop().unwrap().0;
-            let val: usize = self.mass[index].into();
-            self.mass[index] = (val - 1).try_into().unwrap();
-            if self.bounding_box_cache_fraction > 0.0 && !resolved {
-                resolved = self.check_contains_and_rebuild_box(index, point, point_store);
-            }
-        }
-    }
 
-    pub fn delete_internal_node(&mut self, index: usize) {
+    pub fn delete_internal_node(&mut self, index: usize) -> Result<()>{
         let null_node = self.null_node();
 
         self.left_index[index] = null_node.try_into().unwrap();
@@ -402,51 +448,20 @@ where
         }
         self.cut_dimension[index] = C::MAX;
         self.cut_value[index] = 0.0;
-        self.internal_node_manager.release(index);
-    }
-
-    pub fn get_point_index(&self, index: usize) -> usize {
-        assert!(self.is_leaf(index));
-        index - self.capacity
+        if self.propagate_attributes {
+            self.propagated_attributes.remove(&index.try_into().expect("incorrect state"));
+        }
+        self.internal_node_manager.release(index)
     }
 
-    pub fn get_cut_value(&self, index: usize) -> f32 {
+    pub fn cut_value(&self, index: usize) -> f32 {
         self.cut_value[index]
     }
 
-    pub fn get_cut_dimension(&self, index: usize) -> usize {
+    pub fn cut_dimension(&self, index: usize) -> usize {
         self.cut_dimension[index].into()
     }
 
-    pub fn check_left(
-        &self,
-        index: usize,
-        dim: usize,
-        value: f32,
-        point_store: &dyn PointStore,
-    ) -> bool {
-        if self.is_leaf(index) {
-            let point = (self.project_to_tree)(point_store.get_copy(self.get_point_index(index)));
-            return point[dim] < value;
-        }
-        self.check_left(self.get_left_index(index), dim, value, point_store)
-            && self.check_left(self.get_right_index(index), dim, value, point_store)
-    }
-
-    pub fn check_right(
-        &self,
-        index: usize,
-        dim: usize,
-        value: f32,
-        point_store: &dyn PointStore,
-    ) -> bool {
-        if self.is_leaf(index) {
-            let point = (self.project_to_tree)(point_store.get_copy(self.get_point_index(index)));
-            return point[dim] >= value;
-        }
-        self.check_right(self.get_left_index(index), dim, value, point_store)
-            && self.check_right(self.get_right_index(index), dim, value, point_store)
-    }
 
     pub fn replace_node(&mut self, grand_parent: usize, parent: usize, node: usize) {
         if parent == self.left_index[grand_parent].into() {
@@ -459,7 +474,7 @@ where
         }
     }
 
-    pub fn get_size(&self, _dimensions: usize) -> usize {
+    pub fn size(&self, _dimensions: usize) -> usize {
         (self.internal_node_manager.get_size() + self.left_index.len() + self.right_index.len())
             * std::mem::size_of::<P>()
             + (self.parent_index.len() + self.mass.len()) * std::mem::size_of::<N>()
@@ -476,67 +491,198 @@ where
     fn is_internal(&self, index: usize) -> bool {
         index != self.null_node() && index < self.capacity
     }
+
 }
 
-impl<C, P, N> NodeStore for VectorNodeStore<C, P, N>
-where
-    C: Location,
-    usize: From<C>,
-    P: Location,
-    usize: From<P>,
-    N: Location,
-    usize: From<N>,
-    <C as TryFrom<usize>>::Error: Debug,
-    <P as TryFrom<usize>>::Error: Debug,
-    <N as TryFrom<usize>>::Error: Debug,
+
+impl<C, P, N,Label,Attributes> BoxStore<Label,Attributes> for VectorNodeStore<C, P, N>
+    where
+        C: Location,
+        usize: From<C>,
+        P: Location+ Eq + Hash + Send,
+        usize: From<P>,
+        N: Location,
+        usize: From<N>,
+        <C as TryFrom<usize>>::Error: Debug,
+        <P as TryFrom<usize>>::Error: Debug,
+        <N as TryFrom<usize>>::Error: Debug,
+        Label : Sync + Copy,
+        Attributes: Sync + Copy+ Hash + Eq + Send,
 {
-    fn get_mass(&self, index: usize) -> usize {
+    fn attribut_vec<PS: PointStore<Label, Attributes>>(&self, index: usize, point_store: &PS) -> Result<Vec<f32>>{
+        check_argument(self.propagate_attributes, " enable propagation of vectors")?;
         if self.is_leaf(index) {
-            let y = index - self.capacity;
-            return if let Some(a) = self.hash_mass_leaves.get(&y) {
-                (*a).into()
-            } else {
-                1
-            };
+            let list = self.attributes.get(&(self.leaf_point_index(index)?.try_into().unwrap())).expect("incorrect state");
+            check_argument(list.len() > 0, "cannot be 0")?;
+            let veclist = list.iter().map(|(&x, &y)| {
+                let weight : usize = y.into();
+                let mut vec = point_store.attribute_vec(x.into())?;
+                for z in vec.iter_mut() {
+                    *z *= weight as f32;
+                };
+                Ok(vec)
+            }).collect::<Result<Vec<Vec<f32>>>>()?;
+            let mut answer =  veclist[0].clone();
+            for i in 1..list.len() {
+                for (x,y) in answer.iter_mut().zip(&veclist[i]) {
+                    *x += *y;
+                }
+            }
+            Ok(answer)
+        } else {
+            Ok(self.propagated_attributes.get(&index.try_into().unwrap()).expect("incorrect state").clone())
         }
-        let base: usize = self.mass[index].into();
-        base + 1
     }
 
-    fn get_box(&self, index: usize, point_store: &dyn PointStore) -> BoundingBox {
+    fn recompute_attribute_vec<PS: PointStore<Label, Attributes>>(&mut self, index: usize, point_store: &PS) -> Result<()>{
+        check_argument(!self.is_leaf(index), "incorrect invocation")?;
+        let mut left = self.attribut_vec(self.left_index[index].into(),point_store)?;
+        let right = self.attribut_vec(self.right_index[index].into(),point_store)?;
+        for (x,y) in left.iter_mut().zip(right){
+            *x += y;
+        }
+        self.propagated_attributes.insert(index.try_into().expect("incorrect state"),left);
+        Ok(())
+    }
+
+    fn pointsum<PS: PointStore<Label, Attributes>>(&self, index: usize, point_store: &PS) -> Result<Vec<f32>>{
+        check_argument(self.store_pointsum, " enable store_pointsum")?;
+        if self.is_leaf(index) {
+            let mut point = point_store.copy(self.leaf_point_index(index)?)?;
+            let mass = self.mass(index);
+            for x in point.iter_mut() {
+                *x *= mass as f32;
+            }
+            Ok(point)
+        } else {
+            Ok(Vec::from(&self.pointsum[(index * self.dimensions)..((index + 1) * self.dimensions)]))
+        }
+    }
+
+    fn recompute_pointsum<PS: PointStore<Label, Attributes>>(&mut self, index: usize, point_store: &PS) -> Result<()>{
+        check_argument(!self.is_leaf(index), "incorrect invocation")?;
+        let left = self.pointsum(self.left_index[index].into(),point_store)?;
+        let right = self.pointsum(self.right_index[index].into(),point_store)?;
+        for ((x,y),z) in self.pointsum[(index * self.dimensions)..((index + 1) * self.dimensions)].iter_mut().zip(left).zip(right) {
+            *x = y + z;
+        }
+        Ok(())
+    }
+
+    fn manage_ancestors_add<PS: PointStore<Label, Attributes>>(
+        &mut self,
+        path: &mut Vec<(usize, usize)>,
+        point: &[f32],
+        point_store: &PS,
+        box_resolved: bool,
+    ) -> Result<()>{
+        let mut resolved = box_resolved;
+        while path.len() != 0 {
+            let index = path.pop().unwrap().0;
+            let val: usize = self.mass[index].into();
+            self.mass[index] = (val + 1).try_into().unwrap();
+            if self.store_pointsum {
+                self.recompute_pointsum(index,point_store)?;
+            }
+            if self.propagate_attributes {
+                self.recompute_attribute_vec(index,point_store)?;
+            }
+            if self.bounding_box_cache_fraction > 0.0 && !resolved {
+                resolved = self.check_contains_and_add_point(index.into(), point);
+            }
+        }
+        Ok(())
+    }
+
+    fn manage_ancestors_delete<PS: PointStore<Label, Attributes>>(
+        &mut self,
+        path: &mut Vec<(usize, usize)>,
+        point: &[f32],
+        point_store: &PS,
+        box_resolved: bool,
+    ) -> Result<()>{
+        let mut resolved = box_resolved;
+        while path.len() != 0 {
+            let index = path.pop().unwrap().0;
+            let val: usize = self.mass[index].into();
+            self.mass[index] = (val - 1).try_into().unwrap();
+            if self.store_pointsum {
+                self.recompute_pointsum(index,point_store)?;
+            }
+            if self.propagate_attributes {
+                self.recompute_attribute_vec(index,point_store)?;
+            }
+            if self.bounding_box_cache_fraction > 0.0 && !resolved {
+                resolved = self.check_contains_and_rebuild_box(index, point, point_store)?;
+            }
+        }
+        Ok(())
+    }
+
+    fn reconstruct_box<PS: PointStore<Label, Attributes>>(&self, index: usize, point_store: &PS) -> Result<BoundingBox> {
+        let mut mutated_bounding_box = self.bounding_box(self.left_index[index].into(), point_store)?;
+        self.grow_node_box(
+            &mut mutated_bounding_box,
+            point_store,
+            index,
+            self.right_index[index].into(),
+        )?;
+        Ok(mutated_bounding_box)
+    }
+
+    fn check_contains_and_rebuild_box<PS: PointStore<Label, Attributes>>(
+        &mut self,
+        index: usize,
+        point: &[f32],
+        point_store: &PS,
+    ) -> Result<bool> {
+        let idx = self.translate(index);
+        if idx != usize::MAX {
+            if !self.check_strictly_contains(index, point) {
+                let mutated_bounding_box = self.reconstruct_box(index, point_store)?;
+                self.copy_box_to_data(index, &mutated_bounding_box);
+                return Ok(false);
+            }
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+
+    fn bounding_box<PS: PointStore<Label, Attributes>>(&self, index: usize, point_store: &PS) -> Result<BoundingBox> {
         if self.is_leaf(index) {
             return if self.using_transforms {
                 let point =
-                    &(self.project_to_tree)(point_store.get_copy(self.get_point_index(index)));
+                    &(self.project_to_tree)(point_store.copy(self.leaf_point_index(index)?)?);
                 BoundingBox::new(point, point)
             } else {
                 let point = point_store
-                    .get_reference_and_offset(self.get_point_index(index))
+                    .reference_and_offset(self.leaf_point_index(index)?)?
                     .0;
                 BoundingBox::new(point, point)
             };
         } else {
             let idx: usize = self.translate(index);
             if idx != usize::MAX {
-                return self.get_box_from_data(idx);
+                return Ok(self.box_from_data(idx));
             }
-            let mut mutated_bounding_box = self.get_box(self.left_index[index].into(), point_store);
+            let mut mutated_bounding_box = self.bounding_box(self.left_index[index].into(), point_store)?;
             self.grow_node_box(
                 &mut mutated_bounding_box,
                 point_store,
                 index,
                 self.right_index[index].into(),
-            );
-            return mutated_bounding_box;
+            )?;
+            return Ok(mutated_bounding_box);
         }
     }
 
-    fn get_probability_of_cut(
+    fn probability_of_cut<PS: PointStore<Label, Attributes>>(
         &self,
         index: usize,
         point: &[f32],
-        point_store: &dyn PointStore,
-    ) -> f64 {
+        point_store: &PS,
+    ) -> Result<f64> {
         let node_idx: usize = self.translate(index);
         if node_idx != usize::MAX {
             let base = 2 * node_idx * self.dimensions;
@@ -556,21 +702,21 @@ where
             let sum = maxsum + minsum;
 
             if sum == 0.0 {
-                return 0.0;
+                return Ok(0.0);
             }
-            sum as f64 / (self.range_sum_data[node_idx] + sum as f64)
+            Ok(sum as f64 / (self.range_sum_data[node_idx] + sum as f64))
         } else {
-            let bounding_box = self.get_box(index, point_store);
-            bounding_box.probability_of_cut(point)
+            let bounding_box = self.bounding_box(index, point_store)?;
+            Ok(bounding_box.probability_of_cut(point))
         }
     }
-    fn get_probability_of_cut_with_missing_coordinates(
+    fn probability_of_cut_with_missing_coordinates<PS: PointStore<Label, Attributes>>(
         &self,
         index: usize,
         point: &[f32],
         missing_coordinates: &[bool],
-        point_store: &dyn PointStore,
-    ) -> f64 {
+        point_store: &PS,
+    ) -> Result<f64> {
         let node_idx: usize = self.translate(index);
         if node_idx != usize::MAX {
             let base = 2 * node_idx * self.dimensions;
@@ -592,22 +738,22 @@ where
             let sum = maxsum + minsum;
 
             if sum == 0.0 {
-                return 0.0;
+                return Ok(0.0);
             }
-            sum as f64 / (self.range_sum_data[node_idx] + sum as f64)
+            Ok(sum as f64 / (self.range_sum_data[node_idx] + sum as f64))
         } else {
-            let bounding_box = self.get_box(index, point_store);
-            bounding_box.probability_of_cut_with_missing_coordinates(point, missing_coordinates)
+            let bounding_box = self.bounding_box(index, point_store)?;
+            Ok(bounding_box.probability_of_cut_with_missing_coordinates(point, missing_coordinates))
         }
     }
-    fn modify_in_place_probability_of_cut_di_vector(
+    fn modify_in_place_probability_of_cut_di_vector<PS: PointStore<Label, Attributes>>(
         &self,
         index: usize,
         point: &[f32],
-        point_store: &dyn PointStore,
+        point_store: &PS,
         di_vector: &mut DiVector,
-    ) {
-        assert!(di_vector.high.len() == point.len());
+    ) -> Result<()>{
+        check_argument(di_vector.high.len() == point.len(), " incorrect dimensions of bounding box")?;
         let node_idx: usize = self.translate(index);
         if node_idx != usize::MAX {
             let base = 2 * node_idx * self.dimensions;
@@ -647,20 +793,21 @@ where
                 di_vector.scale(1.0 / (self.range_sum_data[node_idx] + sum));
             }
         } else {
-            let bounding_box = self.get_box(index, point_store);
+            let bounding_box = self.bounding_box(index, point_store)?;
             di_vector.assign_as_probability_of_cut(&bounding_box, point);
         };
+        Ok(())
     }
 
-    fn modify_in_place_probability_of_cut_di_vector_with_missing_coordinates(
+    fn modify_in_place_probability_of_cut_di_vector_with_missing_coordinates<PS: PointStore<Label, Attributes>>(
         &self,
         index: usize,
         point: &[f32],
         missing_coordinates: &[bool],
-        point_store: &dyn PointStore,
+        point_store: &PS,
         di_vector: &mut DiVector,
-    ) {
-        assert!(di_vector.high.len() == point.len());
+    ) -> Result<()>{
+        check_argument(di_vector.high.len() == point.len(), " incorrect dimensions of bounding box")?;
         let node_idx: usize = self.translate(index);
         if node_idx != usize::MAX {
             let base = 2 * node_idx * self.dimensions;
@@ -702,32 +849,33 @@ where
                 di_vector.scale(1.0 / (self.range_sum_data[node_idx] + sum));
             }
         } else {
-            let bounding_box = self.get_box(index, point_store);
+            let bounding_box = self.bounding_box(index, point_store)?;
             di_vector.assign_as_probability_of_cut_with_missing_coordinates(
                 &bounding_box,
                 point,
                 missing_coordinates,
             );
         };
+        Ok(())
     }
 
-    fn grow_node_box_pair(
+    fn grow_node_box_pair<PS: PointStore<Label, Attributes>>(
         &self,
         first: &mut BoundingBox,
         second: &mut BoundingBox,
-        point_store: &dyn PointStore,
+        point_store: &PS,
         _node: usize,
         sibling: usize,
-    ) {
+    ) -> Result<()>{
         if self.is_leaf(sibling) {
             if self.using_transforms {
                 let point =
-                    &(self.project_to_tree)(point_store.get_copy(self.get_point_index(sibling)));
+                    &(self.project_to_tree)(point_store.copy(self.leaf_point_index(sibling)?)?);
                 (*first).check_contains_and_add_point(point);
                 (*second).check_contains_and_add_point(point);
             } else {
                 let point = point_store
-                    .get_reference_and_offset(self.get_point_index(sibling))
+                    .reference_and_offset(self.leaf_point_index(sibling)?)?
                     .0;
                 (*first).check_contains_and_add_point(point);
                 (*second).check_contains_and_add_point(point);
@@ -753,34 +901,35 @@ where
                     second,
                     point_store,
                     sibling,
-                    self.get_left_index(sibling),
-                );
+                    self.left_index(sibling),
+                )?;
                 self.grow_node_box_pair(
                     first,
                     second,
                     point_store,
                     sibling,
-                    self.get_right_index(sibling),
-                );
+                    self.right_index(sibling),
+                )?;
             }
         }
+        Ok(())
     }
 
-    fn grow_node_box(
+    fn grow_node_box<PS: PointStore<Label, Attributes>>(
         &self,
         bounding_box: &mut BoundingBox,
-        point_store: &dyn PointStore,
+        point_store: &PS,
         _node: usize,
         sibling: usize,
-    ) {
+    ) -> Result<()>{
         if self.is_leaf(sibling) {
             if self.using_transforms {
                 let point =
-                    &(self.project_to_tree)(point_store.get_copy(self.get_point_index(sibling)));
+                    &(self.project_to_tree)(point_store.copy(self.leaf_point_index(sibling)?)?);
                 (*bounding_box).check_contains_and_add_point(point);
             } else {
                 let point = point_store
-                    .get_reference_and_offset(self.get_point_index(sibling))
+                    .reference_and_offset(self.leaf_point_index(sibling)?)?
                     .0;
                 (*bounding_box).check_contains_and_add_point(point);
             }
@@ -799,19 +948,82 @@ where
                     bounding_box,
                     point_store,
                     sibling,
-                    self.get_left_index(sibling),
-                );
+                    self.left_index(sibling),
+                )?;
                 self.grow_node_box(
                     bounding_box,
                     point_store,
                     sibling,
-                    self.get_right_index(sibling),
-                );
+                    self.right_index(sibling),
+                )?;
             }
         }
+        Ok(())
+    }
+    fn check_left<PS: PointStore<Label,Attributes>>(
+        &self,
+        index: usize,
+        dim: usize,
+        value: f32,
+        point_store: &PS
+    ) -> Result<bool> {
+        if self.is_leaf(index) {
+            let point = (self.project_to_tree)(point_store.copy(self.leaf_point_index(index)?)?);
+            return Ok(point[dim] < value);
+        }
+        // both are left -- we want both to be less than value
+        Ok(self.check_left(self.left_index(index), dim, value, point_store)?
+            && self.check_left(self.right_index(index), dim, value, point_store)?)
     }
 
-    fn get_sibling(&self, node: usize, parent: usize) -> usize {
+    fn check_right<PS: PointStore<Label,Attributes>>(
+        &self,
+        index: usize,
+        dim: usize,
+        value: f32,
+        point_store: &PS
+    ) -> Result<bool> {
+        if self.is_leaf(index) {
+            let point = (self.project_to_tree)(point_store.copy(self.leaf_point_index(index)?)?);
+            return Ok(point[dim] >= value);
+        }
+        // both are right -- we want the subtree to be greater or equal value
+        Ok(self.check_right(self.left_index(index), dim, value, point_store)?
+            && self.check_right(self.right_index(index), dim, value, point_store)?)
+    }
+}
+
+impl<C, P, N> BasicStore for VectorNodeStore<C, P, N>
+        where
+            C: Location,
+            usize: From<C>,
+            P: Location + Eq + Hash + Send,
+            usize: From<P>,
+            N: Location,
+            usize: From<N>,
+            <C as TryFrom<usize>>::Error: Debug,
+            <P as TryFrom<usize>>::Error: Debug,
+            <N as TryFrom<usize>>::Error: Debug,
+{
+    fn mass(&self, index: usize) -> usize {
+        if self.is_leaf(index) {
+            let y = index - self.capacity;
+            return if let Some(a) = self.hash_mass_leaves.get(&y) {
+                (*a).into()
+            } else {
+                1
+            };
+        }
+        let base: usize = self.mass[index].into();
+        base + 1
+    }
+
+    fn leaf_point_index(&self, index: usize) -> Result<usize> {
+        check_argument(self.is_leaf(index), " not a leaf index")?;
+        Ok(index - self.capacity)
+    }
+
+    fn sibling(&self, node: usize, parent: usize) -> usize {
         let mut sibling = self.left_index[parent].into();
         if node == sibling {
             sibling = self.right_index[parent].into();
@@ -819,27 +1031,20 @@ where
         sibling
     }
 
-    fn get_leaf_point_index(&self, index: usize) -> usize {
-        if !self.is_leaf(index) {
-            println!(" not at a leaf");
-            panic!();
-        }
-        self.get_point_index(index)
-    }
 
-    fn get_cut_dimension(&self, index: usize) -> usize {
+    fn cut_dimension(&self, index: usize) -> usize {
         self.cut_dimension[index].into()
     }
 
-    fn get_left_index(&self, index: usize) -> usize {
+    fn left_index(&self, index: usize) -> usize {
         self.left_index[index].try_into().unwrap()
     }
 
-    fn get_right_index(&self, index: usize) -> usize {
+    fn right_index(&self, index: usize) -> usize {
         self.right_index[index].try_into().unwrap()
     }
 
-    fn get_cut_value(&self, index: usize) -> f32 {
+    fn cut_value(&self, index: usize) -> f32 {
         self.cut_value[index]
     }
 
@@ -856,16 +1061,16 @@ where
         self.bounding_box_cache_fraction < SWITCH_THRESHOLD
     }
 
-    fn get_distribution(&self, index: usize) -> (usize, f32, usize, usize) {
+    fn distribution(&self, index: usize) -> (usize, f32, usize, usize) {
         (
             self.cut_dimension[index].into(),
             self.cut_value[index],
-            self.get_mass(self.get_left_index(index)),
-            self.get_mass(self.get_right_index(index)),
+            self.mass(self.left_index(index)),
+            self.mass(self.right_index(index)),
         )
     }
 
-    fn get_cut_and_children(&self, index: usize) -> (usize, f32, usize, usize) {
+    fn cut_and_children(&self, index: usize) -> (usize, f32, usize, usize) {
         if self.is_internal(index) {
             (
                 self.cut_dimension[index].into(),
@@ -895,4 +1100,26 @@ where
     fn null_node(&self) -> usize {
         Self::null_value(self.capacity)
     }
+
+    fn attribute_at_leaf(&self,point_index: usize) -> Result<Vec<(usize,usize)>> {
+        self.attributes.get(&point_index.try_into().expect("out of range")).expect("should be present").iter()
+            .map(|(&x,&y)| {
+                Ok((x.into(),y.into()))
+            }).collect()
+    }
 }
+
+impl<C, P, N,Label,Attributes> NodeStore<Label,Attributes> for VectorNodeStore<C, P, N>
+    where
+        C: Location,
+        usize: From<C>,
+        P: Location+ Eq + Hash + Send,
+        usize: From<P>,
+        N: Location,
+        usize: From<N>,
+        <C as TryFrom<usize>>::Error: Debug,
+        <P as TryFrom<usize>>::Error: Debug,
+        <N as TryFrom<usize>>::Error: Debug,
+        Label : Sync + Copy,
+        Attributes: Sync + Copy+ Hash + Eq + Send,
+{}
diff --git a/Rust/src/samplerplustree/nodeview.rs b/Rust/src/samplerplustree/nodeview.rs
index 2869ab9a..dc9a82db 100644
--- a/Rust/src/samplerplustree/nodeview.rs
+++ b/Rust/src/samplerplustree/nodeview.rs
@@ -1,51 +1,46 @@
+use std::hash::Hash;
 use crate::{
     common::divector::DiVector,
     pointstore::PointStore,
-    samplerplustree::{boundingbox::BoundingBox, nodestore::NodeStore},
+    samplerplustree::{boundingbox::BoundingBox, nodestore::{BasicStore, NodeStore}},
     visitor::visitor::VisitorInfo,
+    types::Result
 };
 
-pub trait UpdatableNodeView<NS, PS>
-where
-    NS: NodeStore,
-    PS: PointStore,
-{
-    fn create(root: usize, node_store: &NS) -> Self;
-    fn update_at_leaf(
+
+pub trait UpdatableNodeView <Label: Copy + Sync, Attributes : Copy + Sync+ Hash + Eq + Send>{
+    fn create<NS : NodeStore<Label,Attributes>>(root: usize, node_store: &NS) -> Self;
+    fn update_at_leaf<PS: PointStore<Label,Attributes>, NS: NodeStore<Label,Attributes>>(
         &mut self,
         point: &[f32],
         index: usize,
         node_store: &NS,
         point_store: &PS,
         visitor_info: &VisitorInfo,
-    );
-    fn update_from_node_traversing_down(
+    ) -> Result<()>;
+    fn update_from_node_traversing_down< PS: PointStore<Label,Attributes>, NS: NodeStore<Label,Attributes>>(
         &mut self,
         point: &[f32],
         index: usize,
         node_store: &NS,
         point_store: &PS,
         visitor_info: &VisitorInfo,
-    );
-    fn update_from_node_traversing_up(
+    ) -> Result<()>;
+    fn update_from_node_traversing_up< PS: PointStore<Label,Attributes>, NS: NodeStore<Label,Attributes>>(
         &mut self,
         point: &[f32],
         index: usize,
         node_store: &NS,
         point_store: &PS,
         visitor_info: &VisitorInfo,
-    );
-    fn get_current_node(&self) -> usize;
-    fn set_use_shadow_box(&mut self, node_store: &NS, point_store: &PS);
+    ) -> Result<()>;
+    fn current_node(&self) -> usize;
+    fn set_use_shadow_box< PS: PointStore<Label,Attributes>, NS: NodeStore<Label,Attributes>>(&mut self, node_store: &NS, point_store: &PS) -> Result<()>;
 }
 
-pub trait UpdatableMultiNodeView<NS, PS>: UpdatableNodeView<NS, PS>
-where
-    NS: NodeStore,
-    PS: PointStore,
-{
-    fn create(root: usize, node_store: &NS) -> Self;
-    fn set_trigger_traversing_down(
+pub trait UpdatableMultiNodeView<Label: Copy + Sync, Attributes : Copy + Sync+ Hash + Eq + Send> : UpdatableNodeView<Label, Attributes> {
+    fn create<NS: NodeStore<Label,Attributes>>(root: usize, node_store: &NS) -> Self;
+    fn set_trigger_traversing_down<PS: PointStore<Label,Attributes>, NS: NodeStore<Label,Attributes>>(
         &mut self,
         point: &[f32],
         parent: usize,
@@ -53,7 +48,7 @@ where
         point_store: &PS,
         visitor_info: &VisitorInfo,
     );
-    fn update_view_to_parent_with_missing_coordinates(
+    fn update_view_to_parent_with_missing_coordinates<PS: PointStore<Label,Attributes>, NS: NodeStore<Label,Attributes>>(
         &mut self,
         parent: usize,
         point: &[f32],
@@ -61,10 +56,10 @@ where
         node_store: &NS,
         point_store: &PS,
         visitor_info: &VisitorInfo,
-    );
+    ) -> Result<()>;
     fn set_current_node(&mut self, index: usize);
-    fn get_bounding_box(&self) -> Option<BoundingBox>;
-    fn merge_paths(
+    fn bounding_box(&self) -> Option<BoundingBox>;
+    fn merge_paths<PS: PointStore<Label,Attributes>, NS: NodeStore<Label,Attributes>>(
         &mut self,
         parent: usize,
         saved_box: Option<BoundingBox>,
@@ -72,14 +67,14 @@ where
         missing_coordinates: &[bool],
         node_store: &NS,
         point_store: &PS,
-    );
+    ) -> Result<()>;
 }
 
 #[repr(C)]
 pub struct SmallNodeView {
     current_node: usize,
     probability_of_cut: f64,
-    shadow_box_probablity_of_cut: f64,
+    shadow_box_probability_of_cut: f64,
     mass: usize,
     depth: usize,
     leaf_index: usize,
@@ -90,29 +85,29 @@ pub struct SmallNodeView {
 }
 
 impl SmallNodeView {
-    pub fn get_probability_of_cut(&self) -> f64 {
+    pub fn probability_of_cut(&self) -> f64 {
         self.probability_of_cut
     }
-    pub fn get_shadow_box_probability_of_cut(&self) -> f64 {
-        self.shadow_box_probablity_of_cut
+    pub fn shadow_box_probability_of_cut(&self) -> f64 {
+        self.shadow_box_probability_of_cut
     }
-    pub fn get_mass(&self) -> usize {
+    pub fn mass(&self) -> usize {
         self.mass
     }
-    pub fn get_depth(&self) -> usize {
+    pub fn depth(&self) -> usize {
         self.depth
     }
-    pub fn get_leaf_index(&self) -> usize {
+    pub fn leaf_index(&self) -> usize {
         self.leaf_index
     }
     pub fn is_duplicate(&self) -> bool {
         self.leaf_duplicate
     }
-    pub fn new<NS: NodeStore>(root: usize, node_store: &NS) -> Self {
+    pub fn new<Label: Copy + Sync, Attributes : Copy + Sync+ Hash + Eq + Send, NS: NodeStore<Label,Attributes>>(root: usize, _node_store: &NS) -> Self {
         SmallNodeView {
             current_node: root,
             probability_of_cut: f64::MAX, // not feasible; but that is the point!
-            shadow_box_probablity_of_cut: f64::MAX,
+            shadow_box_probability_of_cut: f64::MAX,
             mass: 0,
             depth: 0,
             leaf_index: usize::MAX,
@@ -124,26 +119,23 @@ impl SmallNodeView {
     }
 }
 
-impl<NS, PS> UpdatableNodeView<NS, PS> for SmallNodeView
-where
-    NS: NodeStore,
-    PS: PointStore,
-{
-    fn create(root: usize, _node_store: &NS) -> Self {
+impl<Label: Copy + Sync, Attributes : Copy + Sync+ Hash + Eq + Send> UpdatableNodeView<Label,Attributes> for SmallNodeView {
+
+    fn create<NS: NodeStore<Label,Attributes>>(root: usize, _node_store: &NS) -> Self {
         SmallNodeView::new(root, _node_store)
     }
 
-    fn update_at_leaf(
+    fn update_at_leaf< PS: PointStore<Label,Attributes>, NS: NodeStore<Label,Attributes>>(
         &mut self,
         point: &[f32],
         index: usize,
         node_store: &NS,
         point_store: &PS,
-        visito_info: &VisitorInfo,
-    ) {
-        self.leaf_index = node_store.get_leaf_point_index(index);
-        self.mass = node_store.get_mass(index);
-        self.probability_of_cut = if point_store.is_equal(point, self.leaf_index) {
+        _visitor_info: &VisitorInfo,
+    ) ->Result<()>{
+        self.leaf_index = node_store.leaf_point_index(index)?;
+        self.mass = node_store.mass(index);
+        self.probability_of_cut = if point_store.is_equal(point, self.leaf_index)? {
             self.leaf_duplicate = true;
             0.0
         } else {
@@ -151,69 +143,73 @@ where
             1.0f64
         };
         if node_store.use_path_for_box() {
-            self.current_box = Some(node_store.get_box(self.current_node, point_store));
+            self.current_box = Some(node_store.bounding_box(self.current_node, point_store)?);
         }
+        Ok(())
     }
 
-    fn update_from_node_traversing_down(
+    fn update_from_node_traversing_down< PS: PointStore<Label,Attributes>, NS: NodeStore<Label,Attributes>>(
         &mut self,
         point: &[f32],
-        index: usize,
+        _index: usize,
         node_store: &NS,
-        point_store: &PS,
-        visitor_info: &VisitorInfo,
-    ) {
+        _point_store: &PS,
+        _visitor_info: &VisitorInfo,
+    ) -> Result<()>{
         if node_store.is_left_of(self.current_node, point) {
-            self.current_node = node_store.get_left_index(self.current_node);
+            self.current_node = node_store.left_index(self.current_node);
         } else {
-            self.current_node = node_store.get_right_index(self.current_node);
+            self.current_node = node_store.right_index(self.current_node);
         }
         self.depth += 1;
+        Ok(())
     }
 
-    fn update_from_node_traversing_up(
+    fn update_from_node_traversing_up<PS: PointStore<Label,Attributes>, NS: NodeStore<Label,Attributes>>(
         &mut self,
         point: &[f32],
         index: usize,
         node_store: &NS,
         point_store: &PS,
-        visitor_info: &VisitorInfo,
-    ) {
+        _visitor_info: &VisitorInfo,
+    ) -> Result<()>{
         self.probability_of_cut = match &mut self.current_box {
             Some(x) => {
-                let sibling = node_store.get_sibling(self.current_node, index);
+                let sibling = node_store.sibling(self.current_node, index);
                 if self.use_shadow_box {
-                    let z = node_store.get_box(sibling, point_store);
+                    let z = node_store.bounding_box(sibling, point_store)?;
                     x.add_box(&z);
                     match &mut self.shadow_box {
                         Some(y) => y.add_box(&z),
                         None => self.shadow_box = Some(z),
                     }
-                    self.shadow_box_probablity_of_cut =
+                    self.shadow_box_probability_of_cut =
                         self.shadow_box.as_ref().unwrap().probability_of_cut(point);
                 } else {
-                    node_store.grow_node_box(x, point_store, index, sibling);
+                    node_store.grow_node_box(x, point_store, index, sibling)?;
                 };
                 x.probability_of_cut(point)
             }
-            None => node_store.get_probability_of_cut(index, point, point_store),
+            None => node_store.probability_of_cut(index, point, point_store)?,
         };
         self.current_node = index;
-        self.mass = node_store.get_mass(index);
+        self.mass = node_store.mass(index);
         self.depth -= 1;
+        Ok(())
     }
 
-    fn get_current_node(&self) -> usize {
+    fn current_node(&self) -> usize {
         self.current_node
     }
 
-    fn set_use_shadow_box(&mut self, node_store: &NS, point_store: &PS) {
+    fn set_use_shadow_box< PS: PointStore<Label,Attributes>, NS: NodeStore<Label,Attributes>>(&mut self, node_store: &NS, point_store: &PS) -> Result<()>{
         self.use_shadow_box = true;
         // we will maintain a current box since we haver to maintain a shadow box in any case
         // the shadow box is not set; it can only be set at the next level
         // when update_from_node_up() is invoked
         // we will maintain the invariant that *if the shadow is present then the current box also is present*
-        self.current_box = Some(node_store.get_box(self.current_node, point_store));
+        self.current_box = Some(node_store.bounding_box(self.current_node, point_store)?);
+        Ok(())
     }
 }
 
@@ -236,37 +232,34 @@ pub struct MediumNodeView {
 }
 
 impl MediumNodeView {
-    pub fn get_probability_of_cut(&self) -> f64 {
+    pub fn probability_of_cut(&self) -> f64 {
         self.probability_of_cut
     }
-    pub fn get_shadow_box_probability_of_cut(&self) -> f64 {
+    pub fn shadow_box_probability_of_cut(&self) -> f64 {
         self.shadow_box_probablity_of_cut
     }
-    pub fn get_mass(&self) -> usize {
+    pub fn mass(&self) -> usize {
         self.mass
     }
-    pub fn get_depth(&self) -> usize {
+    pub fn depth(&self) -> usize {
         self.depth
     }
-    pub fn get_leaf_index(&self) -> usize {
+    pub fn leaf_index(&self) -> usize {
         self.leaf_index
     }
     pub fn is_duplicate(&self) -> bool {
         self.leaf_duplicate
     }
-    pub fn get_cut_dimension(&self) -> usize {
+    pub fn cut_dimension(&self) -> usize {
         self.cut_dimension
     }
-    pub fn get_cut_value(&self) -> f32 {
+    pub fn cut_value(&self) -> f32 {
         self.cut_value
     }
-    pub fn get_leaf_point(&self) -> Vec<f32> {
+    pub fn leaf_point(&self) -> Vec<f32> {
         self.point_at_leaf.clone()
     }
-    pub fn new<NS: NodeStore>(root: usize, node_store: &NS) -> Self {
-        let (cut_dimension, cut_value, left_child, right_child) =
-            node_store.get_cut_and_children(root);
-        let mass = node_store.get_mass(root);
+    pub fn new<Label: Copy + Sync, Attributes : Copy + Sync>(root: usize, cut_dimension : usize, cut_value: f32, mass: usize ) -> Self {
         Self {
             current_node: root,
             sibling: usize::MAX,
@@ -286,26 +279,40 @@ impl MediumNodeView {
     }
 }
 
-impl<NS, PS> UpdatableNodeView<NS, PS> for MediumNodeView
-where
-    NS: NodeStore,
-    PS: PointStore,
-{
-    fn create(root: usize, node_store: &NS) -> Self {
-        MediumNodeView::new(root, node_store)
+impl<Label: Copy + Sync, Attributes : Copy + Sync+ Hash + Eq + Send> UpdatableNodeView<Label,Attributes> for MediumNodeView {
+    fn create<NS: NodeStore<Label,Attributes>>(root: usize, node_store: &NS) -> Self {
+        let (cut_dimension, cut_value, _left_child, _right_child) =
+            node_store.cut_and_children(root);
+        let mass = node_store.mass(root);
+        Self {
+            current_node: root,
+            sibling: usize::MAX,
+            probability_of_cut: f64::MAX,
+            shadow_box_probablity_of_cut: f64::MAX,
+            mass,
+            depth: 0,
+            leaf_index: usize::MAX,
+            leaf_duplicate: false,
+            use_shadow_box: false,
+            current_box: None,
+            shadow_box: None,
+            cut_dimension,
+            cut_value,
+            point_at_leaf: Vec::new(),
+        }
     }
 
-    fn update_at_leaf(
+    fn update_at_leaf<PS: PointStore<Label,Attributes>, NS: NodeStore<Label,Attributes>>(
         &mut self,
         point: &[f32],
         index: usize,
         node_store: &NS,
         point_store: &PS,
-        visitor_info: &VisitorInfo,
-    ) {
-        self.leaf_index = node_store.get_leaf_point_index(index);
-        self.point_at_leaf = point_store.get_copy(self.leaf_index);
-        self.mass = node_store.get_mass(index);
+        _visitor_info: &VisitorInfo,
+    ) -> Result<()>{
+        self.leaf_index = node_store.leaf_point_index(index)?;
+        self.point_at_leaf = point_store.copy(self.leaf_index)?;
+        self.mass = node_store.mass(index);
         self.probability_of_cut = if self.point_at_leaf.eq(point) {
             self.leaf_duplicate = true;
             0.0
@@ -314,39 +321,41 @@ where
             1.0f64
         };
         if node_store.use_path_for_box() {
-            self.current_box = Some(BoundingBox::new(&self.point_at_leaf, &self.point_at_leaf));
+            self.current_box = Some(BoundingBox::new(&self.point_at_leaf, &self.point_at_leaf)?);
         }
+        Ok(())
     }
 
-    fn update_from_node_traversing_down(
+    fn update_from_node_traversing_down<PS: PointStore<Label,Attributes>, NS: NodeStore<Label,Attributes>>(
         &mut self,
         point: &[f32],
-        index: usize,
+        _index: usize,
         node_store: &NS,
-        point_store: &PS,
-        visitor_info: &VisitorInfo,
-    ) {
+        _point_store: &PS,
+        _visitor_info: &VisitorInfo,
+    ) -> Result<()>{
         if node_store.is_left_of(self.current_node, point) {
-            self.current_node = node_store.get_left_index(self.current_node);
+            self.current_node = node_store.left_index(self.current_node);
         } else {
-            self.current_node = node_store.get_right_index(self.current_node);
+            self.current_node = node_store.right_index(self.current_node);
         }
         self.depth += 1;
+        Ok(())
     }
 
-    fn update_from_node_traversing_up(
+    fn update_from_node_traversing_up<PS: PointStore<Label,Attributes>, NS: NodeStore<Label,Attributes>>(
         &mut self,
         point: &[f32],
         index: usize,
         node_store: &NS,
         point_store: &PS,
-        visitor_info: &VisitorInfo,
-    ) {
+        _visitor_info: &VisitorInfo,
+    ) -> Result<()>{
         self.probability_of_cut = match &mut self.current_box {
             Some(x) => {
-                self.sibling = node_store.get_sibling(self.current_node, index);
+                self.sibling = node_store.sibling(self.current_node, index);
                 if self.use_shadow_box {
-                    let z = node_store.get_box(self.sibling, point_store);
+                    let z = node_store.bounding_box(self.sibling, point_store)?;
                     x.add_box(&z);
                     match &mut self.shadow_box {
                         Some(y) => y.add_box(&z),
@@ -355,103 +364,104 @@ where
                     self.shadow_box_probablity_of_cut =
                         self.shadow_box.as_ref().unwrap().probability_of_cut(point);
                 } else {
-                    node_store.grow_node_box(x, point_store, index, self.sibling);
+                    node_store.grow_node_box(x, point_store, index, self.sibling)?;
                 };
                 x.probability_of_cut(point)
             }
-            None => node_store.get_probability_of_cut(index, point, point_store),
+            None => node_store.probability_of_cut(index, point, point_store)?,
         };
         self.current_node = index;
-        let (cut_dimension, cut_value, left_child, right_child) =
-            node_store.get_cut_and_children(self.current_node);
+        let (cut_dimension, cut_value, _left_child, _right_child) =
+            node_store.cut_and_children(self.current_node);
         self.cut_dimension = cut_dimension;
         self.cut_value = cut_value;
-        self.mass = node_store.get_mass(index);
+        self.mass = node_store.mass(index);
         self.depth -= 1;
+        Ok(())
     }
 
-    fn get_current_node(&self) -> usize {
+    fn current_node(&self) -> usize {
         self.current_node
     }
 
-    fn set_use_shadow_box(&mut self, node_store: &NS, point_store: &PS) {
+    fn set_use_shadow_box<PS: PointStore<Label,Attributes>, NS: NodeStore<Label,Attributes>>(&mut self, node_store: &NS, point_store: &PS) -> Result<()>{
         self.use_shadow_box = true;
         // we will maintain a current box since we haver to maintain a shadow box in any case
         // the shadow box is not set; it can only be set at the next level
         // when update_from_node_up() is invoked
         // we will maintain the invariant that *if the shadow is present then the current box also is present*
-        self.current_box = Some(node_store.get_box(self.current_node, point_store));
+        self.current_box = Some(node_store.bounding_box(self.current_node, point_store)?);
+        Ok(())
     }
 }
 
-impl<NS, PS> UpdatableMultiNodeView<NS, PS> for MediumNodeView
-where
-    NS: NodeStore,
-    PS: PointStore,
-{
-    fn create(root: usize, node_store: &NS) -> Self {
-        MediumNodeView::new(root, node_store)
+impl<Label: Copy + Sync, Attributes : Copy + Sync+ Hash + Eq + Send> UpdatableMultiNodeView<Label,Attributes> for MediumNodeView {
+    fn create<NS: NodeStore<Label,Attributes>>(root: usize, node_store: &NS) -> Self {
+        let (cut_dimension,cut_value,_left_child,_right_child) = node_store.cut_and_children(root);
+        let mass = node_store.mass(root);
+        MediumNodeView::new::<Label,Attributes>(root, cut_dimension,cut_value,mass)
     }
 
-    fn set_trigger_traversing_down(
+    fn set_trigger_traversing_down< PS: PointStore<Label,Attributes>, NS: NodeStore<Label,Attributes>>(
         &mut self,
-        point: &[f32],
-        parent: usize,
+        _point: &[f32],
+        _parent: usize,
         node_store: &NS,
-        point_store: &PS,
-        visitor_info: &VisitorInfo,
+        _point_store: &PS,
+        _visitor_info: &VisitorInfo,
     ) {
-        let (cut_dimension, cut_value, left_child, right_child) =
-            node_store.get_cut_and_children(self.current_node);
+        let (cut_dimension, cut_value, _left_child, _right_child) =
+            node_store.cut_and_children(self.current_node);
         self.cut_dimension = cut_dimension;
         self.cut_value = cut_value;
     }
 
-    fn update_view_to_parent_with_missing_coordinates(
+    fn update_view_to_parent_with_missing_coordinates< PS: PointStore<Label,Attributes>, NS: NodeStore<Label,Attributes>>(
         &mut self,
         parent: usize,
         point: &[f32],
         missing_coordinates: &[bool],
         node_store: &NS,
         point_store: &PS,
-        visitor_info: &VisitorInfo,
-    ) {
+        _visitor_info: &VisitorInfo,
+    ) -> Result<()>{
         if node_store.use_path_for_box() {
-            let sibling = node_store.get_sibling(self.current_node, parent);
+            let sibling = node_store.sibling(self.current_node, parent);
             node_store.grow_node_box(
                 self.current_box.as_mut().unwrap(),
                 point_store,
                 parent,
                 sibling,
-            );
+            )?;
             self.probability_of_cut = self
                 .current_box
                 .as_ref()
                 .unwrap()
                 .probability_of_cut_with_missing_coordinates(point, missing_coordinates);
         } else {
-            self.probability_of_cut = node_store.get_probability_of_cut_with_missing_coordinates(
+            self.probability_of_cut = node_store.probability_of_cut_with_missing_coordinates(
                 parent,
                 point,
                 missing_coordinates,
                 point_store,
-            );
+            )?;
         }
         self.current_node = parent;
+        Ok(())
     }
 
     fn set_current_node(&mut self, index: usize) {
         self.current_node = index;
     }
 
-    fn get_bounding_box(&self) -> Option<BoundingBox> {
+    fn bounding_box(&self) -> Option<BoundingBox> {
         match &self.current_box {
-            Some(x) => Some(x.copy()),
+            Some(x) => Some(x.clone()),
             None => None,
         }
     }
 
-    fn merge_paths(
+    fn merge_paths<PS: PointStore<Label,Attributes>, NS: NodeStore<Label,Attributes>>(
         &mut self,
         parent: usize,
         saved_box: Option<BoundingBox>,
@@ -459,7 +469,7 @@ where
         missing_coordinates: &[bool],
         node_store: &NS,
         point_store: &PS,
-    ) {
+    ) -> Result<()>{
         if node_store.use_path_for_box() {
             // both boxes, current and saved, should be present as invariant
             self.current_box
@@ -472,14 +482,15 @@ where
                 .unwrap()
                 .probability_of_cut_with_missing_coordinates(point, missing_coordinates);
         } else {
-            self.probability_of_cut = node_store.get_probability_of_cut_with_missing_coordinates(
+            self.probability_of_cut = node_store.probability_of_cut_with_missing_coordinates(
                 parent,
                 point,
                 missing_coordinates,
                 point_store,
-            );
+            )?;
         }
         self.current_node = parent;
+        Ok(())
     }
 }
 
@@ -504,38 +515,45 @@ pub struct LargeNodeView {
 }
 
 impl LargeNodeView {
-    pub fn get_probability_of_cut(&self) -> f64 {
+    pub fn probability_of_cut(&self) -> f64 {
         self.probability_of_cut
     }
-    pub fn get_shadow_box_probability_of_cut(&self) -> f64 {
+    pub fn shadow_box_probability_of_cut(&self) -> f64 {
         self.shadow_box_probablity_of_cut
     }
-    pub fn get_mass(&self) -> usize {
+    pub fn mass(&self) -> usize {
         self.mass
     }
-    pub fn get_depth(&self) -> usize {
+    pub fn depth(&self) -> usize {
         self.depth
     }
-    pub fn get_leaf_index(&self) -> usize {
+    pub fn leaf_index(&self) -> usize {
         self.leaf_index
     }
     pub fn is_duplicate(&self) -> bool {
         self.leaf_duplicate
     }
-    pub fn get_cut_dimension(&self) -> usize {
+    pub fn cut_dimension(&self) -> usize {
         self.cut_dimension
     }
-    pub fn get_cut_value(&self) -> f32 {
+    pub fn cut_value(&self) -> f32 {
         self.cut_value
     }
-    pub fn get_leaf_point(&self) -> Vec<f32> {
+    pub fn leaf_point(&self) -> Vec<f32> {
         self.point_at_leaf.clone()
     }
-    pub fn bounding_box(&self) -> BoundingBox {
-        self.current_box.as_ref().unwrap().copy()
+    pub fn bounding_box(&self) -> Option<BoundingBox> {
+        match &self.current_box {
+            Some(x) => Some(x.clone()),
+            None => None,
+        }
     }
-    pub fn shadow_box(&self) -> BoundingBox {
-        self.shadow_box.as_ref().unwrap().copy()
+
+    pub fn shadow_box(&self) -> Option<BoundingBox> {
+        match &self.shadow_box {
+            Some(x) => Some(x.clone()),
+            None => None,
+        }
     }
     pub fn assign_probability_of_cut(&self, di_vector: &mut DiVector, point: &[f32]) {
         di_vector.assign_as_probability_of_cut(self.current_box.as_ref().unwrap(), point)
@@ -544,10 +562,9 @@ impl LargeNodeView {
         assert!(self.use_shadow_box, "shadow box not in use");
         di_vector.assign_as_probability_of_cut(self.shadow_box.as_ref().unwrap(), point)
     }
-    pub fn new<NS: NodeStore>(root: usize, node_store: &NS) -> Self {
-        let (cut_dimension, cut_value, left_child, right_child) =
-            node_store.get_cut_and_children(root);
-        let mass = node_store.get_mass(root);
+
+    pub fn new<Label: Copy + Sync, Attributes : Copy + Sync>(root: usize, cut_dimension : usize, cut_value : f32,
+                                                             left_child : usize, right_child: usize, mass: usize) -> Self {
         Self {
             current_node: root,
             sibling: usize::MAX,
@@ -569,26 +586,24 @@ impl LargeNodeView {
     }
 }
 
-impl<NS, PS> UpdatableNodeView<NS, PS> for LargeNodeView
-where
-    NS: NodeStore,
-    PS: PointStore,
-{
-    fn create(root: usize, node_store: &NS) -> Self {
-        LargeNodeView::new(root, node_store)
+impl<Label: Copy + Sync, Attributes : Copy + Sync+ Hash + Eq + Send> UpdatableNodeView<Label,Attributes> for LargeNodeView {
+    fn create<NS: NodeStore<Label,Attributes>>(root: usize, node_store: &NS) -> Self {
+        let (cut_dimension,cut_value,left_child,right_child) = node_store.cut_and_children(root);
+        let mass = node_store.mass(root);
+        LargeNodeView::new::<Label,Attributes>(root, cut_dimension,cut_value,left_child,right_child,mass)
     }
 
-    fn update_at_leaf(
+    fn update_at_leaf< PS: PointStore<Label,Attributes>, NS: NodeStore<Label,Attributes>>(
         &mut self,
         point: &[f32],
         index: usize,
         node_store: &NS,
         point_store: &PS,
-        visitor_info: &VisitorInfo,
-    ) {
-        self.leaf_index = node_store.get_leaf_point_index(index);
-        self.point_at_leaf = point_store.get_copy(self.leaf_index);
-        self.mass = node_store.get_mass(index);
+        _visitor_info: &VisitorInfo,
+    ) -> Result<()>{
+        self.leaf_index = node_store.leaf_point_index(index)?;
+        self.point_at_leaf = point_store.copy(self.leaf_index)?;
+        self.mass = node_store.mass(index);
         self.probability_of_cut = if self.point_at_leaf.eq(point) {
             self.leaf_duplicate = true;
             0.0
@@ -596,43 +611,45 @@ where
             self.leaf_duplicate = false;
             1.0f64
         };
-        self.current_box = Some(BoundingBox::new(&self.point_at_leaf, &self.point_at_leaf));
+        self.current_box = Some(BoundingBox::new(&self.point_at_leaf, &self.point_at_leaf)?);
+        Ok(())
     }
 
-    fn update_from_node_traversing_down(
+    fn update_from_node_traversing_down<PS: PointStore<Label,Attributes>, NS: NodeStore<Label,Attributes>>(
         &mut self,
         point: &[f32],
-        index: usize,
+        _index: usize,
         node_store: &NS,
-        point_store: &PS,
-        visitor_info: &VisitorInfo,
-    ) {
+        _point_store: &PS,
+        _visitor_info: &VisitorInfo,
+    ) -> Result<()>{
         if point[self.cut_dimension] <= self.cut_value {
             self.current_node = self.left_child;
         } else {
             self.current_node = self.right_child;
         }
         let (cut_dimension, cut_value, left_child, right_child) =
-            node_store.get_cut_and_children(self.current_node);
+            node_store.cut_and_children(self.current_node);
         self.cut_dimension = cut_dimension;
         self.cut_value = cut_value;
         self.left_child = left_child;
         self.right_child = right_child;
         self.depth += 1;
-        self.mass = node_store.get_mass(self.current_node);
+        self.mass = node_store.mass(self.current_node);
+        Ok(())
     }
 
-    fn update_from_node_traversing_up(
+    fn update_from_node_traversing_up< PS: PointStore<Label,Attributes>, NS: NodeStore<Label,Attributes>>(
         &mut self,
         point: &[f32],
         index: usize,
         node_store: &NS,
         point_store: &PS,
-        visitor_info: &VisitorInfo,
-    ) {
-        self.sibling = node_store.get_sibling(self.current_node, index);
+        _visitor_info: &VisitorInfo,
+    ) -> Result<()>{
+        self.sibling = node_store.sibling(self.current_node, index);
         if self.use_shadow_box {
-            let z = node_store.get_box(self.sibling, point_store);
+            let z = node_store.bounding_box(self.sibling, point_store)?;
             self.current_box.as_mut().unwrap().add_box(&z);
             match &mut self.shadow_box {
                 Some(y) => y.add_box(&z),
@@ -646,99 +663,100 @@ where
                 point_store,
                 index,
                 self.sibling,
-            );
+            )?;
         };
         self.probability_of_cut = self.current_box.as_ref().unwrap().probability_of_cut(point);
 
         self.current_node = index;
         let (cut_dimension, cut_value, left_child, right_child) =
-            node_store.get_cut_and_children(self.current_node);
+            node_store.cut_and_children(self.current_node);
         self.cut_dimension = cut_dimension;
         self.cut_value = cut_value;
         self.left_child = left_child;
         self.right_child = right_child;
-        self.mass = node_store.get_mass(index);
+        self.mass = node_store.mass(index);
         self.depth -= 1;
+        Ok(())
     }
 
-    fn get_current_node(&self) -> usize {
+    fn current_node(&self) -> usize {
         self.current_node
     }
 
-    fn set_use_shadow_box(&mut self, node_store: &NS, point_store: &PS) {
+    fn set_use_shadow_box< PS: PointStore<Label,Attributes>, NS: NodeStore<Label,Attributes>>(&mut self, _node_store: &NS, _point_store: &PS) -> Result<()>{
         self.use_shadow_box = true;
         // note that the current box is always maintained
+        Ok(())
     }
 }
 
-impl<NS, PS> UpdatableMultiNodeView<NS, PS> for LargeNodeView
-where
-    NS: NodeStore,
-    PS: PointStore,
-{
-    fn create(root: usize, node_store: &NS) -> Self {
-        LargeNodeView::new(root, node_store)
+impl<Label: Copy + Sync, Attributes : Copy + Sync+ Hash + Eq + Send,> UpdatableMultiNodeView<Label,Attributes> for LargeNodeView {
+    fn create<NS: NodeStore<Label,Attributes>>(root: usize, node_store: &NS) -> Self {
+        let (cut_dimension,cut_value,left_child,right_child) = node_store.cut_and_children(root);
+        let mass = node_store.mass(root);
+        LargeNodeView::new::<Label,Attributes>(root, cut_dimension,cut_value,left_child,right_child,mass)
     }
 
-    fn set_trigger_traversing_down(
+    fn set_trigger_traversing_down< PS: PointStore<Label,Attributes>, NS: NodeStore<Label,Attributes>>(
         &mut self,
-        point: &[f32],
-        parent: usize,
+        _point: &[f32],
+        _parent: usize,
         node_store: &NS,
-        point_store: &PS,
-        visitor_info: &VisitorInfo,
+        _point_store: &PS,
+        _visitor_info: &VisitorInfo,
     ) {
-        let (cut_dimension, cut_value, left_child, right_child) =
-            node_store.get_cut_and_children(self.current_node);
+        let (cut_dimension, cut_value, _left_child, _right_child) =
+            node_store.cut_and_children(self.current_node);
         self.cut_dimension = cut_dimension;
         self.cut_value = cut_value;
     }
 
-    fn update_view_to_parent_with_missing_coordinates(
+    fn update_view_to_parent_with_missing_coordinates<PS: PointStore<Label,Attributes>, NS: NodeStore<Label,Attributes>>(
         &mut self,
         parent: usize,
         point: &[f32],
         missing_coordinates: &[bool],
         node_store: &NS,
         point_store: &PS,
-        visitor_info: &VisitorInfo,
-    ) {
+        _visitor_info: &VisitorInfo,
+    ) -> Result<()> {
         if node_store.use_path_for_box() {
-            let sibling = node_store.get_sibling(self.current_node, parent);
+            let sibling = node_store.sibling(self.current_node, parent);
             node_store.grow_node_box(
                 self.current_box.as_mut().unwrap(),
                 point_store,
                 parent,
                 sibling,
-            );
+            )?;
             self.probability_of_cut = self
                 .current_box
                 .as_ref()
                 .unwrap()
                 .probability_of_cut_with_missing_coordinates(point, missing_coordinates);
         } else {
-            self.probability_of_cut = node_store.get_probability_of_cut_with_missing_coordinates(
+            self.probability_of_cut = node_store.probability_of_cut_with_missing_coordinates(
                 parent,
                 point,
                 missing_coordinates,
                 point_store,
-            );
+            )?;
         }
         self.current_node = parent;
+        Ok(())
     }
 
     fn set_current_node(&mut self, index: usize) {
         self.current_node = index;
     }
 
-    fn get_bounding_box(&self) -> Option<BoundingBox> {
+    fn bounding_box(&self) -> Option<BoundingBox> {
         match &self.current_box {
-            Some(x) => Some(x.copy()),
+            Some(x) => Some(x.clone()),
             None => None,
         }
     }
 
-    fn merge_paths(
+    fn merge_paths< PS: PointStore<Label,Attributes>, NS: NodeStore<Label,Attributes>>(
         &mut self,
         parent: usize,
         saved_box: Option<BoundingBox>,
@@ -746,7 +764,7 @@ where
         missing_coordinates: &[bool],
         node_store: &NS,
         point_store: &PS,
-    ) {
+    ) -> Result <()>{
         if node_store.use_path_for_box() {
             // both boxes, current and saved, should be present as invariant
             self.current_box
@@ -759,13 +777,14 @@ where
                 .unwrap()
                 .probability_of_cut_with_missing_coordinates(point, missing_coordinates);
         } else {
-            self.probability_of_cut = node_store.get_probability_of_cut_with_missing_coordinates(
+            self.probability_of_cut = node_store.probability_of_cut_with_missing_coordinates(
                 parent,
                 point,
                 missing_coordinates,
                 point_store,
-            );
+            )?;
         }
         self.current_node = parent;
+        Ok(())
     }
 }
diff --git a/Rust/src/samplerplustree/randomcuttree.rs b/Rust/src/samplerplustree/randomcuttree.rs
index c5da3f8c..44c78481 100644
--- a/Rust/src/samplerplustree/randomcuttree.rs
+++ b/Rust/src/samplerplustree/randomcuttree.rs
@@ -1,4 +1,6 @@
+use std::collections::HashMap;
 use std::fmt::Debug;
+use std::hash::Hash;
 
 use rand::{Rng, SeedableRng};
 use rand_chacha::ChaCha20Rng;
@@ -9,15 +11,17 @@ use crate::{
     samplerplustree::{
         boundingbox::BoundingBox,
         cut::Cut,
-        nodestore::{NodeStore, VectorNodeStore},
+        nodestore::{NodeStore, BasicStore, BoxStore, VectorNodeStore},
         nodeview::{MediumNodeView, UpdatableMultiNodeView, UpdatableNodeView},
     },
-    types::Location,
+    types::{Result, Location},
     visitor::{
         imputevisitor::ImputeVisitor,
         visitor::{SimpleMultiVisitor, Visitor, VisitorInfo},
     },
 };
+use crate::errors::RCFError;
+use crate::util::check_argument;
 
 extern crate rand;
 extern crate rand_chacha;
@@ -27,10 +31,10 @@ pub struct RCFTree<C, P, N>
 where
     C: Location,
     usize: From<C>,
-    P: Location,
+    P: Location + Eq + Hash,
     usize: From<P>,
     N: Location,
-    usize: From<N>,
+    usize: From<N>
 {
     dimensions: usize,
     capacity: usize,
@@ -39,73 +43,91 @@ where
     root: usize,
     tree_mass: usize,
     using_transforms: bool,
+    store_attributes: bool,
+    store_pointsum: bool,
+    propagate_attributes: bool,
 }
 
 impl<C, P, N> RCFTree<C, P, N>
 where
     C: Location,
     usize: From<C>,
-    P: Location,
+    P: Location + Eq + Hash,
     usize: From<P>,
     N: Location,
     usize: From<N>,
     <C as TryFrom<usize>>::Error: Debug,
     <P as TryFrom<usize>>::Error: Debug,
-    <N as TryFrom<usize>>::Error: Debug,
+    <N as TryFrom<usize>>::Error: Debug
 {
     pub fn new(
         dimensions: usize,
         capacity: usize,
         using_transforms: bool,
+        store_attributes: bool,
+        store_pointsum: bool,
+        propagate_attributes: bool,
         bounding_box_cache_fraction: f64,
         random_seed: u64,
-    ) -> Self {
+    ) -> Result<Self> {
         let project_to_tree: fn(Vec<f32>) -> Vec<f32> = { |x| x };
         let node_store = VectorNodeStore::<C, P, N>::new(
             capacity,
             dimensions,
             using_transforms,
+            store_attributes,
+            store_pointsum,
+            propagate_attributes,
             project_to_tree,
             bounding_box_cache_fraction,
-        );
+        )?;
         let root = node_store.null_node();
-        RCFTree {
+        Ok(RCFTree {
             dimensions,
             capacity,
             using_transforms,
+            store_attributes,
+            store_pointsum,
             random_seed,
             node_store,
             root,
             tree_mass: 0,
-        }
+            propagate_attributes
+        })
     }
 
-    pub fn add(
+    pub fn add<Label : Copy + Sync ,Attributes: Copy + Sync+ Hash + Eq + Send, PS: PointStore<Label,Attributes>>(
         &mut self,
         point_index: usize,
-        _point_attribute: usize,
-        point_store: &dyn PointStore,
-    ) -> usize {
+        point_attribute: usize,
+        point_store: &PS,
+    ) -> Result<usize> {
         if self.root == self.node_store.null_node() {
             self.root = self.node_store.leaf_index(point_index);
             self.tree_mass = 1;
-            point_index
+            if self.store_attributes {
+               self.node_store.add_attrib_at_leaf(point_index,point_attribute)?;
+            }
+            Ok(point_index)
         } else {
-            let point = &point_store.get_copy(point_index);
+            let point = &point_store.copy(point_index)?;
             let mut path_to_root = Vec::new();
             self.node_store
                 .set_path(&mut path_to_root, self.root, point);
             let (mut node, mut sibling) = path_to_root.pop().unwrap();
 
-            let leaf_point_index = self.node_store.get_point_index(node);
-            let old_point = &point_store.get_copy(leaf_point_index);
+            let leaf_point_index = self.node_store.leaf_point_index(node)?;
+            let old_point = &point_store.copy(leaf_point_index)?;
 
             self.tree_mass += 1;
             if point.eq(old_point) {
-                self.node_store.increase_leaf_mass(node);
+                self.node_store.increase_leaf_mass(node)?;
+                if self.store_attributes {
+                    self.node_store.add_attrib_at_leaf(leaf_point_index, point_attribute)?;
+                }
                 self.node_store
-                    .manage_ancestors_add(&mut path_to_root, point, point_store, true);
-                return leaf_point_index;
+                    .manage_ancestors_add(&mut path_to_root, point, point_store, true)?;
+                return Ok(leaf_point_index);
             } else {
                 let mut saved_parent = if path_to_root.len() != 0 {
                     path_to_root.last().unwrap().0
@@ -113,8 +135,8 @@ where
                     self.node_store.null_node()
                 };
                 let mut saved_node = node;
-                let mut current_box = BoundingBox::new(old_point, old_point);
-                let mut saved_box = current_box.copy();
+                let mut current_box = BoundingBox::new(old_point, old_point)?;
+                let mut saved_box = current_box.clone();
                 let mut parent_path: Vec<(usize, usize)> = Vec::new();
                 let mut rng = ChaCha20Rng::seed_from_u64(self.random_seed);
                 self.random_seed = rng.next_u64();
@@ -130,12 +152,12 @@ where
                         saved_cut = new_cut;
                         saved_parent = parent;
                         saved_node = node;
-                        saved_box = current_box.copy();
+                        saved_box = current_box.clone();
                         parent_path.clear();
                     } else {
                         parent_path.push((node, sibling));
                     }
-                    assert!(saved_cut.dimension != usize::MAX);
+                    check_argument(saved_cut.dimension != usize::MAX, "incorrect state")?;
 
                     if parent == self.node_store.null_node() {
                         break;
@@ -145,7 +167,7 @@ where
                             point_store,
                             parent,
                             sibling,
-                        );
+                        )?;
                         let (a, b) = path_to_root.pop().unwrap();
                         node = a;
                         sibling = b;
@@ -161,9 +183,9 @@ where
                     while !parent_path.is_empty() {
                         path_to_root.push(parent_path.pop().unwrap());
                     }
-                    assert!(path_to_root.last().unwrap().0 == saved_parent);
+                    check_argument(path_to_root.last().unwrap().0 == saved_parent, "incorrect state")?;
                 } else {
-                    assert!(path_to_root.len() == 0);
+                    check_argument(path_to_root.len() == 0, "incorrect state")?;
                 }
                 let merged_node = self.node_store.add_node(
                     saved_parent,
@@ -172,56 +194,61 @@ where
                     point_index,
                     saved_cut,
                     &saved_box,
-                );
+                )?;
 
+                if self.store_attributes {
+                    self.node_store.add_attrib_at_leaf(point_index,point_attribute)?;
+                }
+                if self.store_pointsum {
+                    self.node_store.recompute_pointsum(merged_node,point_store)?;
+                }
+                if self.propagate_attributes {
+                    self.node_store.recompute_attribute_vec(merged_node,point_store)?;
+                }
                 if saved_parent != self.node_store.null_node() {
                     self.node_store.manage_ancestors_add(
                         &mut path_to_root,
                         point,
                         point_store,
                         false,
-                    );
+                    )?;
                 } else {
                     self.root = merged_node;
                 }
             }
-            point_index
+            Ok(point_index)
         }
     }
 
-    pub fn delete(
+    pub fn delete<Label : Copy + Sync ,Attributes: Copy + Sync+ Hash + Eq + Send,PS:PointStore<Label,Attributes>>(
         &mut self,
         point_index: usize,
-        _point_attribute: usize,
-        point_store: &dyn PointStore,
-    ) -> usize {
-        if self.root == self.node_store.null_node() {
-            println!(" deleting from an empty tree");
-            panic!();
-        }
+        point_attribute: usize,
+        point_store: &PS
+    ) -> Result<usize> {
+        check_argument(self.root != self.node_store.null_node() ," deleting from an empty tree")?;
+
         self.tree_mass = self.tree_mass - 1;
-        let point = &point_store.get_copy(point_index);
+        let point = &point_store.copy(point_index)?;
         let mut leaf_path = Vec::new();
         self.node_store.set_path(&mut leaf_path, self.root, point);
         let (leaf_node, leaf_saved_sibling) = leaf_path.pop().unwrap();
 
-        let leaf_point_index = self.node_store.get_point_index(leaf_node);
+        let leaf_point_index = self.node_store.leaf_point_index(leaf_node)?;
 
         if leaf_point_index != point_index {
-            if !point_store.is_equal(point, leaf_point_index) {
-                println!(
-                    " deleting wrong node; looking for {} found {}",
-                    point_index, leaf_point_index
-                );
-                let old_point = point_store.get_copy(leaf_point_index);
-                for j in 0..self.dimensions.into() {
-                    println!("want {} found {}", point[j], old_point[j]);
-                }
-                panic!();
+            if !point_store.is_equal(point, leaf_point_index)? {
+                return Err(RCFError::InvalidArgument {
+                    msg: " deleting wrong node "
+                });
             }
         }
 
-        if self.node_store.decrease_leaf_mass(leaf_node) == 0 {
+        if self.store_attributes {
+            self.node_store.del_attrib_at_leaf(leaf_point_index, point_attribute)?;
+        }
+
+        if self.node_store.decrease_leaf_mass(leaf_node)? == 0 {
             if leaf_path.len() == 0 {
                 self.root = self.node_store.null_node();
             } else {
@@ -243,19 +270,22 @@ where
                         point,
                         point_store,
                         false,
-                    );
+                    )?;
                 }
 
-                self.node_store.delete_internal_node(parent);
+                self.node_store.delete_internal_node(parent)?;
+                if self.store_pointsum {
+                    self.node_store.invalidate_pointsum(parent)?;
+                }
             }
         } else {
             self.node_store
-                .manage_ancestors_delete(&mut leaf_path, point, point_store, true);
+                .manage_ancestors_delete(&mut leaf_path, point, point_store, true)?;
         }
-        leaf_point_index
+        Ok(leaf_point_index)
     }
 
-    pub fn conditional_field<PS: PointStore>(
+    pub fn conditional_field<Label : Copy + Sync ,Attributes: Copy + Sync+ Hash + Eq + Send,PS: PointStore<Label,Attributes>>(
         &self,
         missing: &[usize],
         point: &[f32],
@@ -263,12 +293,14 @@ where
         centrality: f64,
         seed: u64,
         visitor_info: &VisitorInfo,
-    ) -> (f64, usize, f64) {
+    ) -> Result<(f64, usize, f64)> {
         if self.root == self.node_store.null_node() {
-            return (0.0, usize::MAX, 0.0);
+            return Ok((0.0, usize::MAX, 0.0));
         }
         let mut visitor = ImputeVisitor::new(missing, centrality, self.tree_mass, seed);
-        let mut node_view = MediumNodeView::new(self.root, &self.node_store);
+        let (cut_dimension, cut_value, _left_child, _right_child) = self.node_store.cut_and_children(self.root);
+        let mass = self.node_store.mass(self.root);
+        let mut node_view = MediumNodeView::new::<Label,Attributes>(self.root, cut_dimension,cut_value,mass);
         let mut missing_coordinates = vec![false; self.dimensions];
         for i in missing.iter() {
             missing_coordinates[*i] = true;
@@ -280,11 +312,11 @@ where
             point,
             &missing_coordinates,
             point_store,
-        );
+        )?;
         visitor.result(&visitor_info)
     }
 
-    pub fn traverse_multi_with_missing_coordinates<V, NodeView, PS, R>(
+    pub fn traverse_multi_with_missing_coordinates<V, NodeView, PS, R, Label, Attributes>(
         &self,
         node_view: &mut NodeView,
         visitor: &mut V,
@@ -292,15 +324,17 @@ where
         point: &[f32],
         missing_coordinates: &[bool],
         point_store: &PS,
-    ) where
+    ) -> Result<()> where
         V: SimpleMultiVisitor<NodeView, R>,
-        NodeView: UpdatableMultiNodeView<VectorNodeStore<C, P, N>, PS>,
-        PS: PointStore,
+        Label: Copy + Sync,
+        Attributes : Copy + Sync+ Hash + Eq + Send,
+        NodeView: UpdatableMultiNodeView<Label,Attributes>,
+        PS: PointStore<Label,Attributes>,
     {
-        let node = node_view.get_current_node();
+        let node = node_view.current_node();
         if self.node_store.is_leaf(node) {
-            node_view.update_at_leaf(point, node, &self.node_store, &point_store, &visitor_info);
-            visitor.accept_leaf(point, visitor_info, node_view);
+            node_view.update_at_leaf(point, node, &self.node_store, point_store, &visitor_info)?;
+            visitor.accept_leaf(point, visitor_info, node_view)?;
         } else {
             let parent = node;
             node_view.set_trigger_traversing_down(
@@ -310,9 +344,9 @@ where
                 point_store,
                 visitor_info,
             );
-            if missing_coordinates[self.node_store.get_cut_dimension(parent)] {
-                let right = self.node_store.get_left_index(parent);
-                let left = self.node_store.get_right_index(parent);
+            if missing_coordinates[self.node_store.cut_dimension(parent)] {
+                let right = self.node_store.left_index(parent);
+                let left = self.node_store.right_index(parent);
                 node_view.set_current_node(left);
                 self.traverse_multi_with_missing_coordinates(
                     node_view,
@@ -321,8 +355,8 @@ where
                     point,
                     missing_coordinates,
                     point_store,
-                );
-                let saved_box = node_view.get_bounding_box();
+                )?;
+                let saved_box = node_view.bounding_box();
                 node_view.set_current_node(right);
                 self.traverse_multi_with_missing_coordinates(
                     node_view,
@@ -331,9 +365,9 @@ where
                     point,
                     missing_coordinates,
                     point_store,
-                );
-                visitor.combine_branches(point, &node_view, visitor_info);
-                if !visitor.is_converged() {
+                )?;
+                visitor.combine_branches(point, &node_view, visitor_info)?;
+                if !visitor.is_converged()? {
                     node_view.merge_paths(
                         parent,
                         saved_box,
@@ -341,7 +375,7 @@ where
                         missing_coordinates,
                         &self.node_store,
                         point_store,
-                    );
+                    )?;
                 }
             } else {
                 node_view.update_from_node_traversing_down(
@@ -350,7 +384,7 @@ where
                     &self.node_store,
                     point_store,
                     &visitor_info,
-                );
+                )?;
                 self.traverse_multi_with_missing_coordinates(
                     node_view,
                     visitor,
@@ -358,8 +392,8 @@ where
                     point,
                     missing_coordinates,
                     point_store,
-                );
-                if !visitor.is_converged() {
+                )?;
+                if !visitor.is_converged()? {
                     node_view.update_view_to_parent_with_missing_coordinates(
                         parent,
                         point,
@@ -367,44 +401,47 @@ where
                         &self.node_store,
                         point_store,
                         &visitor_info,
-                    );
+                    )?;
                 }
             }
-            if !visitor.is_converged() {
-                visitor.accept(point, visitor_info, node_view);
+            if !visitor.is_converged()? {
+                visitor.accept(point, visitor_info, node_view)?;
             }
         }
+        Ok(())
     }
 
     pub fn get_size(&self) -> usize {
-        self.node_store.get_size(self.dimensions.into()) + std::mem::size_of::<RCFTree<C, P, N>>()
+        self.node_store.size(self.dimensions.into()) + std::mem::size_of::<RCFTree<C, P, N>>()
     }
 
-    fn traverse_recursive<R, PS, NodeView, V>(
+    fn traverse_recursive<R, PS, NodeView, V,Label,Attributes>(
         &self,
         point: &[f32],
         node_view: &mut NodeView,
         visitor: &mut V,
         visitor_info: &VisitorInfo,
         point_store: &PS,
-    ) where
-        PS: PointStore,
+    ) -> Result<()> where
+        PS: PointStore<Label,Attributes>,
         V: Visitor<NodeView, R>,
         R: Clone,
-        NodeView: UpdatableNodeView<VectorNodeStore<C, P, N>, PS>,
+        Label: Copy + Sync,
+        Attributes : Copy + Sync+ Hash + Eq + Send,
+        NodeView: UpdatableNodeView<Label,Attributes>,
     {
-        let current_node = node_view.get_current_node();
+        let current_node = node_view.current_node();
         if self.node_store.is_leaf(current_node) {
             node_view.update_at_leaf(
                 point,
                 current_node,
                 &self.node_store,
-                &point_store,
+                point_store,
                 &visitor_info,
-            );
-            visitor.accept_leaf(point, visitor_info, &node_view);
+            )?;
+            visitor.accept_leaf(point, visitor_info, &node_view)?;
             if visitor.use_shadow_box() {
-                node_view.set_use_shadow_box(&self.node_store, point_store);
+                node_view.set_use_shadow_box(&self.node_store, point_store)?;
             }
         } else {
             node_view.update_from_node_traversing_down(
@@ -413,31 +450,30 @@ where
                 &self.node_store,
                 point_store,
                 visitor_info,
-            );
-            self.traverse_recursive(point, node_view, visitor, visitor_info, point_store);
-            if !visitor.is_converged() {
+            )?;
+            self.traverse_recursive(point, node_view, visitor, visitor_info, point_store)?;
+            if !visitor.is_converged()? {
                 node_view.update_from_node_traversing_up(
                     point,
                     current_node,
                     &self.node_store,
-                    &point_store,
+                    point_store,
                     &visitor_info,
-                );
-                visitor.accept(point, visitor_info, &node_view);
+                )?;
+                visitor.accept(point, visitor_info, &node_view)?;
             }
         }
+        Ok(())
     }
 }
 
-pub trait Traversable<NodeView, N, PS, V, R>
+pub trait Traversable<NodeView, V, R, Label,Attributes>
 where
-    N: Location,
-    <N as TryFrom<usize>>::Error: Debug,
-    usize: From<N>,
-    PS: PointStore,
     V: Visitor<NodeView, R>,
+    Label: Copy + Sync,
+    Attributes: Copy + Sync+ Hash + Eq + Send,
 {
-    fn traverse(
+    fn traverse<PS: PointStore<Label,Attributes>>(
         &self,
         point: &[f32],
         parameters: &[usize],
@@ -445,26 +481,28 @@ where
         visitor_info: &VisitorInfo,
         point_store: &PS,
         default: &R,
-    ) -> R;
+    ) -> Result<R>;
 }
 
-impl<C, P, N, PS, NodeView, V, R> Traversable<NodeView, N, PS, V, R> for RCFTree<C, P, N>
+impl<C, P, N, NodeView, V, R, Label,Attributes> Traversable<NodeView, V, R,Label,Attributes>
+for RCFTree<C, P, N>
 where
     C: Location,
     <C as TryFrom<usize>>::Error: Debug,
     usize: From<C>,
-    P: Location,
+    P: Location + Eq + Hash,
     <P as TryFrom<usize>>::Error: Debug,
     usize: From<P>,
     N: Location,
     <N as TryFrom<usize>>::Error: Debug,
     usize: From<N>,
-    PS: PointStore,
-    NodeView: UpdatableNodeView<VectorNodeStore<C, P, N>, PS>,
+    Label: Copy + Sync,
+    Attributes : Copy + Sync+ Hash + Eq + Send,
+    NodeView: UpdatableNodeView<Label,Attributes>,
     V: Visitor<NodeView, R>,
     R: Clone,
 {
-    fn traverse(
+    fn traverse<PS: PointStore<Label,Attributes>>(
         &self,
         point: &[f32],
         parameters: &[usize],
@@ -472,9 +510,9 @@ where
         visitor_info: &VisitorInfo,
         point_store: &PS,
         default: &R,
-    ) -> R {
+    ) -> Result<R> {
         if self.root == self.node_store.null_node() {
-            return default.clone();
+            return Ok(default.clone());
         }
         let mut visitor = visitor_factory(self.tree_mass, parameters, &visitor_info);
         let mut node_view = NodeView::create(self.root, &self.node_store);
@@ -483,8 +521,8 @@ where
             &mut node_view,
             &mut visitor,
             &visitor_info,
-            &point_store,
-        );
+            point_store,
+        )?;
         visitor.result(visitor_info)
     }
 }
diff --git a/Rust/src/samplerplustree/sampler.rs b/Rust/src/samplerplustree/sampler.rs
index 1b08c229..f5dbaacf 100644
--- a/Rust/src/samplerplustree/sampler.rs
+++ b/Rust/src/samplerplustree/sampler.rs
@@ -1,6 +1,8 @@
 use std::fmt::Debug;
 
 use crate::types::Max;
+use crate::util::check_argument;
+use crate::types::Result;
 
 #[repr(C)]
 pub struct Sampler<P> {
@@ -23,16 +25,16 @@ pub struct SamplerAcceptState {
 
 impl<P: Max + Copy + std::cmp::PartialEq> Sampler<P>
 where
-    P: std::convert::TryFrom<usize>,
+    P: TryFrom<usize>,
     usize: From<P>,
 {
-    pub fn new(capacity: usize, store_attributes: bool) -> Self {
+    pub fn new(capacity: usize, store_attributes: bool) -> Result<Self> {
         let attrib_vec: Vec<P> = if store_attributes {
             vec![P::MAX; capacity]
         } else {
             Vec::new()
         };
-        Sampler {
+        Ok(Sampler {
             store_attributes,
             capacity,
             weights: vec![0.0; capacity],
@@ -40,14 +42,14 @@ where
             point_attributes: attrib_vec,
             accepted_state: (0.0, usize::MAX, usize::MAX),
             current_size: 0,
-        }
+        })
     }
 
     pub fn get_references(&self) -> &[P] {
         &self.points[0..self.current_size]
     }
 
-    fn swap_down(&mut self, start_index: usize, validate: bool) {
+    fn swap_down(&mut self, start_index: usize, validate: bool) -> Result<()>{
         let mut current: usize = start_index;
         while 2 * current + 1 < self.current_size {
             let mut max_index: usize = 2 * current + 1;
@@ -57,28 +59,25 @@ where
                 max_index = 2 * current + 2;
             }
             if self.weights[max_index] > self.weights[current] {
-                if validate {
-                    println!("the heap property is not satisfied at index '{}' ", current);
-                    panic!();
-                }
-                self.swap_weights(current, max_index);
+                check_argument(!validate, "the heap property is not satisfied")?;
+                self.swap_weights(current, max_index)?;
                 current = max_index;
             } else {
                 break;
             }
         }
+        Ok(())
     }
 
-    pub fn reheap(&mut self, validate: bool) {
+    pub fn reheap(&mut self, validate: bool) -> Result<()>{
         for i in ((self.current_size + 1) / 2)..=0 {
-            self.swap_down(i, validate);
+            self.swap_down(i, validate)?;
         }
+        Ok(())
     }
 
-    fn swap_weights(&mut self, a: usize, b: usize) {
-        if self.points[a] == P::MAX || self.points[b] == P::MAX {
-            panic!();
-        }
+    fn swap_weights(&mut self, a: usize, b: usize) -> Result<()>{
+        check_argument( self.points[a] != P::MAX && self.points[b] != P::MAX, "incorrect state in sampler swap")?;
 
         let tmp: P = self.points[a];
         self.points[a] = self.points[b];
@@ -93,19 +92,17 @@ where
             self.point_attributes[a] = self.point_attributes[b];
             self.point_attributes[b] = tmp_attrib;
         }
+        Ok(())
     }
 
-    pub fn add_point(&mut self, point_index: usize)
+    pub fn add_point(&mut self, point_index: usize) -> Result<()>
     where
         <P as TryFrom<usize>>::Error: Debug,
     {
         if point_index != usize::MAX {
-            assert!(self.current_size < self.capacity.into(), "sampler full");
-            assert_ne!(
-                self.accepted_state.1,
-                usize::MAX,
-                "this method should only be called after a successful call to accept_sample(long)"
-            );
+            check_argument(self.current_size < self.capacity.into(), "sampler full")?;
+            check_argument(self.accepted_state.1 !=  usize::MAX,
+                "this method should only be called after a successful call to accept_sample(long)")?;
 
             self.weights[self.current_size] = self.accepted_state.0;
             self.points[self.current_size] = point_index.try_into().unwrap();
@@ -126,7 +123,7 @@ where
             while current > 0 {
                 let tmp = (current - 1) / 2;
                 if self.weights[tmp] < self.weights[current] {
-                    self.swap_weights(current, tmp);
+                    self.swap_weights(current, tmp)?;
                     current = tmp;
                 } else {
                     break;
@@ -135,6 +132,7 @@ where
             // resetting the state
             self.accepted_state = (0.0, usize::MAX, usize::MAX);
         }
+        Ok(())
     }
 
     pub fn accept_point(
@@ -143,23 +141,23 @@ where
         weight: f32,
         point_index: usize,
         attribute: usize,
-    ) -> SamplerAcceptState {
+    ) -> Result<SamplerAcceptState> {
         let mut return_val = (true, usize::MAX, weight, usize::MAX);
         if initial || (weight < self.weights[0]) {
             self.accepted_state = (weight, point_index, attribute);
             if !initial {
-                let partial = self.evict_max();
+                let partial = self.evict_max()?;
                 return_val = (true, partial.0, partial.1, partial.2);
             }
         } else {
             return_val.0 = false;
         }
-        return SamplerAcceptState {
+        Ok(SamplerAcceptState {
             eviction_occurred: return_val.0,
             point_index: return_val.1,
             evicted_weight: return_val.2,
             point_attribute: return_val.3,
-        };
+        })
     }
 
     /**
@@ -167,7 +165,7 @@ where
      * change the size of the sampler and associated tree
      */
 
-    pub fn evict_max(&mut self) -> (usize, f32, usize) {
+    pub fn evict_max(&mut self) -> Result<(usize, f32, usize)> {
         let evicted_attribute_index: usize = if self.store_attributes {
             self.point_attributes[0].into()
         } else {
@@ -186,9 +184,9 @@ where
         if self.store_attributes {
             self.point_attributes[0] = self.point_attributes[current];
         }
-        self.swap_down(0, false);
+        self.swap_down(0, false)?;
 
-        evicted_point
+        Ok(evicted_point)
     }
 
     pub fn is_full(&self) -> bool {
diff --git a/Rust/src/samplerplustree/samplerplustree.rs b/Rust/src/samplerplustree/samplerplustree.rs
index 14dd402f..9d7f3b66 100644
--- a/Rust/src/samplerplustree/samplerplustree.rs
+++ b/Rust/src/samplerplustree/samplerplustree.rs
@@ -2,6 +2,7 @@ extern crate rand;
 extern crate rand_chacha;
 
 use std::fmt::Debug;
+use std::hash::Hash;
 
 use rand::{Rng, SeedableRng};
 use rand_chacha::ChaCha20Rng;
@@ -15,19 +16,20 @@ use crate::{
         randomcuttree::{RCFTree, Traversable},
         sampler::Sampler,
     },
-    types::Location,
+    types::{Location,Result},
     visitor::visitor::{Visitor, VisitorInfo},
 };
+use crate::samplerplustree::nodestore::NodeStore;
 
 #[repr(C)]
 pub struct SamplerPlusTree<C, P, N>
 where
     C: Location,
     usize: From<C>,
-    P: Location,
+    P: Location + Eq + Hash,
     usize: From<P>,
     N: Location,
-    usize: From<N>,
+    usize: From<N>
 {
     tree: RCFTree<C, P, N>,
     sampler: Sampler<P>,
@@ -42,7 +44,7 @@ impl<C, P, N> SamplerPlusTree<C, P, N>
 where
     C: Location,
     usize: From<C>,
-    P: Location,
+    P: Location + Eq + Hash,
     usize: From<P>,
     N: Location,
     usize: From<N>,
@@ -56,14 +58,16 @@ where
         using_transforms: bool,
         random_seed: u64,
         store_attributes: bool,
+        store_pointsum: bool,
+        propagate_attribute_vectors: bool,
         time_decay: f64,
         initial_accept_fraction: f64,
         bounding_box_cache_fraction: f64,
-    ) -> Self {
+    ) -> Result<Self> {
         let mut rng = ChaCha20Rng::seed_from_u64(random_seed);
         let self_seed = rng.next_u64();
 
-        SamplerPlusTree {
+        Ok(SamplerPlusTree {
             time_decay,
             initial_accept_fraction,
             using_transforms,
@@ -71,21 +75,24 @@ where
                 dimensions,
                 capacity,
                 using_transforms,
+                store_attributes,
+                store_pointsum,
+                propagate_attribute_vectors,
                 bounding_box_cache_fraction,
                 rng.next_u64(),
-            ),
-            sampler: Sampler::new(capacity, store_attributes),
+            )?,
+            sampler: Sampler::new(capacity, store_attributes)?,
             entries_seen: 0,
             random_seed: self_seed,
-        }
+        })
     }
 
-    pub fn update(
+    pub fn update<Label : Copy + Sync ,Attributes: Copy + Sync+ Hash + Eq + Send, PS: PointStore<Label,Attributes>>(
         &mut self,
         point_index: usize,
         point_attribute: usize,
-        point_store: &dyn PointStore,
-    ) -> (usize, usize) {
+        point_store: &PS
+    ) -> Result<((usize, usize),(usize,usize))> {
         if point_index != usize::MAX {
             let mut initial = false;
             let mut rng = ChaCha20Rng::seed_from_u64(self.random_seed);
@@ -100,29 +107,29 @@ where
             }
             let accept_state =
                 self.sampler
-                    .accept_point(initial, weight as f32, point_index, point_attribute);
+                    .accept_point(initial, weight as f32, point_index, point_attribute)?;
 
             self.entries_seen += 1;
             if accept_state.eviction_occurred {
                 let delete_ref = if accept_state.point_index != usize::MAX {
-                    self.tree.delete(
+                    (self.tree.delete(
                         accept_state.point_index,
                         accept_state.point_attribute,
                         point_store,
-                    )
+                    )?,accept_state.point_attribute)
                 } else {
-                    usize::MAX
+                    (usize::MAX,usize::MAX)
                 };
 
                 // the tree may choose to return a reference to an existing point
                 // whose value is equal to `point`
-                let added_ref = self.tree.add(point_index, point_attribute, point_store);
+                let added_ref = self.tree.add(point_index, point_attribute, point_store)?;
 
-                self.sampler.add_point(added_ref);
-                return (added_ref, delete_ref);
+                self.sampler.add_point(added_ref)?;
+                return Ok(((added_ref,point_attribute), delete_ref));
             }
         }
-        (usize::MAX, usize::MAX)
+        Ok(((usize::MAX, usize::MAX),(usize::MAX,usize::MAX)))
     }
 
     fn initial_accept_probability(&self, fill_fraction: f64) -> f64 {
@@ -136,7 +143,7 @@ where
         };
     }
 
-    pub fn simple_traversal<NodeView, V, R, PS>(
+    pub fn simple_traversal<NodeView, V, R, PS,Label,Attributes>(
         &self,
         point: &[f32],
         point_store: &PS,
@@ -144,11 +151,13 @@ where
         visitor_info: &VisitorInfo,
         visitor_factory: fn(usize, &[usize], &VisitorInfo) -> V,
         default: &R,
-    ) -> R
+    ) -> Result<R>
     where
-        NodeView: UpdatableNodeView<VectorNodeStore<C, P, N>, PS>,
+        NodeView: UpdatableNodeView<Label,Attributes>,
         V: Visitor<NodeView, R>,
-        PS: PointStore,
+        Label : Sync + Copy,
+        Attributes: Copy + Sync+ Hash + Eq + Send,
+        PS: PointStore<Label,Attributes>,
         R: Clone,
     {
         self.tree.traverse(
@@ -161,16 +170,16 @@ where
         )
     }
 
-    pub fn conditional_field<PS>(
+    pub fn conditional_field<Label : Copy + Sync ,Attributes: Copy + Sync+ Hash + Eq + Send, PS>(
         &self,
         positions: &[usize],
         centrality: f64,
         point: &[f32],
         point_store: &PS,
         visitor_info: &VisitorInfo,
-    ) -> (f64, usize, f64)
+    ) -> Result<(f64, usize, f64)>
     where
-        PS: PointStore,
+        PS: PointStore<Label,Attributes>
     {
         self.tree.conditional_field(
             positions,
diff --git a/Rust/src/trcf/basicthresholder.rs b/Rust/src/trcf/basicthresholder.rs
index 48f902ff..b6d858ab 100644
--- a/Rust/src/trcf/basicthresholder.rs
+++ b/Rust/src/trcf/basicthresholder.rs
@@ -1,28 +1,28 @@
 
 use crate::common::deviation::Deviation;
+use crate::trcf::types::TransformMethod;
+use crate::trcf::types::TransformMethod::{DIFFERENCE, NONE, NORMALIZE_DIFFERENCE};
+use crate::util::{maxf32, minf32};
+use crate::types::Result;
 
 const DEFAULT_ELASTICITY : f32= 0.01;
-const DEFAULT_HORIZON : f32 = 0.5;
-const DEFAULT_HORIZON_ONED : f32 = 0.75;
+const DEFAULT_SCORE_DIFFERENCING: f32 = 0.5;
+
 const DEFAULT_MINIMUM_SCORES : i32 = 10;
 const DEFAULT_ABSOLUTE_THRESHOLD : f32= 0.8;
 const DEFAULT_ABSOLUTE_SCORE_FRACTION :f32 = 0.5;
-const DEFAULT_UPPER_THRESHOLD :f32= 2.0;
 const DEFAULT_LOWER_THRESHOLD :f32 = 1.0;
-const DEFAULT_LOWER_THRESHOLD_ONED :f32 = 1.1;
-const DEFAULT_LOWER_THRESHOLD_NORMALIZED : f32 = 0.9;
 const DEFAULT_INITIAL_THRESHOLD :f32= 1.5;
-const DEFAULT_Z_FACTOR :f32 = 2.5;
-const DEFAULT_UPPER_FACTOR :f32 = 5.0;
-const DEFAULT_AUTO_ADJUST_LOWER_THRESHOLD :bool = false;
-const DEFAULT_THRESHOLD_STEP :f32 = 0.1;
+const DEFAULT_Z_FACTOR :f32 = 3.0;
+const MINIMUM_Z_FACTOR : f32 = 2.0;
+const DEFAULT_FACTOR_ADJUSTMENT_THRESHOLD : f32 = 0.9;
 
 #[repr(C)]
 #[derive(Clone)]
 pub struct BasicThresholder {
     elasticity: f32,
     count: i32,
-    horizon: f32,
+    score_differencing: f32,
     last_score: f32,
     primary_deviation: Deviation,
     secondary_deviation: Deviation,
@@ -30,39 +30,35 @@ pub struct BasicThresholder {
     auto_threshold: bool,
     absolute_threshold:f32,
     absolute_score_fraction: f32,
-    upper_threshold: f32,
     lower_threshold: f32,
+    factor_adjustment_threshold: f32,
     initial_threshold: f32,
     z_factor: f32,
-    upper_z_factor: f32,
-    in_potential_anomaly: bool,
     minimum_scores: i32,
 }
 
 impl BasicThresholder {
-    pub fn new_adjustible(discount : f32, adjust:bool) -> Self {
-        BasicThresholder{
+    pub fn new_adjustible(discount : f64, adjust:bool) -> Result<Self> {
+        Ok(BasicThresholder{
             elasticity: DEFAULT_ELASTICITY,
             count: 0,
-            horizon: DEFAULT_HORIZON,
+            score_differencing: DEFAULT_SCORE_DIFFERENCING,
             last_score: 0.0,
-            primary_deviation: Deviation::new(discount as f64),
-            secondary_deviation: Deviation::new(discount as f64),
-            threshold_deviation: Deviation::new(discount as f64/2.0),
+            primary_deviation: Deviation::new(discount as f64)?,
+            secondary_deviation: Deviation::new(discount as f64)?,
+            threshold_deviation: Deviation::new(discount as f64/2.0)?,
             auto_threshold: adjust,
             absolute_threshold: DEFAULT_ABSOLUTE_THRESHOLD,
             absolute_score_fraction: DEFAULT_ABSOLUTE_SCORE_FRACTION,
-            upper_threshold: DEFAULT_UPPER_THRESHOLD,
             lower_threshold: DEFAULT_LOWER_THRESHOLD,
+            factor_adjustment_threshold: DEFAULT_FACTOR_ADJUSTMENT_THRESHOLD,
             initial_threshold: DEFAULT_INITIAL_THRESHOLD,
             z_factor: DEFAULT_Z_FACTOR,
-            upper_z_factor: DEFAULT_UPPER_FACTOR,
-            in_potential_anomaly: false,
             minimum_scores: DEFAULT_MINIMUM_SCORES
-        }
+        })
     }
 
-    pub fn new(discount : f32) -> Self{
+    pub fn new(discount : f64) -> Result<Self>{
         BasicThresholder::new_adjustible(discount,false)
     }
 
@@ -70,15 +66,10 @@ impl BasicThresholder {
         if self.count < self.minimum_scores {
             return false;
         }
-
-        if self.horizon == 0.0 {
-            return self.secondary_deviation.count() >= self.minimum_scores;
-        } else if self.horizon == 1.0 {
+        if self.score_differencing != 0.0 {
             return self.primary_deviation.count() >= self.minimum_scores;
-        } else {
-            return self.secondary_deviation.count() >= self.minimum_scores
-                && self.primary_deviation.count() >= self.minimum_scores;
         }
+        return true;
     }
 
     fn intermediate_fraction(&self) -> f32 {
@@ -91,78 +82,120 @@ impl BasicThresholder {
         }
     }
 
-    fn short_term_threshold(&self, factor : f32, intermediate_fraction : f32) -> f32{
-        if !self.is_deviation_ready() { // count < minimumScore is this branch
-            f32::max(self.initial_threshold,self.lower_threshold)
+    fn adjusted_factor(&self, factor : f32, method:TransformMethod, _dimension:usize) -> f32 {
+        let base = self.primary_deviation.mean();
+        let corrected_factor = if (base as f32) < self.factor_adjustment_threshold && method != NONE {
+            (base as f32) * factor / self.factor_adjustment_threshold
+        } else {
+            factor
+        };
+        if corrected_factor < MINIMUM_Z_FACTOR {
+            MINIMUM_Z_FACTOR
         } else {
-            let t = intermediate_fraction *self.longterm_threshold(factor) +
-                (1.0 -intermediate_fraction)*self.initial_threshold;
-            f32::max(t,self.lower_threshold)
+            corrected_factor
         }
     }
 
-    pub fn threshold(&self) -> f32{
-        return self.longterm_threshold(self.z_factor);
-    }
-
-    pub fn longterm_threshold(&self, factor:f32) -> f32 {
-        let t= (self.primary_deviation.mean() as f32) + factor * self.longterm_deviation();
-        f32::min(t,self.lower_threshold)
+    fn long_term_deviation(&self, method : TransformMethod, shingle_size:usize) -> f32{
+        if shingle_size == 1 && !(method == DIFFERENCE || method == NORMALIZE_DIFFERENCE) {
+            minf32((f64::sqrt(2.0)*self.threshold_deviation.mean()) as f32,self.primary_deviation.mean() as f32)
+        } else {
+            let mut first = self.primary_deviation.deviation();
+            let t = f64::sqrt(2.0) * self.threshold_deviation.deviation();
+            if t < first {
+                first = t;
+            }
+            if self.secondary_deviation.deviation() < first {
+                first = self.secondary_deviation.deviation();
+            }
+            self.score_differencing * (first as f32) + (1.0 - self.score_differencing) * (self.secondary_deviation.deviation() as f32)
+        }
     }
 
-    fn longterm_deviation(&self) -> f32{
-        self.horizon * (self.primary_deviation.deviation() as f32) + (1.0 - self.horizon) * (self.secondary_deviation.deviation() as f32)
+    pub fn threshold_and_grade(&self, score : f32, method: TransformMethod, dimension : usize,
+                               shingle_size : usize)  -> ( f32, f32) {
+        self.threshold_and_grade_with_factor(score,self.z_factor,method,dimension,shingle_size)
     }
 
-    pub fn anomaly_grade_with_factor(&self, score : f32, previous : bool, factor: f32) -> f32{
-        assert!(factor >= self.z_factor, "incorrect call");
-
-        let elastic_addition = if previous {self.elasticity} else {0.0};
+    pub fn threshold_and_grade_with_factor(&self, score : f32, factor : f32, method: TransformMethod, dimension : usize,
+                                   shingle_size : usize)  -> ( f32, f32) {
         let intermediate_fraction = self.intermediate_fraction();
-        if intermediate_fraction == 1.0 {
-            if score < self.longterm_threshold(factor) - elastic_addition {
-                return 0.0;
+        let new_factor = self.adjusted_factor(factor, method, dimension);
+        let long_term = self.long_term_deviation(method, shingle_size);
+        let scaled_deviation = (new_factor - 1.0) * long_term + self.primary_deviation.deviation() as f32;
+
+        let mut absolute = self.absolute_threshold;
+        let t = self.primary_deviation.mean() as f32;
+        if self.auto_threshold && intermediate_fraction >= 1.0 && t <
+            self.factor_adjustment_threshold {
+            absolute = t * absolute / self.factor_adjustment_threshold;
+        }
+        let threshold = if !self.is_deviation_ready() {
+            maxf32(self.initial_threshold,absolute)
+        } else {
+            let t = intermediate_fraction * (self.primary_deviation.mean() as f32 + scaled_deviation) +
+                (1.0 - intermediate_fraction) * self.initial_threshold;
+            maxf32(t,absolute)
+        };
+
+        if   (score as f32) < threshold || threshold == 0.0 {
+            return (threshold, 0.0);
+        } else {
+            let mut t = self.surprise_index(score, threshold, new_factor, scaled_deviation / new_factor);
+            t = minf32(f32::floor(t * 20.0) / 16.0,1.0);
+            if t > 0.0 { (threshold, t) } else {
+                (score as f32, 0.0)
             }
-            let mut t_factor = self.upper_z_factor;
-            let longterm_deviation = self.longterm_deviation();
-            if longterm_deviation > 0.0 {
-                let t =  (score - self.primary_deviation.mean() as f32) / longterm_deviation;
-                if (t as f32) < t_factor {
-                    t_factor = t as f32;
-                }
+        }
+    }
+
+    fn surprise_index(&self, score: f32, base : f32, factor: f32, deviation : f32)  -> f32 {
+        if self.is_deviation_ready() {
+            let mut t_factor = 2.0 * factor;
+            if deviation > 0.0 {
+                let z = (score as f32 - base) / deviation;
+                t_factor = minf32(z,factor);
             }
-            return (t_factor - self.z_factor) / (self.upper_z_factor - self.z_factor);
+            t_factor = t_factor/factor;
+            maxf32(t_factor,0.0)
         } else {
-            let t = self.short_term_threshold(factor, intermediate_fraction);
-            if score < t - elastic_addition {
-                return 0.0;
+            let t = ((score as f32) - self.absolute_threshold) / self.absolute_threshold;
+            minf32(1.0,maxf32(t,0.0))
+        }
+    }
+
+
+    pub fn threshold(&self) -> f32 {
+        self.primary_deviation.mean() as f32 + self.z_factor * self.primary_deviation.deviation() as f32
+    }
+
+    pub fn primary_grade(&self, score : f32) -> f32 {
+        if !self.is_deviation_ready() {
+            return 0.0;
+        }
+        let threshold = self.threshold();
+        let mut t = score - threshold;
+        let deviation = self.primary_deviation.deviation() as f32;
+        if t>0.0 {
+            if deviation > 0.0 {
+                t = t/(deviation);
+                return minf32(t,1.0);
+            } else {
+                return 0.1;
             }
-            let upper = if self.upper_threshold > 2.0 * t {self.upper_threshold} else {2.0*t};
-            let quasi_score = if score <upper {score} else {upper};
-            return (quasi_score - t) / (upper - t);
+        } else {
+            return 0.0;
         }
     }
 
-    pub fn anomaly_grade(&self, score : f32, previous : bool) -> f32{
-        return self.anomaly_grade_with_factor(score, previous, self.z_factor);
+    pub fn primary_threshold_and_grade(&self, score: f32) -> (f32,f32) {
+        (self.threshold(),self.primary_grade(score))
     }
 
     pub fn update_threshold(&mut self, score:f32) {
-        let gap : f32 = if score > self.lower_threshold {1.0} else {0.0};
-        self.threshold_deviation.update(gap as f64);
-        if self.auto_threshold && self.threshold_deviation.count() > self.minimum_scores {
-            // note the rate is set at half the anomaly rate
-            if self.threshold_deviation.mean() > self.threshold_deviation.discount() {
-                let t = self.lower_threshold + DEFAULT_THRESHOLD_STEP;
-                self.set_lower_threshold(t, self.auto_threshold);
-                self.threshold_deviation.set_count(0);
-            } else if self.threshold_deviation.mean() < self.threshold_deviation.discount() / 4.0 {
-                let t = self.lower_threshold - DEFAULT_THRESHOLD_STEP;
-                if t > self.absolute_threshold {
-                    self.set_lower_threshold(t, self.auto_threshold);
-                    self.threshold_deviation.set_count(0);
-                }
-            }
+        let gap : f32 = score - self.primary_deviation.mean() as f32;
+        if gap>0.0 {
+            self.threshold_deviation.update(gap as f64);
         }
     }
 
@@ -181,74 +214,40 @@ impl BasicThresholder {
         self.count += 1;
     }
 
-    pub fn update(&mut self, primary: f32, secondary: f32, last_score: f32, previous : bool){
-        self.update_both(primary,secondary - last_score);
-        self.in_potential_anomaly = previous;
+    pub fn update(&mut self, primary: f32, secondary: f32, last_score: f32){
+        self.update_both(minf32(2.0,primary),secondary - last_score);
     }
-    // the next set of functions maintain the invariant that
-    // DEFAULT_Z_FACTOR <= z_FACTOR < 2.0 * z_factor <= upper_z_factor
 
-    pub fn set_z_factor(&mut self, factor : f32) {
-        let z_factor = if factor > DEFAULT_Z_FACTOR {factor} else {DEFAULT_Z_FACTOR};
-        self.z_factor = z_factor;
-        if self.upper_z_factor < 2.0 * z_factor {
-            self.upper_z_factor = 2.0 * z_factor;
-        }
-    }
-
-    pub fn set_upper_z_factor(&mut self, factor : f32) {
-        let t = if factor> 2.0*self.z_factor {factor} else {2.0*self.z_factor};
-        self.upper_z_factor = t
-    }
 
     pub fn z_factor(&self) -> f32 {
         self.z_factor
     }
 
+    pub fn set_z_factor(&mut self, factor : f32){
+        self.z_factor = factor;
+    }
+
     // the next set of functions maintain the invariant that
     // absolute_threshold <= lower_threshold < initial_threshold <= upper_threshold
     // absolute_threshold <= lower_threshold < 2.0 *lower_threshold <= upper_threshold
     // to increase proceed as upper_threshold, initial_threshold, lower_threshold, absolute_threshold
     // to decrease proceed in reverse of the above order
 
-    pub fn set_lower_threshold(&mut self, lower : f32, adjust: bool) {
-        let lower_t = if lower>self.absolute_threshold {lower} else {self.absolute_threshold};
-        self.lower_threshold = lower_t;
-        self.auto_threshold = adjust;
-        if self.initial_threshold < lower_t {
-            self.initial_threshold = lower_t;
-        };
-        if self.upper_threshold < 2.0 * lower_t {
-            self.upper_threshold = 2.0 * lower_t;
-        }
+    pub fn set_lower_threshold(&mut self, lower : f32) {
+        self.lower_threshold = lower;
     }
 
     pub fn set_absolute_threshold(&mut self, value:f32) {
         self.absolute_threshold = value;
-        self.set_lower_threshold(self.absolute_threshold, self.auto_threshold);
     }
 
     pub fn set_initial_threshold(&mut self, initial : f32) {
-        self.initial_threshold = if initial< self.lower_threshold {self.lower_threshold} else {initial};
-        if self.upper_threshold < initial {
-            self.upper_threshold = initial;
-        }
-    }
-
-    pub fn set_upper_threshold(&mut self, upper : f32) {
-        self.upper_threshold = if upper < self.initial_threshold {self.initial_threshold} else {upper};
-        if self.upper_threshold < 2.0 * self.lower_threshold {
-            self.upper_threshold = 2.0 * self.lower_threshold;
-        }
-    }
-
-    pub fn in_potential_anomaly(&self) -> bool {
-        self.in_potential_anomaly
+        self.initial_threshold =  initial;
     }
 
-    pub fn set_horizon(&mut self, horizon:f32) {
+    pub fn set_score_differencing(&mut self, horizon:f32) {
         assert!(horizon >= 0.0 && horizon <= 1.0, "incorrect horizon parameter");
-        self.horizon = horizon;
+        self.score_differencing = horizon;
     }
 
     pub fn last_score(&self) -> f32{
diff --git a/Rust/src/trcf/basictrcf.rs b/Rust/src/trcf/basictrcf.rs
index 1e0a5bf3..de2cbbf6 100644
--- a/Rust/src/trcf/basictrcf.rs
+++ b/Rust/src/trcf/basictrcf.rs
@@ -1,77 +1,348 @@
-
-use crate::common::anomalydescriptor::AnomalyDescriptor;
+use std::hash::Hash;
+use rand::Rng;
+use rand_chacha::ChaCha20Rng;
+use rand_core::SeedableRng;
+use crate::common::descriptor::Descriptor;
+use crate::common::deviation::Deviation;
 use crate::common::rangevector::RangeVector;
-use crate::rcf::{create_rcf, RCF};
-use crate::types::Result;
+use crate::rcf::{AugmentedRCF, RCF, RCFBuilder, RCFOptions};
+use crate::types::{Result};
 use crate::trcf::predictorcorrector::PredictorCorrector;
+use crate::trcf::preprocessor::{Preprocessor, PreprocessorBuilder};
+use crate::trcf::types::ForestMode::{STANDARD, STREAMING_IMPUTE, TIME_AUGMENTED};
+use crate::trcf::types::{ForestMode, ImputationMethod, ScoringStrategy, TransformMethod};
+use crate::trcf::types::TransformMethod::{NONE, NORMALIZE};
+use crate::util::check_argument;
+use crate::rcf::RCFOptionsBuilder;
+use crate::trcf::types::ImputationMethod::USE_RCF;
+use crate::trcf::types::ScoringStrategy::{DISTANCE, EXPECTED_INVERSE_HEIGHT};
 
-pub struct BasicTRCF {
-    dimensions: usize,
-    capacity: usize,
-    number_of_trees: usize,
-    rcf : Box<dyn RCF>,
-    predictor_corrector: PredictorCorrector,
-    shingle_size: usize,
-    internal_timestamp : usize,
-    bounding_box_cache_fraction: f64,
-    last_anomaly_descriptor : AnomalyDescriptor,
+#[repr(C)]
+#[derive(Clone)]
+pub struct Bandit {
+    id: u64,
+    current_model: usize,
+    switches: usize,
+    affirmations: usize,
+    interval: (usize, usize),
+    stats: Vec<Deviation>,
 }
 
+#[repr(C)]
+#[derive(Clone)]
+pub struct State {
+    pub id: u64,
+    random_seed : u64,
+    pub scoring_strategy: ScoringStrategy,
+    pub bandit: Bandit,
+    pub predictor_corrector: PredictorCorrector,
+    pub preprocessor: Preprocessor,
+    pub last_descriptor : Descriptor,
+}
 
-impl BasicTRCF {
-    pub fn new(
-        dimensions: usize,
-        shingle_size: usize,
-        capacity: usize,
-        number_of_trees: usize,
-        random_seed: u64,
-        parallel_enabled: bool,
-        time_decay: f64,
-        anomaly_rate: f32,
-        initial_accept_fraction: f64,
-        bounding_box_cache_fraction: f64,
-    ) -> Self {
-        BasicTRCF{
-            dimensions,
-            capacity,
-            number_of_trees,
-            rcf: create_rcf(dimensions,shingle_size,capacity,number_of_trees,random_seed,false,parallel_enabled,true,false,time_decay,initial_accept_fraction,bounding_box_cache_fraction),
-            predictor_corrector : PredictorCorrector::new(anomaly_rate),
-            shingle_size,
-            bounding_box_cache_fraction,
-            internal_timestamp : 0,
-            last_anomaly_descriptor: AnomalyDescriptor::new(&Vec::new(),0),
-        }
+impl Bandit{
+   pub fn new(id: u64, arms:usize, interval:(usize,usize)) -> Result<Self>{
+       Ok(Bandit{
+           id,
+           switches : 0,
+           affirmations : 0,
+           current_model: if arms==1 {0} else {arms},
+           interval,
+           stats: vec![Deviation::new(0.0)?;arms]
+       })
+   }
+
+    pub fn current_model(&self) -> usize {
+        self.current_model
     }
 
-    pub fn process(&mut self, point: &[f32], timestamp: usize) -> Result<AnomalyDescriptor>{
-        let mut result = AnomalyDescriptor::new(point,timestamp);
-        result.internal_timestamp = self.internal_timestamp;
-        self.internal_timestamp += 1;
-        result.rcf_point = Some(self.rcf.shingled_point(point));
-        result.forecast_reasonable = self.rcf.entries_seen() > 200;
-        self.predictor_corrector.detect_and_modify(&mut result,&self.last_anomaly_descriptor,self.shingle_size, &self.rcf,false,false);
-        if result.anomaly_grade > 0.0 {
-            if let Some(x) = &result.expected_rcf_point {
-                let base_dimension = self.dimensions / self.shingle_size;
-                let start: usize = (self.shingle_size as i32 + result.relative_index.unwrap() - 1) as usize * base_dimension;
-                result.expected_values_list = Some(vec![Vec::from(&x[start..start+base_dimension])]);
-                result.past_values = Some(Vec::from(&result.rcf_point.as_ref().unwrap()[start..start+base_dimension]));
-                result.likelihood_of_values=Some(vec![1.0f32]);
+    pub fn is_evaluating(&self,arms:usize, internal_timestamp:usize) -> bool {
+        arms == self.current_model || (internal_timestamp >= self.interval.0 && self.interval.1 >= internal_timestamp)
+    }
+
+    pub fn update(&mut self, scores:&[f32]) -> Result<()>{
+        check_argument(scores.len() == self.stats.len(), "incorrect length")?;
+        self.stats.iter_mut().zip(scores).for_each(|(x,&y)|
+            {if y>0.0 {
+                x.update(y as f64);
+            }});
+        Ok(())
+    }
+
+    // no assumptions are made other than the fact that the scores are +ve and lower is better
+    pub fn choose(&mut self, internal_timestamp: usize, shingle_size: usize, random: f32){
+        if self.current_model == self.stats.len() || self.interval.1 == internal_timestamp {
+            let mut min = self.stats.len();
+            let mut min_value = f32::MAX;
+            for i in 0..self.stats.len() {
+                if !self.stats[i].is_empty() && min_value > self.stats[i].mean() as f32 {
+                    min = i;
+                    min_value = self.stats[i].mean() as f32;
+                    self.stats[i].reset();
+                }
+            }
+            if self.current_model != self.stats.len() {
+                if self.current_model != min {
+                    self.switches += 1;
+                } else {
+                    self.affirmations += 1;
+                }
+            }
+            self.current_model = min;
+            if self.current_model != self.stats.len() {
+                let gap = ((1.0 + random) * self.interval.1 as f32) as usize + 3 * shingle_size;
+                self.interval = (self.interval.0 + gap, self.interval.1 + gap);
             }
-            self.last_anomaly_descriptor = result.clone();
         }
+    }
+    pub fn switches(&self) -> usize {
+        self.switches
+    }
+
+    pub fn affirmations(&self) -> usize {
+        self.affirmations
+    }
+}
+
+impl State {
+    pub fn new(id: u64, arms: usize, scoring_strategy: ScoringStrategy, predictor_corrector : PredictorCorrector, preprocessor: Preprocessor) -> Result<Self>{
+        let random_seed = ChaCha20Rng::from_entropy().gen::<u64>();
+        let last_descriptor = Descriptor::new(id,&Vec::new(),0,preprocessor.forest_mode() == TIME_AUGMENTED,None);
+        let base = preprocessor.start_normalization();
+        let interval = (base, base + 3 * preprocessor.shingle_size());
+        Ok(State{
+            id,
+            random_seed,
+            scoring_strategy,
+            bandit: Bandit::new(id,arms,interval)?,
+            predictor_corrector,
+            preprocessor,
+            last_descriptor,
+        })
+    }
+
+    pub fn random(&mut self) -> f32 {
+    let mut rng = ChaCha20Rng::seed_from_u64( self.random_seed);
+    self.random_seed = rng.gen::<u64>();
+    rng.gen::<f32>()
+    }
+}
+
+pub struct BasicTRCF {
+    rcf : Box<dyn RCF + Send + Sync>,
+    state: State
+}
+
+pub fn core_process<U :?Sized, Label:Sync + Copy, Attributes: Sync + Copy>(rcf: Option<&Box<U>>, state : &mut State, point: &[f32], timestamp: u64) -> Result<Descriptor>
+    where U : AugmentedRCF<Label,Attributes> {
+    let mut result = Descriptor::new(state.id,point,timestamp,state.preprocessor.forest_mode() == TIME_AUGMENTED,None);
+    result.values_seen = state.preprocessor.values_seen();
+    // the check for input length is done in exactly this place
+    //along with Nan/finiteness
+    match state.preprocessor.shingled_point(rcf, point, timestamp)? {
+        Some(x) => {
+            result.rcf_point = Some(x);
+            result.shift = Some(state.preprocessor.shift());
+            result.scale = Some(state.preprocessor.scale());
+            result.difference_deviations = Some(state.preprocessor.difference_deviations());
+            result.scoring_strategy = state.scoring_strategy;
+            result.transform_method = state.preprocessor.transformation_method();
+            if state.preprocessor.is_ready() {
+                match rcf {
+                    Some(y) => state.predictor_corrector.detect_and_modify(&mut result, &state.last_descriptor, state.preprocessor.shingle_size(), y)?,
+                    _ =>{}
+                }
+            }
+        },
+        None => {}
+    }
+    state.preprocessor.post_process(&mut result, point, timestamp, &state.last_descriptor)?;
+    if result.anomaly_grade > 0.0 {
+        state.last_descriptor = result.clone();
+    } else {
+        state.last_descriptor.values_seen = result.values_seen;
+        state.last_descriptor.current_timestamp = result.current_timestamp;
+        state.last_descriptor.anomaly_grade = 0.0;
+        state.last_descriptor.rcf_point = result.rcf_point.clone();
+        state.last_descriptor.score = result.score;
+        state.last_descriptor.threshold = result.threshold;
+    }
+    Ok(result)
+}
+
+impl BasicTRCF {
 
-        self.rcf.update(point,timestamp as u64)?;
+    pub fn process(&mut self, point: &[f32], timestamp: u64) -> Result<Descriptor>{
+        let result = core_process(Some(&self.rcf), &mut self.state, point, timestamp)?;
+        match result.rcf_point.as_ref() {
+            // this path would be taken for all un-normalized transformations
+            // relies on internal shingling
+            Some(x) => {
+                let dimension = x.len();
+                let shingle_size = self.state.preprocessor.shingle_size();
+                self.rcf.update(&x[(dimension - (dimension / shingle_size))..dimension], timestamp as u64)?;
+            },
+            _ => { self.state.preprocessor.drain(Some(&mut self.rcf))?; }
+        }
         Ok(result)
     }
 
-    pub fn extrapolate(&self, look_ahead: usize) -> Result<RangeVector> {
-        self.rcf.extrapolate(look_ahead)
+    pub fn process_sequentially(&mut self, input: &[(&[f32],u64)]) -> Result<Vec<Descriptor>> {
+        let answer = input.into_iter().map(|(a, b)| self.process(*a, *b))
+           .collect::<Result<Vec<Descriptor>>>()?.into_iter().filter(|x| x.anomaly_grade>0.0).collect();
+        Ok(answer)
+    }
+
+    pub fn extrapolate(&self, look_ahead: usize) -> Result<(RangeVector<f32>,Option<RangeVector<f64>>)> {
+        self.state.preprocessor.invert_extrapolation(self.rcf.extrapolate(look_ahead)?)
+    }
+
+}
+
+pub struct TRCFOptions {
+    pub(crate) transform_decay: Option<f64>,
+    pub(crate) transform_method: TransformMethod,
+    pub(crate) forest_mode : ForestMode,
+    pub(crate) verbose: bool,
+    pub(crate) weights: Option<Vec<f32>>,
+    pub(crate) default_fill : Option<Vec<f32>>,
+    pub(crate) start_normalization: usize,
+    pub(crate) stop_normalization:usize,
+    pub(crate) scoring_strategy: ScoringStrategy,
+}
+
+pub trait TRCFOptionsBuilder {
+    fn get_trcf_options(&mut self) -> &mut TRCFOptions;
+    fn transform_decay(&mut self, transform_decay: f64) -> &mut Self {
+        self.get_trcf_options().transform_decay = Some(transform_decay);
+        self
+    }
+    fn forest_mode(&mut self, forest_mode: ForestMode) -> &mut Self {
+        self.get_trcf_options().forest_mode = forest_mode;
+        self
+    }
+    fn transform_method(&mut self, transform_method: TransformMethod) -> &mut Self {
+        self.get_trcf_options().transform_method = transform_method;
+        self
+    }
+    fn start_normalization(&mut self, start_normalization: usize) -> &mut Self {
+        self.get_trcf_options().start_normalization = start_normalization;
+        self
+    }
+    fn stop_normalization(&mut self, stop_normalization: usize) -> &mut Self {
+        self.get_trcf_options().stop_normalization = stop_normalization;
+        self
+    }
+    fn weights(&mut self, weights: &[f32]) -> &mut Self {
+        self.get_trcf_options().weights = Some(Vec::from(weights));
+        self
+    }
+    fn default_fill(&mut self, default_fill: &[f32]) -> &mut Self {
+        self.get_trcf_options().default_fill = Some(Vec::from(default_fill));
+        self
+    }
+    fn verbose(&mut self, verbose: bool) -> &mut Self {
+        self.get_trcf_options().verbose = verbose;
+        self
+    }
+    fn scoring_strategy(&mut self, scoring_strategy: ScoringStrategy) -> &mut Self {
+        self.get_trcf_options().scoring_strategy = scoring_strategy;
+        self
+    }
+}
+
+impl TRCFOptions{
+    pub fn validate(&self, input_dimensions: usize) ->Result<()> {
+        check_argument(self.transform_decay.unwrap_or(0.0) >= 0.0, "transform decay cannot be negative")?;
+        // juct check -- the builder should not be modified in case it is reused
+        check_argument(self.weights.as_ref().unwrap_or(&vec![1.0; input_dimensions]).len() == input_dimensions,
+                       " incorrect length of weight vector")?;
+        check_argument(self.default_fill.as_ref().unwrap_or(&vec![0.0; input_dimensions]).len() == input_dimensions,
+                       " incorrect length of default_fill vector")?;
+        check_argument(self.start_normalization <= self.stop_normalization, "normalization cannot start cannot be after stopping")?;
+        Ok(())
     }
+}
 
+impl Default for TRCFOptions {
+    fn default() -> Self {
+       TRCFOptions {
+           transform_decay: None,
+           transform_method: NORMALIZE,
+           forest_mode: STANDARD,
+           verbose: false,
+           weights: None,
+           default_fill: None,
+           start_normalization: 10,
+           stop_normalization: usize::MAX,
+           scoring_strategy: EXPECTED_INVERSE_HEIGHT
+       }
+    }
+}
 
+pub struct BasicTRCFBuilder {
+    input_dimensions: usize,
+    shingle_size: usize,
+    trcf_options: TRCFOptions,
+    rcf_options : RCFOptions<u64,u64>
 }
 
+impl BasicTRCFBuilder {
+    pub fn new(input_dimensions: usize, shingle_size: usize) -> Self {
+        BasicTRCFBuilder {
+            input_dimensions,
+            shingle_size,
+            rcf_options: RCFOptions::default(),
+            trcf_options: TRCFOptions::default()
+        }
+    }
+
+    pub fn build(&self) -> Result<BasicTRCF> {
+        check_argument(self.trcf_options.forest_mode!= STREAMING_IMPUTE, "not yet supported")?;
+        check_argument( self.input_dimensions > 0, "input_dimensions cannot be 0")?;
+        check_argument( self.shingle_size > 0, "shingle size cannot be 0")?;
+        self.rcf_options.validate()?;
+        self.trcf_options.validate(self.input_dimensions)?;
+        let output_after = self.rcf_options.output_after.unwrap_or(1 + self.rcf_options.capacity / 4);
+        let time_decay = self.rcf_options.time_decay.unwrap_or(0.1/self.rcf_options.capacity as f64);
+        let transform_decay = self.trcf_options.transform_decay.unwrap_or(0.1/self.rcf_options.capacity as f64);
+        let weights = match &self.trcf_options.weights {
+            Some(x) => x.clone(),
+            _ => vec![1.0; self.input_dimensions],
+        };
+        let random_seed = self.rcf_options.random_seed.unwrap_or( ChaCha20Rng::from_entropy().gen::<u64>());
+        let rcf = RCFBuilder::<u64,u64>::new(self.input_dimensions,self.shingle_size)
+            .tree_capacity(self.rcf_options.capacity).number_of_trees(self.rcf_options.number_of_trees)
+            .random_seed(random_seed)
+            .parallel_enabled(self.rcf_options.parallel_enabled).time_decay(time_decay)
+            .bounding_box_cache_fraction(self.rcf_options.bounding_box_cache_fraction)
+            .output_after(output_after)
+            .initial_accept_fraction(self.rcf_options.initial_accept_fraction).build_default()?;
+        let preprocessor = PreprocessorBuilder::new(self.input_dimensions,self.shingle_size)
+            .transform_decay(transform_decay)
+            .transform_method(self.trcf_options.transform_method)
+            .forest_mode(self.trcf_options.forest_mode)
+            .random_seed(random_seed+1)
+            .weights(&weights)
+            .start_normalization(self.trcf_options.start_normalization)
+            .stop_normalization(self.trcf_options.stop_normalization).build()?;
+        let predictor_corrector = PredictorCorrector::new(transform_decay,!self.trcf_options.verbose,self.input_dimensions)?;
+
+        Ok(BasicTRCF {
+            rcf,
+            state: State::new(0, 1, self.trcf_options.scoring_strategy,predictor_corrector, preprocessor)?
+        })
+    }
+}
 
+impl RCFOptionsBuilder<u64, u64> for BasicTRCFBuilder {
+    fn get_rcf_options(&mut self) -> &mut RCFOptions<u64, u64> {
+        &mut self.rcf_options
+    }
+}
 
+impl TRCFOptionsBuilder for BasicTRCFBuilder {
+    fn get_trcf_options(&mut self) -> &mut TRCFOptions {
+        &mut self.trcf_options
+    }
+}
\ No newline at end of file
diff --git a/Rust/src/trcf/errorhandler.rs b/Rust/src/trcf/errorhandler.rs
new file mode 100644
index 00000000..aaeec498
--- /dev/null
+++ b/Rust/src/trcf/errorhandler.rs
@@ -0,0 +1,245 @@
+
+use crate::common::descriptor::{Descriptor, ErrorInformation};
+use crate::common::divector::DiVector;
+use crate::common::rangevector::RangeVector;
+use crate::trcf::types::Calibration;
+use crate::util::{check_argument, maxf32, minf32};
+use crate::types::{Result};
+
+#[repr(C)]
+#[derive(Clone)]
+pub struct ErrorHandler {
+    add_error : bool,
+    input_length: usize,
+    sequence_index: usize,
+    percentile: f32,
+    forecast_horizon: usize,
+    error_horizon: usize,
+    past_forecasts: Vec<RangeVector<f32>>,
+    actuals: Vec<Vec<f32>>,
+    error_distribution: RangeVector<f32>,
+    error_rmse: DiVector,
+    error_mean: Vec<f32>,
+    interval_precision: Vec<f32>,
+    last_deviations: Vec<f32>
+}
+
+impl ErrorHandler {
+    pub fn new(add_error: bool, input_length: usize, forecast_horizon: usize, error_horizon: usize, percentile: f32) -> Self {
+        ErrorHandler {
+            add_error,
+            input_length,
+            sequence_index: 0,
+            percentile,
+            forecast_horizon,
+            error_horizon,
+            past_forecasts: Vec::new(),
+            actuals: Vec::new(),
+            error_distribution: RangeVector::<f32>::new(input_length*forecast_horizon),
+            error_rmse: DiVector::empty(input_length*forecast_horizon),
+            error_mean: vec![0.0;input_length*forecast_horizon],
+            interval_precision: vec![0.0;input_length*forecast_horizon],
+            last_deviations: vec![0.0;input_length]
+        }
+    }
+
+    pub fn update_actuals(&mut self, input : &[f32], deviations : &[f32]) -> Result<()>{
+        let array_length = self.past_forecasts.len();
+        let input_length = input.len();
+        check_argument(self.input_length == input_length, "incorrect input")?;
+        if self.sequence_index > 0 {
+            let input_index = (self.sequence_index + array_length - 1) % array_length;
+            if self.sequence_index < array_length + 1 {
+                check_argument(self.actuals.len() == input_index, "incorrect accounting")?;
+                self.actuals.push(Vec::from(input));
+            } else {
+                for (x,y) in self.actuals[input_index].iter_mut().zip(input) {
+                    *x = *y;
+                }
+            }
+        }
+
+        self.sequence_index += 1;
+        self.recompute_errors()?;
+        for (x,y) in self.last_deviations.iter_mut().zip(deviations){
+            *x = *y;
+        };
+        Ok(())
+    }
+
+    pub fn augment_descriptor(&self,descriptor : &mut Descriptor) {
+        descriptor.error_information = Some(
+            ErrorInformation{
+                interval_precision: self.interval_precision.clone(),
+                error_distribution: self.error_distribution.clone(),
+                error_rmse: self.error_rmse.clone(),
+                error_mean: self.error_mean.clone()
+            }
+        )
+    }
+
+    pub fn update_forecasts(&mut self, range_vector: &RangeVector<f32>) -> Result<()> {
+        check_argument(range_vector.values.len() == self.input_length *self.forecast_horizon, "incorrect input")?;
+        let array_length = self.past_forecasts.len();
+        let stored_forecast_index = (self.sequence_index + array_length - 1) % (array_length);
+        if stored_forecast_index < array_length + 1 {
+            check_argument(self.past_forecasts.len() == stored_forecast_index, "incorrect accounting")?;
+            self.past_forecasts.push(range_vector.clone());
+        } else {
+            for (x,y) in self.past_forecasts[stored_forecast_index].values.iter_mut().zip(&range_vector.values) {
+                *x = *y;
+            }
+            for (x,y) in self.past_forecasts[stored_forecast_index].lower.iter_mut().zip(&range_vector.lower) {
+                *x = *y;
+            }
+            for (x,y) in self.past_forecasts[stored_forecast_index].upper.iter_mut().zip(&range_vector.upper) {
+                *x = *y;
+            }
+        };
+        Ok(())
+    }
+
+
+    fn length(sequence_index : usize, error_horizon : usize, index : usize) -> usize {
+        if sequence_index > error_horizon + index + 1 {error_horizon}
+        else  if sequence_index < index + 1 {0}
+        else {sequence_index - index - 1}
+    }
+
+    fn recompute_errors(&mut self) -> Result<()>{
+        let array_length = self.past_forecasts.len();
+        let input_index = (self.sequence_index - 2 + array_length) % array_length;
+        let mut median_error = vec![0.0f32;self.error_horizon];
+
+        for x in self.interval_precision.iter_mut(){
+            *x =0.0;
+        }
+
+        for i in 0..self.forecast_horizon {
+            let len = Self::length(self.sequence_index, self.error_horizon, i);
+            for j in 0..self.input_length {
+                let pos = i * self.input_length + j;
+                if len > 0 {
+                    let mut positive_sum = 0.0f64;
+                    let mut positive_count = 0;
+                    let mut negative_sum = 0.0f64;
+                    let mut positive_sq_sum = 0.0f64;
+                    let mut negative_sq_sum = 0.0f64;
+                    for k in 0..len  {
+                        let past_index = (input_index - i - k + array_length) % array_length;
+                        let index = (input_index - k + array_length) % array_length;
+                        let error = (self.actuals[index][j] - self.past_forecasts[past_index].values[pos]) as f64;
+                        median_error[k] = error as f32;
+                        let within = self.past_forecasts[past_index].upper[pos] >= self.actuals[index][j]
+                            && self.actuals[index][j] >= self.past_forecasts[past_index].lower[pos];
+                        self.interval_precision[pos] += if within { 1.0 } else { 0.0 };
+
+                        if error >= 0.0 {
+                            positive_sum += error;
+                            positive_sq_sum += error * error;
+                            positive_count += 1;
+                        } else {
+                            negative_sum += error;
+                            negative_sq_sum += error * error;
+                        }
+                    }
+                    self.error_mean[pos] = (positive_sum + negative_sum) as f32 / len as f32;
+                    self.error_rmse.high[pos] = if positive_count == 0 { 0.0 } else {
+                        f64::sqrt(positive_sq_sum / positive_count as f64)
+                    };
+                    self.error_rmse.low[pos] = if positive_count == len { 0.0 } else {
+                        - f64::sqrt(negative_sq_sum / (len - positive_count) as f64)
+                    };
+
+                    if len as f32 * self.percentile >= 1.0 {
+                        median_error[0..(len as usize)].sort_by(|o1, o2| o1.partial_cmp(&o2).unwrap());
+                        self.error_distribution.values[pos] = Self::interpolated_median(&median_error, len)?;
+                        self.error_distribution.upper[pos] = Self::interpolated_upper_rank(&median_error, len, len as f32 * self.percentile);
+                        self.error_distribution.lower[pos] = Self::interpolated_lower_rank(&median_error, len as f32 * self.percentile);
+                    }
+                    self.interval_precision[pos] = self.interval_precision[pos] / len as f32;
+                } else {
+                    self.error_mean[pos] = 0.0;
+                    self.error_rmse.high[pos] = 0.0;
+                    self.error_rmse.low[pos] = 0.0;
+                    self.error_distribution.values[pos] = 0.0;
+                    self.error_distribution.upper[pos] = 0.0;
+                    self.error_distribution.lower[pos] = 0.0;
+                    self.interval_precision[pos] = 0.0;
+                }
+            }
+        };
+        Ok(())
+    }
+
+    pub fn calibrate(&self,calibration : Calibration, ranges : &mut RangeVector<f32>) -> Result<()>{
+        check_argument(self.input_length * self.forecast_horizon == ranges.values.len(), "mismatched lengths")?;
+        for i in 0..self.forecast_horizon {
+            let len = Self::length(self.sequence_index, self.error_horizon, i);
+            for j in 0..self.input_length {
+                let pos = i * self.input_length + j;
+                if len > 0 {
+                    if calibration != Calibration::NONE {
+                        if len as f32 * self.percentile < 1.0 {
+                            let deviation = self.last_deviations[j];
+                            ranges.upper[pos] = maxf32(ranges.upper[pos], ranges.values[pos] + (1.3 * deviation));
+                            ranges.lower[pos] = minf32(ranges.lower[pos], ranges.values[pos] - (1.3 * deviation));
+                        } else {
+                            match calibration {
+                                Calibration::SIMPLE => { Self::adjust(pos, ranges, &self.error_distribution)?; },
+                                Calibration::MINIMAL => { Self::adjust_minimal(pos, ranges, &self.error_distribution)?; },
+                                _ => {}
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        Ok(())
+    }
+
+    fn interpolated_median(ascending_array : &[f32], len : usize) -> Result<f32>{
+        check_argument(ascending_array.len() >= len, "incorrect length parameter")?;
+        let lower = if len % 2 == 0 { ascending_array[len / 2 - 1] }
+                else { (ascending_array[len / 2] + ascending_array[len / 2 - 1]) / 2.0 };
+        let upper = if len % 2 == 0 { ascending_array[len / 2] }
+                else { (ascending_array[len / 2] + ascending_array[len / 2 - 1]) / 2.0 };
+
+        if lower <= 0.0 && 0.0 <= upper {
+            return Ok(0.0);
+        } else {
+            return Ok((upper + lower) / 2.0);
+        }
+    }
+
+    fn interpolated_lower_rank(ascending_array: &[f32], frac_rank : f32) -> f32{
+        let rank = f32::floor(frac_rank) as usize;
+        return ascending_array[rank - 1]
+                + (frac_rank - rank as f32) * (ascending_array[rank] - ascending_array[rank - 1]);
+    }
+
+    fn interpolated_upper_rank(ascending_array : &[f32], len : usize, frac_rank : f32) -> f32 {
+        let rank = f32::floor(frac_rank) as usize;
+        return ascending_array[len - rank]
+                + (frac_rank - rank as f32) * (ascending_array[len - rank - 1] - ascending_array[len - rank]);
+    }
+
+    fn adjust(pos: usize, range_vector : &mut RangeVector<f32>, other : &RangeVector<f32>) -> Result<()>{
+        check_argument(other.values.len() == range_vector.values.len(), " mismatch in lengths")?;
+        check_argument(pos < other.values.len(), " cannot be this large")?;
+        range_vector.values[pos] += other.values[pos];
+        range_vector.upper[pos] = maxf32(range_vector.values[pos], range_vector.upper[pos] + other.upper[pos]);
+        range_vector.lower[pos] = minf32(range_vector.values[pos], range_vector.lower[pos] + other.lower[pos]);
+        Ok(())
+    }
+
+   fn adjust_minimal(pos: usize, range_vector : &mut RangeVector<f32>, other : &RangeVector<f32>)  -> Result<()> {
+       check_argument(other.values.len() == range_vector.values.len(), " mismatch in lengths")?;
+       check_argument(pos < other.values.len(), "cannot be this large")?;
+       let old_val = range_vector.values[pos];
+       range_vector.values[pos] += other.values[pos];
+       range_vector.upper[pos] = maxf32(range_vector.values[pos], old_val + other.upper[pos]);
+       range_vector.lower[pos] = minf32(range_vector.values[pos], old_val + other.lower[pos]);
+       Ok(())
+   }
+}
diff --git a/Rust/src/trcf/mod.rs b/Rust/src/trcf/mod.rs
index 36a641ee..0f71f837 100644
--- a/Rust/src/trcf/mod.rs
+++ b/Rust/src/trcf/mod.rs
@@ -1,3 +1,9 @@
 mod predictorcorrector;
 pub(crate) mod basicthresholder;
 pub mod basictrcf;
+mod preprocessor;
+mod transformer;
+pub mod types;
+pub mod errorhandler;
+pub mod rcfcaster;
+pub mod multitrcf;
diff --git a/Rust/src/trcf/multitrcf.rs b/Rust/src/trcf/multitrcf.rs
new file mode 100644
index 00000000..1dea07a8
--- /dev/null
+++ b/Rust/src/trcf/multitrcf.rs
@@ -0,0 +1,244 @@
+use std::collections::HashMap;
+use rand_chacha::ChaCha20Rng;
+use rand_core::{RngCore, SeedableRng};
+use rayon::prelude::*;
+use crate::common::descriptor::Descriptor;
+use crate::rcf::{AugmentedRCF, RCF, RCFBuilder, RCFOptions};
+use crate::types::{Result};
+use crate::trcf::predictorcorrector::PredictorCorrector;
+use crate::trcf::preprocessor::{PreprocessorBuilder};
+use crate::trcf::types::ForestMode::{STANDARD};
+use crate::trcf::types::{ScoringStrategy, TransformMethod};
+use crate::util::{check_argument, maxf32, minf32};
+use crate::rcf::RCFOptionsBuilder;
+use crate::trcf::basictrcf::{core_process, State, TRCFOptions, TRCFOptionsBuilder};
+use crate::trcf::types::ScoringStrategy::EXPECTED_INVERSE_HEIGHT;
+
+
+pub struct MultiTRCF {
+    arms : usize,
+    rcfs : Vec<Box<dyn AugmentedRCF<(u64,u64),u64> + Send + Sync>>,
+    states: HashMap<u64,State>,
+    input_dimensions: usize,
+    shingle_size: usize,
+    transform_decay: f64,
+    transform_method: TransformMethod,
+    scoring_strategy: ScoringStrategy,
+    random_seed: u64,
+    probability: f32,
+    parallel_enabled: bool,
+    selector : fn(&Descriptor) -> bool
+}
+
+fn is_anomaly(a:&Descriptor) -> bool {
+   a.anomaly_grade>0.0
+}
+
+impl MultiTRCF {
+
+    fn select_for_update(&self, _a: u64, _b: usize, _score: f32, probability : f32) -> bool {
+        probability < self.probability
+    }
+
+    fn core_multi(&self, state:& mut State, point: &[f32],timestamp : u64)
+        -> Result<((usize,(u64,u64),Option<Vec<f32>>),Option<Descriptor>)> {
+        let internal_timestamp = state.preprocessor.internal_timestamp();
+        if self.arms > 1 && state.bandit.is_evaluating(self.arms, internal_timestamp) {
+            let shingled_point = state.preprocessor.shingled_point(None as Option<&Box<dyn RCF>>, &point, timestamp)?;
+            match shingled_point.as_ref() {
+                Some(x) => {
+                    let mut scores = vec![-1.0f32; self.arms];
+
+                    for i in 0..self.arms {
+                        if self.rcfs[i].is_output_ready() {
+                            scores[i] = self.rcfs[i].score(x).unwrap() as f32;
+                        }
+                    }
+                    state.bandit.update(&scores)?;
+                    let random = state.random();
+                    state.bandit.choose(internal_timestamp, state.preprocessor.shingle_size(), random);
+                },
+                _ => {}
+            }
+        }
+        let rcf = if state.bandit.current_model() < self.arms {
+            Some(&self.rcfs[state.bandit.current_model()])
+        } else {
+            None
+        };
+        let t = core_process(rcf, state, point, timestamp).unwrap();
+        let probability = state.random();
+        let point = if state.preprocessor.is_ready()
+            && self.select_for_update(state.id, state.preprocessor.internal_timestamp(), t.score,probability) {
+            t.rcf_point.clone()
+        } else {
+            None
+        };
+        if (self.selector)(&t) {
+            Ok(((state.bandit.current_model(),(state.id,timestamp), point) , Some(t)))
+        } else {
+            Ok(((state.bandit.current_model(),(state.id,timestamp), point), None))
+        }
+    }
+
+    pub fn process(&mut self, input: HashMap<u64,(&[f32],u64)>) -> Result<Vec<Descriptor>>{
+        let mut join : Vec<(u64,(State,&[f32],u64))> = input.into_iter().map(|e| {
+             if !self.states.contains_key(&e.0) {
+                let preprocessor = PreprocessorBuilder::new(self.input_dimensions, self.shingle_size)
+                    .transform_method(self.transform_method).transform_decay(self.transform_decay)
+                    .start_normalization(3 * self.shingle_size).build().unwrap();
+                let predictor_corrector = PredictorCorrector::new(self.transform_decay, true, self.input_dimensions)?;
+                let state = State::new(e.0,self.arms,self.scoring_strategy,predictor_corrector,preprocessor)?;
+                 Ok((e.0,(state,e.1.0,e.1.1)))
+            } else {
+                Ok((e.0,(self.states.remove(&e.0).unwrap(),e.1.0,e.1.1)))
+            }}).collect::<Result<Vec<(u64,(State,&[f32],u64))>>>()?;
+
+        let collection = if self.parallel_enabled {
+            join.par_iter_mut().map(|(_x,(state,point,timestamp))| {
+                self.core_multi(state,*point,*timestamp)
+            }).collect::<Result<Vec<((usize,(u64,u64),Option<Vec<f32>>),Option<Descriptor>)>>>()?
+        } else {
+            join.iter_mut().map(|(_x,(state,point,timestamp))|  {
+                self.core_multi(state,*point,*timestamp)
+            }).collect::<Result<Vec<((usize,(u64,u64),Option<Vec<f32>>),Option<Descriptor>)>>>()?
+        };
+
+        join.into_iter().for_each(|(id,(state,_,_))| { self.states.insert(id,state);});
+
+        let (updates,proto) : (Vec<(usize,(u64,u64),Option<Vec<f32>>)>,Vec<_>) = collection.into_iter().unzip();
+
+        updates.into_iter().map(|y|  -> Result<()> {
+            match y.2.as_ref() {
+                Some(x) => {
+                    // if there is only one arm then the following will be equivalent -- first branch would
+                    // be taken since y.0 == 1 in such a case
+                    if y.0 != self.arms {
+                        self.rcfs[y.0].update(x, y.1)
+                    } else {
+                        self.rcfs.iter_mut().map(|z| {
+                            z.update(x, y.1)
+                        }).collect()
+                    }
+                },
+                None => { Ok(())}
+            }}).collect::<Result<Vec<()>>>()?;
+
+        let answer: Vec<Descriptor> = proto.into_iter().filter_map(|x| x).collect();
+
+        Ok(answer)
+    }
+
+    pub fn switches(&self) -> usize {
+        self.states.iter().map(|x| x.1.bandit.switches()).sum()
+    }
+
+    pub fn affirmations(&self) -> usize {
+        self.states.iter().map(|x| x.1.bandit.affirmations()).sum()
+    }
+
+    pub fn states(&self) -> Vec<State> {
+        self.states.iter().map(|x| x.1.clone()).collect::<Vec<State>>()
+    }
+
+    pub fn updates(&self) -> Vec<(usize,u64)>{
+        self.rcfs.iter().zip(0..self.rcfs.len()).map(|x| (x.1,x.0.entries_seen())).collect()
+    }
+}
+
+pub struct MultiTRCFBuilder {
+    input_dimensions: usize,
+    shingle_size: usize,
+    arms : usize,
+    probability : f32,
+    scoring_strategy:ScoringStrategy,
+    rcf_options: RCFOptions<(u64,u64),u64>,
+    trcf_options: TRCFOptions
+}
+
+impl Default for MultiTRCFBuilder {
+    // parallel_enabled will apply to MultiTRCF instead of RCF
+    fn default() -> Self {
+        MultiTRCFBuilder {
+            input_dimensions: 1,
+            shingle_size: 10,
+            arms: 1,
+            probability: 0.01,
+            scoring_strategy: EXPECTED_INVERSE_HEIGHT,
+            rcf_options: RCFOptions { parallel_enabled: true, internal_shingling: false, ..Default::default()},
+            trcf_options: Default::default()
+        }
+    }
+}
+
+//just picking time stamp
+fn attribute_creator(_a:&[(u64,u64)],label: (u64,u64)) -> Result<u64> {
+    Ok(label.1)
+}
+
+impl MultiTRCFBuilder {
+    pub fn new(input_dimensions:usize, shingle_size: usize, number_of_models: usize, approx_cardinality: usize) -> Self {
+        MultiTRCFBuilder{
+            input_dimensions,
+            shingle_size,
+            arms: number_of_models,
+            probability : maxf32(0.01,1.0/maxf32(number_of_models as f32, (1+approx_cardinality) as f32)),
+            ..Default::default()
+        }
+    }
+
+    pub fn probability(&mut self, probability:f32) -> &mut Self {
+        self.probability = probability;
+        self
+    }
+
+    pub fn build(&self) -> Result<MultiTRCF>{
+        check_argument(self.arms >0," cannot be zero")?;
+        check_argument(!self.rcf_options.internal_shingling, "internal shingling is not feasible")?;
+        check_argument( self.rcf_options.bounding_box_cache_fraction == 1.0, " bounding box fraction should be 1")?;
+        check_argument(self.trcf_options.forest_mode==STANDARD, "forest mode not supported")?;
+        let mut random_seed = self.rcf_options.random_seed.unwrap_or(ChaCha20Rng::from_entropy().next_u64());
+        let time_decay = self.rcf_options.time_decay.unwrap_or(0.1/self.rcf_options.capacity as f64);
+        let output_after = self.rcf_options.output_after.unwrap_or(1 + self.rcf_options.capacity / 4);
+        let transform_decay = self.trcf_options.transform_decay.unwrap_or(0.1/self.rcf_options.capacity as f64);
+        let mut rcfs= Vec::new();
+        for _i in 0..self.arms {
+            rcfs.push(RCFBuilder::<(u64,u64),u64>::new(self.input_dimensions, self.shingle_size)
+                .tree_capacity(self.rcf_options.capacity)
+                .number_of_trees(self.rcf_options.number_of_trees)
+                .time_decay(time_decay)
+                .store_attributes(self.rcf_options.store_attributes)
+                .output_after(output_after)
+                .initial_accept_fraction(self.rcf_options.initial_accept_fraction)
+                .internal_shingling(false).random_seed(random_seed)
+                .build_to_u64(attribute_creator).unwrap());
+            random_seed += 1;
+        }
+        Ok(MultiTRCF {
+            arms: self.arms,
+            parallel_enabled : self.rcf_options.parallel_enabled,
+            rcfs,
+            states: Default::default(),
+            input_dimensions : self.input_dimensions,
+            shingle_size : self.shingle_size,
+            transform_decay,
+            transform_method: self.trcf_options.transform_method,
+            scoring_strategy: self.trcf_options.scoring_strategy,
+            random_seed,
+            probability: self.probability,
+            selector: is_anomaly
+        })
+    }
+}
+
+impl RCFOptionsBuilder<(u64,u64),u64> for MultiTRCFBuilder {
+    fn get_rcf_options(&mut self) -> &mut RCFOptions<(u64,u64),u64> {
+        &mut self.rcf_options
+    }
+}
+
+impl TRCFOptionsBuilder for MultiTRCFBuilder {
+    fn get_trcf_options(&mut self) -> &mut TRCFOptions {
+        &mut self.trcf_options
+    }
+}
\ No newline at end of file
diff --git a/Rust/src/trcf/predictorcorrector.rs b/Rust/src/trcf/predictorcorrector.rs
index 89a4f04a..124d54da 100644
--- a/Rust/src/trcf/predictorcorrector.rs
+++ b/Rust/src/trcf/predictorcorrector.rs
@@ -1,35 +1,57 @@
+use std::f32::consts::E;
+use num::abs;
 use crate::common::divector::DiVector;
-use crate::rcf::RCF;
+use crate::rcf::{AugmentedRCF, RCF};
+use crate::types::{Result};
 use crate::trcf::basicthresholder::BasicThresholder;
-use crate::common::anomalydescriptor::AnomalyDescriptor;
+use crate::common::descriptor::Descriptor;
+use crate::common::deviation::Deviation;
+use crate::trcf::types::CorrectionMode::{ANOMALY_IN_SHINGLE, CONDITIONAL_FORECAST, DATA_DRIFT, FORECAST, NOISE};
+use crate::trcf::types::ScoringStrategy::EXPECTED_INVERSE_HEIGHT;
+use crate::trcf::types::TransformMethod::{DIFFERENCE, NORMALIZE_DIFFERENCE};
+use crate::util::{absf32, maxf32, minf32};
 
+const DEFAULT_NORMALIZATION_PRECISION:f32 = 1e-3;
 const DEFAULT_NUMBER_OF_MAX_ATTRIBUTORS: usize = 5;
-const DEFAULT_REPEAT_ANOMALY_Z_FACTOR : f32 = 3.5;
-const DEFAULT_IGNORE_SIMILAR_FACTOR :f32 = 0.3;
-const DEFAULT_IGNORE_SIMILAR : bool = false;
+const NOISE_FACTOR: f32 = 1.0;
+const DEFAULT_SAMPLING_SUPPORT : f32 = 0.1;
+const DEFAULT_DIFFERENTIAL_FACTOR : f32 = 0.3;
+const DEFAULT_RUN_ALLOWED : usize = 2;
 
 #[repr(C)]
 #[derive(Clone)]
 pub struct PredictorCorrector {
     basic_thresholder: BasicThresholder,
-    ignore_similar : f32,
-    trigger_factor : f32,
+    auto_adjust : bool,
+    run_length : usize,
+    deviations_actual : Vec<Deviation>,
+    deviations_expected: Vec<Deviation>,
     max_attributors: usize
 }
 
 impl PredictorCorrector {
     // for mappers
-    pub fn new(discount: f32) -> Self {
-        PredictorCorrector {
-            basic_thresholder: BasicThresholder::new_adjustible(discount, false),
-            ignore_similar: DEFAULT_IGNORE_SIMILAR_FACTOR,
-            trigger_factor: DEFAULT_REPEAT_ANOMALY_Z_FACTOR,
-            max_attributors: DEFAULT_NUMBER_OF_MAX_ATTRIBUTORS
+    pub fn new(discount: f64, auto_adjust:bool, base_dimension : usize) -> Result<Self> {
+        let mut a = Vec::new();
+        let mut b =Vec::new();
+        if auto_adjust {
+            for _ in 0..base_dimension {
+                a.push(Deviation::new(discount)?);
+                b.push(Deviation::new(discount)?);
+            }
         }
+        Ok(PredictorCorrector {
+            basic_thresholder: BasicThresholder::new(discount)?,
+            auto_adjust,
+            run_length : 0,
+            deviations_actual: a,
+            deviations_expected: b,
+            max_attributors: DEFAULT_NUMBER_OF_MAX_ATTRIBUTORS
+        })
     }
 
-    pub fn expected_point(di_vector: &DiVector, max_attributors: usize, position: usize, base_dimension: usize, point: &[f32],
-                          forest: &Box<dyn RCF>) -> Vec<f32> {
+    pub fn expected_point<U :?Sized,Label : Sync + Copy, Attributes: Sync + Copy>(di_vector: &DiVector, max_attributors: usize, position: usize, base_dimension: usize, point: &[f32],
+                          forest: &Box<U>) -> Result<Vec<f32>>  where U: AugmentedRCF<Label,Attributes> {
         let mut likely_missing_indices: Vec<usize>;
 
         if base_dimension == 1 {
@@ -62,58 +84,54 @@ impl PredictorCorrector {
 
         let mut answer = Vec::from(point);
         if likely_missing_indices.len() != 0 && (2 * likely_missing_indices.len()  < forest.dimensions()) {
-            let prediction = forest.conditional_field(&likely_missing_indices, point, 1.0, false, 0).unwrap().median;
+            let prediction = forest.conditional_field(&likely_missing_indices, point, 1.0, false, 0)?.median;
             for i in likely_missing_indices{
                 answer[i] = prediction[i];
             }
         }
-        answer
+        Ok(answer)
     }
 
-    fn trigger(&self, candidate: &DiVector, gap: usize, base_dimension: usize, ideal: Option<DiVector>,
-               previous: bool, last_anomaly_descriptor: &AnomalyDescriptor) -> bool {
-        match &last_anomaly_descriptor.attribution {
+    fn trigger(&self, candidate: &DiVector, gap: usize, base_dimension: usize, ideal: &DiVector,
+               last_descriptor: &Descriptor, threshold: f32) -> bool {
+        match &last_descriptor.last_anomaly {
             None => { return true; },
-            Some(x) => {
-                let last_score = last_anomaly_descriptor.score;
-                let dimensions = candidate.dimensions();
-                let difference = gap * base_dimension;
-                if difference < dimensions {
-                    match ideal {
-                        None => {
-                            let mut remainder = 0.0;
-                            for i in (dimensions - difference)..dimensions {
-                                remainder += candidate.high_low_sum(i);
-                            }
-                            return self.basic_thresholder.anomaly_grade_with_factor((remainder as f32) * dimensions as f32 / difference as f32, previous, self.trigger_factor) > 0.0;
-                        },
-                        Some(ref y) => {
+            Some(y) => {
+                match &y.attribution {
+                    None => { return true; },
+                    Some(_x) => {
+                        let last_score = y.score;
+                        let dimensions = candidate.dimensions();
+                        let difference = gap * base_dimension;
+                        if difference < dimensions {
                             let mut differential_remainder = 0.0;
                             for i in (dimensions - difference)..dimensions {
-                                let low_diff = candidate.low[i] - ideal.as_ref().unwrap().low[i];
-                                differential_remainder += if low_diff > 0.0 { low_diff } else { -low_diff };
-                                let high_diff = candidate.high[i] - ideal.as_ref().unwrap().high[i];
-                                differential_remainder += if high_diff > 0.0 { high_diff } else { -high_diff };
+                                let low_diff = candidate.low[i] - ideal.low[i];
+                                differential_remainder += absf32(low_diff as f32);
+                                let high_diff = candidate.high[i] - ideal.high[i];
+                                differential_remainder += absf32(high_diff as f32)
                             }
-                            return (differential_remainder > self.ignore_similar as f64 * last_score as f64) &&
-                                self.basic_thresholder.anomaly_grade_with_factor((differential_remainder as f32) * (dimensions as f32) / difference as f32, previous, self.trigger_factor) > 0.0;
+                            return differential_remainder > DEFAULT_DIFFERENTIAL_FACTOR * last_score
+                                && differential_remainder as f32 * (dimensions as f32) / difference as f32 > threshold;
+                        } else {
+                            return true;
                         }
                     }
-                } else {
-                    return true;
                 }
             }
         }
     }
 
     pub fn apply_basic_corrector(point: &[f32], gap: usize, shingle_size: usize, base_dimension: usize,
-                                 last_anomaly_descriptor: &AnomalyDescriptor, use_difference: bool, time_augmented: bool) -> Vec<f32> {
-        assert!(gap <= shingle_size, "incorrect invocation");
+                                 last_descriptor: &Descriptor, use_difference: bool, time_augmented: bool) -> Vec<f32> {
 
         let mut corrected_point = Vec::from(point);
-        let last_expected_point = last_anomaly_descriptor.expected_rcf_point.as_ref().unwrap();
-        let last_anomaly_point = last_anomaly_descriptor.rcf_point.as_ref().unwrap();
-        let last_relative_index = last_anomaly_descriptor.relative_index.unwrap();
+        if gap > shingle_size || last_descriptor.last_anomaly.is_none() {
+            return corrected_point;
+        }
+        let last_expected_point = &last_descriptor.last_anomaly.as_ref().unwrap().expected_rcf_point;
+        let last_anomaly_point = &last_descriptor.last_anomaly.as_ref().unwrap().anomalous_rcf_point;
+        let last_relative_index = last_descriptor.last_anomaly.as_ref().unwrap().relative_index;
         if gap < shingle_size {
             for i in gap * base_dimension..point.len() {
                 corrected_point[i - gap * base_dimension] = last_expected_point[i];
@@ -137,105 +155,280 @@ impl PredictorCorrector {
         return corrected_point;
     }
 
+    fn centered_transform_pass(base_dimensions: usize, result: &Descriptor, point : &[f32]) -> f32 {
+        let mut max_factor = 0.0f32;
+        let scale = result.scale.as_ref().unwrap();
+        let shift = result.shift.as_ref().unwrap();
+        let deviations = result.difference_deviations.as_ref().unwrap();
+        for i in 0..point.len() {
+            if absf32(point[i]) * scale[i%base_dimensions] > DEFAULT_NORMALIZATION_PRECISION * (1.0+absf32(shift[i%base_dimensions])) {
+                max_factor = 1.0;
+            }
+        }
+
+        if max_factor>0.0 {
+            for i in 0..base_dimensions {
+                let z = absf32(point[point.len() - base_dimensions + i])*scale[i];
+                let dev = maxf32(0.0,deviations[i]);
+                if z > NOISE_FACTOR * dev {
+                    max_factor = minf32(1.0, maxf32(max_factor, z / (3.0 * dev)));
+                }
+            }
+        }
+        max_factor
+    }
+
+    fn calculate_path_deviation(point : &[f32], start_position: usize, index: usize, base_dimension : usize, differenced : bool) -> f32 {
+        let mut position = start_position;
+        let mut variation = 0.0;
+        let mut observation: usize = 0;
+        while position + index + base_dimension < point.len() {
+            variation += if differenced { absf32(point[position + index]) } else { absf32(point[position + index] - point[position + base_dimension + index]) };
+            position += base_dimension;
+            observation += 1;
+        }
+        if observation == 0 {
+            0.0
+        } else {
+            variation / observation as f32
+        }
+    }
+
+    fn construct_uncertainty_box(point :&[f32], start_position : usize, base_dimension : usize, result: &Descriptor) -> Vec<f32>{
+        let method = result.transform_method;
+        let differenced = (method == DIFFERENCE)  || (method == NORMALIZE_DIFFERENCE);
+        let scale = result.scale.as_ref().unwrap();
+        let shift = result.shift.as_ref().unwrap();
+        let mut answer = vec![0.0f32;base_dimension];
+        for y in 0..base_dimension {
+            let shift_amount = DEFAULT_NORMALIZATION_PRECISION * scale[y] * absf32(shift[y]);
+            let path_gap = Self::calculate_path_deviation(point, start_position, y, base_dimension, differenced);
+            let noise_gap = NOISE_FACTOR * result.difference_deviations.as_ref().unwrap()[y];
+            answer[y] = maxf32(scale[y] * path_gap,noise_gap) + shift_amount;
+        }
+        answer
+    }
+
+    fn within_unertainty_box(uncertainty_box: &[f32], start_position : usize, scale: &[f32], point: &[f32], other_point : &[f32]) -> bool {
+        let mut answer = false;
+        for y in 0..uncertainty_box.len() {
+            let a = scale[y] * point[start_position + y];
+            let b = scale[y] * other_point[start_position + y];
+            answer = answer || a < b - uncertainty_box[y] || a > b + uncertainty_box[y];
+        }
+        return !(answer);
+    }
+
+    fn explained_by_conditional_field<U :?Sized,Label : Sync + Copy, Attributes: Sync + Copy>(uncertainty_box: &[f32], point: &[f32], corrected_point : &[f32], start_position : usize,
+                                      result :&Descriptor, forest :&Box<U>) -> Result<bool>
+        where U: AugmentedRCF<Label,Attributes> {
+        let list = forest.near_neighbor_list(corrected_point, 50)?;
+        let mut weight = 0;
+        let total = list.len();
+        for e in list {
+            if Self::within_unertainty_box(uncertainty_box, start_position, result.scale.as_ref().unwrap(), point, &e.1) {
+                weight += 1;
+            }
+        }
+        return Ok(weight as f32 >= DEFAULT_SAMPLING_SUPPORT * total as f32);
+    }
+
+
+    pub fn update_auto_adjust(&mut self, point : &[f32]){
+        if self.auto_adjust && self.run_length > 0 {
+            for y in 0..self.deviations_actual.len() {
+                self.deviations_actual[y].update(point[y] as f64);
+            }
+            self.run_length +=1;
+        }
+    }
+
+    fn update_score(&mut self, score: f32, corrected_score:f32, result: &Descriptor, last_descriptor: &Descriptor){
+        if result.scoring_strategy == EXPECTED_INVERSE_HEIGHT {
+            let last_score = if last_descriptor.scoring_strategy == EXPECTED_INVERSE_HEIGHT {
+                last_descriptor.score
+            } else {
+                0.0
+            };
+            self.basic_thresholder.update(score,corrected_score,last_score);
+        } else {
+            self.basic_thresholder.update_primary(score as f64);
+        }
+    }
 
-    pub fn detect_and_modify(&mut self, result: &mut AnomalyDescriptor, last_anomaly_descriptor : &AnomalyDescriptor, shingle_size: usize, forest : &Box<dyn RCF>, use_difference: bool, time_augmented: bool) {
+    pub fn detect_and_modify<U :?Sized,Label : Sync + Copy, Attributes: Sync + Copy>(&mut self, result: &mut Descriptor, last_descriptor : &Descriptor, shingle_size: usize, forest : &Box<U>)
+        -> Result<()>
+    where U : AugmentedRCF<Label,Attributes> {
         match &result.rcf_point {
-            None => return,
+            None => return Ok(()),
             Some(point) => {
-                let score = forest.score(point).unwrap() as f32;
+                let score = if result.scoring_strategy == EXPECTED_INVERSE_HEIGHT {
+                    forest.score(point)? as f32
+                } else {
+                    forest.density_interpolant(point)?.distance.total() as f32
+                };
+                let method = result.transform_method;
                 result.score = score;
+                let internal_timestamp = result.values_seen;
+                let gap = internal_timestamp - if last_descriptor.last_anomaly.is_none() {0}
+                                          else {last_descriptor.last_anomaly.as_ref().unwrap().values_seen };
                 if score == 0.0 {
-                    return;
+                    return Ok(());
                 }
-                let internal_timestamp = result.internal_timestamp;
-                let base_dimension = forest.dimensions() / shingle_size;
-                result.threshold = self.basic_thresholder.threshold();
-                let previous = self.basic_thresholder.in_potential_anomaly();
 
-                if self.basic_thresholder.anomaly_grade(score, previous) == 0.0 {
-                    result.anomaly_grade = 0.0;
-                    result.in_high_score_region = Some(false);
-                    self.basic_thresholder.update(score, score, 0.0, false);
-                    return;
-                }
+                let dimension = forest.dimensions();
+                let base_dimension = dimension / shingle_size;
+                let (threshold, grade) = if result.scoring_strategy == EXPECTED_INVERSE_HEIGHT {
+                    self.basic_thresholder.threshold_and_grade(score, method, dimension, shingle_size)
+                } else {
+                    self.basic_thresholder.primary_threshold_and_grade(score)
+                };
+                result.threshold = threshold;
 
-                // the score is now high enough to be considered an anomaly
-                result.in_high_score_region = Some(true);
-
-                let gap = internal_timestamp - last_anomaly_descriptor.internal_timestamp;
-
-                let reasonable_forecast = result.forecast_reasonable;
-
-                if reasonable_forecast && gap > 0 && gap <= shingle_size {
-                    if let Some(_expected) = &last_anomaly_descriptor.expected_rcf_point {
-                        let corrected_point = Self::apply_basic_corrector(point, gap, shingle_size, base_dimension,
-                                                                          last_anomaly_descriptor, use_difference, time_augmented);
-                        let corrected_score = forest.score(&corrected_point).unwrap() as f32;
-                        // we know we are looking previous anomalies
-                        if self.basic_thresholder.anomaly_grade(corrected_score, true) == 0.0 {
-                            // fixing the past makes this anomaly go away; nothing to do but process the
-                            // score
-                            // we will not change inHighScoreRegion however, because the score has been
-                            // larger
-                            self.basic_thresholder.update(score, corrected_score, 0.0, false);
-                            result.expected_rcf_point = Some(corrected_point);
-                            result.anomaly_grade = 0.0;
-                            return;
+                if grade == 0.0 {
+                    if self.auto_adjust {
+                        self.run_length = 0;
+                        for y in 0..base_dimension {
+                            self.deviations_actual[y].reset();
+                            self.deviations_expected[y].reset();
                         }
                     }
+                    result.anomaly_grade = 0.0;
+                    self.update_score(score, score, result,last_descriptor);
+                    return Ok(());
                 }
 
-                let attribution = forest.attribution(point).unwrap();
-                // index is 0 .. (shingle_size - 1); this is a departure from java version
-                let index = attribution.max_contribution(base_dimension);
-
-                if !previous && self.trigger(&attribution, gap, base_dimension, None, false, last_anomaly_descriptor) {
-                    result.anomaly_grade = self.basic_thresholder.anomaly_grade(score, false);
-                    result.start_of_anomaly = Some(true);
-                    self.basic_thresholder.update(score, score, 0.0, true);
-                    let start_position = base_dimension * index;
-                    if reasonable_forecast {
-                        let new_point = Self::expected_point(&attribution, self.max_attributors, start_position, base_dimension, point, &forest);
-                        result.expected_rcf_point = Some(new_point);
-                    }
-                    result.relative_index = Some(index as i32 - shingle_size as i32 + 1);
-                    result.attribution = Some(attribution);
-                    return;
-                } else if reasonable_forecast {
-                    let start_position = base_dimension * index;
-                    let new_point = Self::expected_point(&attribution, self.max_attributors, start_position, base_dimension, point, &forest);
-                    let new_attribution = forest.attribution(&new_point).unwrap();
-                    let new_score = forest.score(&new_point).unwrap() as f32;
-
-
-                    if self.trigger(&attribution, gap, base_dimension, Some(new_attribution), previous,
-                                    &last_anomaly_descriptor) {
-                        result.anomaly_grade = self.basic_thresholder.anomaly_grade(score, previous);
-                        result.expected_rcf_point = Some(new_point);
-                        result.relative_index = Some(0);
-                        result.attribution = Some(attribution);
-                        self.basic_thresholder.update(score, new_score, 0.0, true);
+                let candidate = result.scoring_strategy == last_descriptor.scoring_strategy &&
+                    (score > last_descriptor.score
+                    || last_descriptor.score - last_descriptor.threshold > score
+                    - maxf32(threshold, last_descriptor.threshold)
+                    * (1.0 + maxf32(0.2, self.run_length as f32
+                    / (2.0 * maxf32(10.0, shingle_size as f32)))));
+
+
+                let use_difference = method == DIFFERENCE || method == NORMALIZE_DIFFERENCE;
+                let corrected_point = Self::apply_basic_corrector(point, gap, shingle_size, base_dimension,
+                                                                  last_descriptor, use_difference, result.time_augmented);
+                let mut corrected_score = score;
+                if gap > 0 && gap <= shingle_size && last_descriptor.last_anomaly.is_some() {
+                    corrected_score = if result.scoring_strategy == EXPECTED_INVERSE_HEIGHT {
+                        forest.score(&corrected_point)? as f32
+                    } else {
+                        forest.density_interpolant(&corrected_point)?.distance.total() as f32
+                    };
+                    let (_,newgrade) = if result.scoring_strategy == EXPECTED_INVERSE_HEIGHT {
+                        self.basic_thresholder.threshold_and_grade(corrected_score, method, dimension, shingle_size)
                     } else {
-                        // previousIsPotentialAnomaly is true now, but not calling it anomaly either
-                        self.basic_thresholder.update(score, new_score, 0.0, true);
+                        self.basic_thresholder.primary_threshold_and_grade(corrected_score)
+                    };
+                    // we know we are looking previous anomalies
+                    if newgrade == 0.0 {
+                        self.update_auto_adjust(point);
+                        result.correction_mode = ANOMALY_IN_SHINGLE;
+                        self.update_score(score, corrected_score, result,last_descriptor);
                         result.anomaly_grade = 0.0;
-                        return;
+                        return Ok(());
                     }
                 }
-                // previousIsPotentialAnomaly is true now, but not calling it anomaly either
-                self.basic_thresholder.update(score, score, 0.0, true);
-                result.anomaly_grade = 0.0;
-                return;
-            },
+
+                let working_grade = grade * Self::centered_transform_pass(base_dimension, result, &corrected_point);
+                if working_grade == 0.0 {
+                    self.update_auto_adjust(point);
+                    result.correction_mode = NOISE;
+                    result.anomaly_grade = 0.0;
+                    self.update_score(score, corrected_score, result, last_descriptor);
+                    return Ok(());
+                }
+
+
+                let mut attribution = if result.scoring_strategy == EXPECTED_INVERSE_HEIGHT {
+                    forest.attribution(&corrected_point)?
+                } else {
+                    forest.density_interpolant(&corrected_point)?.distance
+                };
+
+                let index = attribution.max_gap_contribution(base_dimension, gap)?;
+                let start_position = index * point.len() / shingle_size;
+                let uncertainty_box = Self::construct_uncertainty_box(point, start_position, base_dimension, result);
+
+                if self.auto_adjust &&
+                    Self::explained_by_conditional_field(&uncertainty_box, point, &corrected_point, start_position,
+                                                        result, forest)? {
+                    self.update_auto_adjust(point);
+                    result.correction_mode = CONDITIONAL_FORECAST;
+                    result.anomaly_grade = 0.0;
+                    self.update_score(score, corrected_score, result, last_descriptor);
+                    return Ok(());
+                }
+
+                let expected_point = Self::expected_point(&attribution, self.max_attributors, start_position, base_dimension, point, forest)?;
+                if gap < shingle_size {
+                    let new_attribution = forest.attribution(&expected_point)?;
+                    if !self.trigger(&attribution, gap, base_dimension, &new_attribution, last_descriptor, threshold) {
+                        result.correction_mode = ANOMALY_IN_SHINGLE;
+                        self.update_auto_adjust(point);
+                        result.anomaly_grade = 0.0;
+                        self.update_score(score, corrected_score, result,last_descriptor);
+                        return Ok(());
+                    }
+                }
+
+                if Self::within_unertainty_box(&uncertainty_box, start_position, result.scale.as_ref().unwrap(), point,
+                                    &expected_point) {
+                    result.correction_mode = FORECAST;
+                    self.update_auto_adjust(point);
+                    result.anomaly_grade = 0.0;
+                    self.update_score(score, corrected_score, result,last_descriptor);
+                    return Ok(());
+                }
+
+
+                if candidate {
+                    if self.auto_adjust {
+                        for y in 0..base_dimension {
+                            self.deviations_actual[y].update(point[dimension - base_dimension + y] as f64);
+                            self.deviations_expected[y].update(expected_point[dimension - base_dimension + y] as f64);
+                        }
+                        if self.run_length > DEFAULT_RUN_ALLOWED {
+                            let mut within = true;
+                            for y in 0..base_dimension {
+                                within =
+                                    absf32(self.deviations_actual[y].mean() as f32 - point[dimension - base_dimension + y]) <
+                                        maxf32(2.0 * self.deviations_actual[y].deviation() as f32,
+                                               NOISE_FACTOR * result.difference_deviations.as_ref().unwrap()[y]);
+                                within = within && absf32(self.deviations_expected[y].mean() as f32
+                                    - expected_point[dimension - base_dimension + y]) < 2.0
+                                    * maxf32(self.deviations_expected[y].deviation() as f32,
+                                             self.deviations_actual[y].deviation() as f32)
+                                    + 0.1 * absf32(
+                                    (self.deviations_actual[y].mean() - self.deviations_expected[y].mean()) as f32);
+                            }
+                            if within { // already adjusted
+                                result.correction_mode = DATA_DRIFT;
+                                result.anomaly_grade = 0.0;
+                                self.update_score(score, corrected_score,result, last_descriptor);
+                                return Ok(());
+                            }
+                        }
+                    }
+                }
+
+
+                self.run_length += 1;
+                result.expected_rcf_point=Some(expected_point);
+                result.anomaly_grade = working_grade;
+                self.update_score(score, corrected_score, result,last_descriptor);
+                result.relative_index = index as i32 - shingle_size as i32 + 1;
+                attribution.normalize(score as f64);
+                result.attribution = Some(attribution);
+                return Ok(());
+            }
         }
     }
 
 
     pub fn set_z_factor(&mut self, factor: f32) {
         self.basic_thresholder.set_z_factor(factor);
-        if factor > self.trigger_factor {
-            self.trigger_factor = factor;
-        }
     }
 
     pub fn set_lower_threshold(&mut self, lower :f32) {
@@ -243,7 +436,7 @@ impl PredictorCorrector {
     }
 
     pub fn set_horizon(&mut self, horizon : f32) {
-        self.basic_thresholder.set_horizon(horizon);
+        self.basic_thresholder.set_score_differencing(horizon);
     }
 
     pub fn set_initial_threshold(&mut self, initial : f32) {
diff --git a/Rust/src/trcf/preprocessor.rs b/Rust/src/trcf/preprocessor.rs
new file mode 100644
index 00000000..8c71ecb5
--- /dev/null
+++ b/Rust/src/trcf/preprocessor.rs
@@ -0,0 +1,512 @@
+use std::cmp::min;
+use rand::Rng;
+use rand_chacha::ChaCha20Rng;
+use rand_core::SeedableRng;
+use crate::common::descriptor::{AnomalyInformation, Descriptor};
+use crate::common::deviation::Deviation;
+use crate::common::rangevector::RangeVector;
+use crate::rcf::{AugmentedRCF, RCF};
+use crate::trcf::basictrcf::BasicTRCFBuilder;
+use crate::trcf::transformer::WeightedTransformer;
+use crate::trcf::types::{ForestMode, ImputationMethod, TransformMethod};
+use crate::trcf::types::ForestMode::{STANDARD, STREAMING_IMPUTE, TIME_AUGMENTED};
+use crate::trcf::types::ImputationMethod::USE_RCF;
+use crate::trcf::types::TransformMethod::{NORMALIZE, NORMALIZE_DIFFERENCE};
+use crate::util::check_argument;
+use crate::types::Result;
+
+const DEFAULT_START_NORMALIZATION: usize = 10;
+
+const DEFAULT_STOP_NORMALIZATION : usize = usize::MAX;
+
+const DEFAULT_CLIP_FACTOR : f32 = 100.0;
+
+const DEFAULT_NORMALIZATION : bool = false;
+
+pub const DEFAULT_DEVIATION_STATES : usize = 5;
+
+#[repr(C)]
+#[derive(Clone)]
+pub struct Preprocessor {
+    timestamp_deviations : Vec<Deviation>,
+    normalize_time : bool,
+    weight_time : f32,
+    transform_decay : f64,
+    previous_timestamps : Vec<u64>,
+    internal_timestamp : usize,
+    initial_values : Vec<Vec<f32>>,
+    initial_timestamps : Vec<u64>,
+    start_normalization : usize,
+    stop_normalization : usize,
+    values_seen : usize,
+    default_fill : Vec<f32>,
+    use_imputed_fraction : f32,
+    number_of_imputed : usize,
+    clip_factor : f32,
+    shingle_size : usize,
+    input_dimensions : usize,
+    last_shingled_input: Vec<f32>,
+    last_shingled_point: Vec<f32>,
+    data_quality : Vec<Deviation>,
+    imputation_method : ImputationMethod,
+    transform_method : TransformMethod,
+    forest_mode : ForestMode,
+    transformer : WeightedTransformer
+}
+
+impl Preprocessor {
+
+    fn past_initial(&self) -> bool{
+        self.values_seen + 1> self.start_normalization ||
+            (self.transform_method != NORMALIZE && self.transform_method != NORMALIZE_DIFFERENCE)
+    }
+
+    pub fn shingled_point<U :?Sized,Label : Sync + Copy, Attributes: Sync + Copy>(&mut self, _rcf: Option<&Box<U>>, input : &[f32], timestamp: u64) -> Result<Option<Vec<f32>>> where
+    U : AugmentedRCF<Label,Attributes> {
+        check_argument(input.len() == self.input_dimensions, "incorrect length")?;
+        for x in input {
+            check_argument(f32::is_finite(*x), " numbers should be finite")?;
+        }
+
+        // the shingle will always be created, possibly wih leading 0's
+        if self.past_initial() {
+            if self.initial_values.len() > 0 {
+                // corresponds to external shingling in MultiRCF
+                // For anomaly detection it is not relevant when we update the state
+                // it can be on seeing the next input (here) or having seen the last input
+                // but forecasting for a single time series is better served
+                // having seen all available data specially when there are a few values
+                self.drain(None as Option<&mut Box<dyn RCF>>)?;
+            }
+            let input = &self.transform(input,timestamp);
+            let mut copy = self.last_shingled_point.clone();
+            Self::shift_vector(&mut copy,input);
+            Ok(Some(copy))
+        } else {
+            Ok(None)
+        }
+    }
+
+    fn shift_vector<T:Copy>(shingle: &mut Vec<T>, point: &[T]) {
+        let dimension = shingle.len();
+        for i in 0..(dimension-point.len()) {
+            shingle[i] = shingle[i + point.len()];
+        }
+        for i in 0..point.len() {
+            shingle[dimension - point.len() + i] = point[i];
+        }
+    }
+
+    fn update_timestamps(&mut self, timestamp:u64,previous: u64){
+        self.timestamp_deviations[0].update(timestamp as f64);
+        self.timestamp_deviations[1].update((timestamp - previous) as f64);
+        let deviation = self.timestamp_deviations[0].deviation();
+        self.timestamp_deviations[2].update(deviation);
+        let difference_mean = self.timestamp_deviations[1].mean();
+        let difference_deviation = self.timestamp_deviations[1].deviation();
+        self.timestamp_deviations[3].update( difference_mean);
+        self.timestamp_deviations[4].update(difference_deviation);
+    }
+
+    fn update(&mut self, input : &[f32], last_shingled_point: &[f32], timestamp: u64) -> Result<()>{
+        let dimension = self.last_shingled_input.len();
+        if self.values_seen < self.stop_normalization {
+            self.transformer.update(input, &self.last_shingled_input[(dimension - self.input_dimensions)..dimension])?;
+            self.update_timestamps(timestamp, self.previous_timestamps[self.shingle_size - 1]);
+        }
+
+        Self::shift_vector(&mut self.last_shingled_input,&input);
+        for (x,y) in self.last_shingled_point.iter_mut().zip(last_shingled_point) {
+            *x = *y;
+        }
+        Self::shift_vector(&mut self.previous_timestamps, &vec![timestamp]);
+        self.internal_timestamp += 1; // will count number of updates
+        self.values_seen += 1;
+        Ok(())
+    }
+
+    pub fn post_process(&mut self, result: &mut Descriptor, point:&[f32],timestamp:u64, _last_descriptor:&Descriptor) -> Result<()> {
+        if self.past_initial() {
+            if let Some(y) = &result.rcf_point {
+                if result.anomaly_grade > 0.0 {
+                    let base_dimension = self.input_dimensions;
+                    let block = (self.shingle_size as i32 + result.relative_index - 1) as usize;
+                    let start: usize = block * base_dimension;
+                    let past_values = if result.relative_index == 0 {
+                        Vec::from(point)
+                    } else {
+                        Vec::from(&self.last_shingled_input[(start + base_dimension)..(start + 2 * base_dimension)])
+                    };
+                    if let Some(x) = &result.expected_rcf_point {
+                        let expected_values_list = vec![self.transformer.invert(&x[start..start + base_dimension],
+                                                                                &self.last_shingled_input[start..start + base_dimension])];
+                        let likelihood_of_values = vec![1.0f32];
+                        result.last_anomaly = Some(
+                            AnomalyInformation {
+                                expected_rcf_point: x.clone(),
+                                anomalous_rcf_point: y.clone(),
+                                relative_index: result.relative_index,
+                                values_seen: result.values_seen,
+                                attribution: result.attribution.clone(),
+                                score: result.score,
+                                grade: result.anomaly_grade,
+                                expected_timestamp: timestamp, // changes not implemented
+                                relevant_attribution: None,
+                                time_attribution: 0.0, // not implemented
+                                past_values,
+                                past_timestamp: self.previous_timestamps[block],
+                                expected_values_list,
+                                likelihood_of_values
+                            }
+                        )
+                    }
+                }
+                self.update(point, y, timestamp)?;
+                result.deviations_post = Some(self.difference_deviations());
+            }
+        } else {
+            self.initial_values.push(Vec::from(point));
+            self.initial_timestamps.push(timestamp);
+            self.values_seen += 1;
+            if self.values_seen == self.start_normalization {
+                result.deviations_post = Some(self.difference_deviations());
+            }
+        }
+        Ok(())
+    }
+
+    pub fn drain<U:?Sized>(&mut self, rcf: Option<&mut Box<U>>) -> Result<()> where U:RCF {
+        if self.values_seen == self.start_normalization {
+            let mut previous = &self.initial_values[0];
+            let mut previous_timestamp = self.initial_timestamps[0];
+            for i in 0..self.initial_values.len() {
+                self.transformer.update(&self.initial_values[i],&previous)?;
+                self.update_timestamps(self.initial_timestamps[i],previous_timestamp);
+                previous_timestamp = self.initial_timestamps[i];
+                previous = &self.initial_values[i];
+            }
+
+            self.previous_timestamps[self.shingle_size - 1] = self.initial_timestamps[0];
+            let dimension = self.shingle_size * self.input_dimensions;
+            for i in 0..self.input_dimensions {
+                self.last_shingled_input[dimension - self.input_dimensions + i] = self.initial_values[0][i];
+            }
+
+            match rcf {
+                None => {
+                    // transformations will work at this point
+                    for (x, &y) in self.initial_values.iter().zip(&self.initial_timestamps) {
+                        let z = &self.transform(x, y);
+                        self.internal_timestamp += 1;
+                        Self::shift_vector(&mut self.last_shingled_input, x);
+                        Self::shift_vector(&mut self.last_shingled_point, z);
+                        Self::shift_vector(&mut self.previous_timestamps, &vec![y]);
+                    }
+                },
+                Some(f) => {
+                    for (x, &y) in self.initial_values.iter().zip(&self.initial_timestamps) {
+                        let z = &self.transform(x, y);
+                        self.internal_timestamp += 1;
+                        Self::shift_vector(&mut self.last_shingled_input, x);
+                        Self::shift_vector(&mut self.last_shingled_point, z);
+                        Self::shift_vector(&mut self.previous_timestamps, &vec![y]);
+                        f.update(z, y)?;
+                    }
+                }
+            }
+            // block deallocation
+            self.initial_timestamps = Vec::new();
+            self.initial_values = Vec::new();
+        }
+        Ok(())
+    }
+
+    pub fn invert_extrapolation(&self, mut range_vector: RangeVector<f32>) -> Result<(RangeVector<f32>,Option<RangeVector<f64>>)> {
+        if self.forest_mode != TIME_AUGMENTED {
+            let dimension = self.input_dimensions * self.shingle_size;
+            self.transformer.invert_forecast(&mut range_vector,&self.last_shingled_input[(dimension - self.input_dimensions)..dimension])?;
+            return Ok((range_vector,None))
+        } else {
+            let augmented = self.get_dimension();
+            let lookahead = range_vector.upper.len()/augmented;
+            let dimension = self.input_dimensions * self.shingle_size;
+            let mut sub_range_vector : RangeVector<f32> = RangeVector::<f32>::new(lookahead*dimension);
+            let mut time_range_vector : RangeVector<f64> = RangeVector::<f64>::new(lookahead);
+            for i in 0..lookahead {
+                for j in 0..dimension {
+                    sub_range_vector.upper[i * dimension + j] = range_vector.upper[i * augmented + j];
+                    sub_range_vector.values[i * dimension + j] = range_vector.values[i * augmented + j];
+                    sub_range_vector.lower[i * dimension + j] = range_vector.lower[i * augmented + j];
+                }
+                time_range_vector.upper[i] = self.invert_time(range_vector.upper[i*augmented + dimension]);
+                time_range_vector.values[i] = self.invert_time(range_vector.values[i*augmented + dimension]);
+                time_range_vector.lower[i] = self.invert_time(range_vector.lower[i*augmented + dimension]);
+                if time_range_vector.upper[i] < time_range_vector.values[i] {
+                    time_range_vector.upper[i] = time_range_vector.values[i];
+                }
+                if time_range_vector.lower[i] > time_range_vector.values[i] {
+                    time_range_vector.lower[i] = time_range_vector.values[i];
+                }
+            }
+            self.transformer.invert_forecast(&mut sub_range_vector,&self.last_shingled_input[(dimension - self.input_dimensions)..dimension])?;
+            time_range_vector.cascaded_add(&vec![self.previous_timestamps[self.shingle_size-1] as f64])?;
+            return Ok((sub_range_vector,Some(time_range_vector)));
+        }
+    }
+
+    fn invert_time(&self,value:f32) -> f64{
+        let factor = if self.weight_time == 0.0 { 0.0 } else { 1.0 / self.weight_time as f64};
+        (value as f64)*factor*self.timescale() + self.timedrift()
+    }
+
+    pub fn internal_timestamp(&self) -> usize {
+        self.internal_timestamp
+    }
+
+    pub fn values_seen(&self) -> usize {
+        self.values_seen
+    }
+
+    pub fn input_dimensions(&self) -> usize {
+        self.input_dimensions
+    }
+
+    pub fn shingle_size(&self) -> usize {
+        self.shingle_size
+    }
+
+    pub fn get_dimension(&self) -> usize {
+        if self.forest_mode == TIME_AUGMENTED {
+            (self.input_dimensions + 1)*self.shingle_size
+        } else {
+            self.input_dimensions * self.shingle_size
+        }
+    }
+
+    pub fn transformation_method(&self) -> TransformMethod {
+           self.transform_method
+    }
+
+    pub fn forest_mode(&self) -> ForestMode {
+        self.forest_mode
+    }
+
+    pub fn shift(&self) -> Vec<f32> {
+        if self.forest_mode != TIME_AUGMENTED {
+            self.transformer.shift()
+        } else {
+            let mut answer = self.transformer.shift();
+             answer.push( self.previous_timestamps[self.shingle_size-1] as f32 + self.timedrift() as f32);
+            answer
+        }
+    }
+
+    pub fn scale(&self) -> Vec<f32> {
+        if self.forest_mode != TIME_AUGMENTED {
+            self.transformer.scale()
+        } else {
+            let mut answer = self.transformer.scale();
+            let factor = if self.weight_time == 0.0 { 0.0 } else { 1.0 / self.weight_time };
+            answer.push(factor * (self.timescale()) as f32);
+            answer
+        }
+    }
+
+    pub fn transform(&self,input:&[f32],timestamp: u64) -> Vec<f32> {
+        let dimension = self.input_dimensions * self.shingle_size;
+        let mut answer = self.transformer.transform
+        (input, &self.last_shingled_input[(dimension - self.input_dimensions)..dimension]);
+
+        if self.forest_mode == TIME_AUGMENTED {
+            let previous = if self.values_seen > 0 {
+                self.previous_timestamps[self.shingle_size - 1]
+            } else {
+                timestamp
+            };
+            answer.push((timestamp as f64 - previous as f64 * (self.weight_time as f64) /
+                self.timescale()) as f32);
+        }
+        answer
+    }
+
+    pub fn difference_deviations(&self) -> Vec<f32> {
+        if self.forest_mode != TIME_AUGMENTED {
+            self.transformer.difference_deviations()
+        } else {
+            let mut answer = self.transformer.difference_deviations();
+            answer.push(self.weight_time as f32 * (self.timestamp_deviations[1].deviation() as f32));
+            answer
+        }
+    }
+
+    fn timescale(&self) -> f64 {
+        self.timestamp_deviations[4].mean() + 1.0
+    }
+
+    fn timedrift(&self) -> f64 {
+        self.timestamp_deviations[3].mean()
+    }
+
+    pub fn is_ready(&self) -> bool {
+        self.internal_timestamp >= self.shingle_size
+    }
+
+    pub fn start_normalization(&self) -> usize {
+        self.start_normalization
+    }
+
+ }
+
+
+pub struct PreprocessorBuilder {
+    normalize_time: bool,
+    input_dimensions: usize ,
+    transform_decay:Option<f64>,
+    weights: Option<Vec<f32>>,
+    weight_time: f32,
+    imputation_method: ImputationMethod,
+    number_of_imputed: usize,
+    clip_factor: f32,
+    use_imputed_fraction: f32,
+    transform_method: TransformMethod,
+    forest_mode : ForestMode,
+    default_fill: Option<Vec<f32>>,
+    shingle_size: usize,
+    random_seed: Option<u64>,
+    start_normalization: usize,
+    stop_normalization : usize
+}
+
+impl Default for PreprocessorBuilder {
+    fn default() -> Self {
+        PreprocessorBuilder{
+            normalize_time: DEFAULT_NORMALIZATION,
+            input_dimensions: 1,
+            transform_decay: Some(0.001),
+            weights: None,
+            weight_time: 1.0,
+            imputation_method: USE_RCF,
+            number_of_imputed: 0,
+            clip_factor: DEFAULT_CLIP_FACTOR,
+            use_imputed_fraction: 0.0,
+            transform_method: NORMALIZE,
+            forest_mode: STANDARD,
+            default_fill: None,
+            shingle_size: 8,
+            random_seed: None,
+            start_normalization: DEFAULT_START_NORMALIZATION,
+            stop_normalization: DEFAULT_STOP_NORMALIZATION,
+        }
+    }
+}
+
+impl PreprocessorBuilder {
+    pub fn new(input_dimensions: usize, shingle_size: usize) -> Self {
+        PreprocessorBuilder { input_dimensions, shingle_size, ..Default::default() }
+    }
+
+    pub fn transform_decay(&mut self, transform_decay: f64) -> &mut PreprocessorBuilder {
+        self.transform_decay = Some(transform_decay);
+        self
+    }
+
+    pub fn forest_mode(&mut self, forest_mode: ForestMode) -> &mut PreprocessorBuilder {
+        self.forest_mode = forest_mode;
+        self
+    }
+
+    pub fn transform_method(&mut self, transform_method: TransformMethod) -> &mut PreprocessorBuilder {
+        self.transform_method = transform_method;
+        self
+    }
+
+    pub fn imputation_method(&mut self, imputation_method: ImputationMethod) -> &mut PreprocessorBuilder {
+        self.imputation_method = imputation_method;
+        self
+    }
+
+    pub fn start_normalization(&mut self, start_normalization: usize) -> &mut PreprocessorBuilder {
+        self.start_normalization = start_normalization;
+        self
+    }
+
+    pub fn stop_normalization(&mut self, stop_normalization: usize) -> &mut PreprocessorBuilder {
+        self.stop_normalization = stop_normalization;
+        self
+    }
+
+    pub fn initial_accept_fraction(&mut self, use_imputed_fraction: f32) -> &mut PreprocessorBuilder {
+        self.use_imputed_fraction = use_imputed_fraction;
+        self
+    }
+
+    pub fn default_fill(&mut self, default_fill: &[f32]) -> &mut PreprocessorBuilder {
+        self.default_fill = Some(Vec::from(default_fill));
+        self
+    }
+
+    pub fn random_seed(&mut self, random_seed: u64) -> &mut PreprocessorBuilder {
+        self.random_seed = Some(random_seed);
+        self
+    }
+
+    pub fn weights(&mut self, weights: &[f32]) -> &mut PreprocessorBuilder {
+        self.weights = Some(Vec::from(weights));
+        self
+    }
+
+    pub fn build(&self) -> Result<Preprocessor> {
+        check_argument(self.forest_mode != STREAMING_IMPUTE, "not yet supported")?;
+        check_argument(self.input_dimensions > 0, "input_dimensions cannot be 0")?;
+        check_argument(self.shingle_size > 0, "shingle size cannot be 0")?;
+        let transform_decay = self.transform_decay.unwrap_or(0.001);
+        let weights = match &self.weights {
+            Some(x) => x.clone(),
+            _ => vec![1.0; self.input_dimensions],
+        };
+        check_argument(self.input_dimensions == weights.len(), "incorrect length of weights")?;
+        check_argument(transform_decay >=0.0 && transform_decay<=1.0, "transform decay must be in [0,1]")?;
+        let mut timestamp_deviations = Vec::new();
+        timestamp_deviations.push(Deviation::new(transform_decay)?);
+        timestamp_deviations.push(Deviation::new(transform_decay)?);
+        for _ in 0..(DEFAULT_DEVIATION_STATES - 2) {
+            timestamp_deviations.push(Deviation::new(0.1*transform_decay)?);
+        }
+        let dimension= self.input_dimensions * self.shingle_size;
+        let augmented = dimension + if self.forest_mode == TIME_AUGMENTED {self.shingle_size} else {0};
+        check_argument(self.start_normalization <= self.stop_normalization, " cannot stop normalization before starting")?;
+        check_argument(self.start_normalization < 2000, "can cause delays, large memory usage")?;
+        let random_seed = self.random_seed.unwrap_or(ChaCha20Rng::from_entropy().gen::<u64>());
+        let default_fill = match &self.default_fill {
+            Some(x) => x.clone(),
+            _ => vec![0.0; self.input_dimensions],
+        };
+        let preprocessor = Preprocessor {
+            timestamp_deviations,
+            normalize_time: self.normalize_time,
+            weight_time: self.weight_time,
+            transform_decay,
+            previous_timestamps: vec![0;self.shingle_size],
+            internal_timestamp: 0,
+            initial_values: vec![],
+            initial_timestamps: vec![],
+            start_normalization: self.start_normalization,
+            stop_normalization: self.stop_normalization,
+            values_seen: 0,
+            default_fill,
+            use_imputed_fraction: self.use_imputed_fraction,
+            number_of_imputed: 0,
+            clip_factor: self.clip_factor,
+            shingle_size: self.shingle_size,
+            input_dimensions: self.input_dimensions,
+            last_shingled_input: vec![0.0;dimension],
+            last_shingled_point: vec![0.0;augmented],
+            data_quality: vec![],
+            imputation_method: self.imputation_method,
+            transform_method: self.transform_method,
+            forest_mode: self.forest_mode,
+            transformer: WeightedTransformer::new(self.transform_method, self.input_dimensions, transform_decay, &weights)?
+        };
+        Ok(preprocessor)
+    }
+}
\ No newline at end of file
diff --git a/Rust/src/trcf/rcfcaster.rs b/Rust/src/trcf/rcfcaster.rs
new file mode 100644
index 00000000..d6dac4ca
--- /dev/null
+++ b/Rust/src/trcf/rcfcaster.rs
@@ -0,0 +1,190 @@
+use rand::Rng;
+use rand_chacha::ChaCha20Rng;
+use rand_core::SeedableRng;
+use crate::common::descriptor::Descriptor;
+use crate::common::rangevector::RangeVector;
+use crate::rcf::{RCF, RCFBuilder, RCFOptions};
+use crate::trcf::errorhandler::ErrorHandler;
+use crate::trcf::predictorcorrector::PredictorCorrector;
+use crate::trcf::preprocessor::{Preprocessor, PreprocessorBuilder};
+use crate::trcf::types::{Calibration, ForestMode, TransformMethod};
+use crate::trcf::types::Calibration::{MINIMAL, NONE};
+use crate::trcf::types::ForestMode::{STANDARD, STREAMING_IMPUTE, TIME_AUGMENTED};
+use crate::trcf::types::TransformMethod::NORMALIZE;
+use crate::types::{Result};
+use crate::rcf::RCFOptionsBuilder;
+use crate::trcf::basictrcf::{BasicTRCF, core_process, State, TRCFOptions, TRCFOptionsBuilder};
+use crate::util::check_argument;
+
+pub const DEFAULT_ERROR_PERCENTILE : f32 = 0.1;
+
+pub const MAX_ERROR_HORIZON : usize = 1024;
+
+pub struct RCFCaster {
+    forecast_horizon : usize,
+    rcf : Box<dyn RCF + Send + Sync>,
+    state: State,
+    error_handler : ErrorHandler,
+    calibration_method : Calibration,
+}
+
+impl RCFCaster {
+
+    pub fn process(&mut self, point: &[f32], timestamp: u64) -> Result<Descriptor>{
+        let mut result = core_process(Some(&self.rcf), &mut self.state, point, timestamp)?;
+        match result.rcf_point.as_ref() {
+            // this path would be taken for all un-normalized transformations
+            // relies on internal shingling
+            Some(x) => {
+                let dimension = x.len();
+                let shingle_size = self.state.preprocessor.shingle_size();
+                self.rcf.update(&x[(dimension - (dimension / shingle_size))..dimension], timestamp as u64)?;
+            },
+            _ => { self.state.preprocessor.drain(Some(&mut self.rcf))?; }
+        }
+
+        if self.rcf.is_output_ready() {
+            self.error_handler.update_actuals(&result.current_input, result.deviations_post.as_ref().expect("should be present"))?;
+            self.error_handler.augment_descriptor(&mut result);
+
+            let mut forecast = self.extrapolate(self.forecast_horizon)?;
+            self.error_handler.update_forecasts(&mut forecast.0)?;
+            result.forecast = Some(forecast.0);
+        }
+        Ok(result)
+    }
+
+    pub fn extrapolate(&self, look_ahead: usize) -> Result<(RangeVector<f32>,Option<RangeVector<f64>>)> {
+        let mut a = self.state.preprocessor.invert_extrapolation(self.rcf.extrapolate(look_ahead)?)?;
+        self.error_handler.calibrate(self.calibration_method, &mut a.0)?;
+        Ok(a)
+    }
+
+    pub fn process_sequentially(&mut self, input: &[(&[f32],u64)]) -> Result<Vec<Descriptor>> {
+       input.iter().map(|(a, b)| self.process(*a, *b))
+            .into_iter().collect()
+    }
+}
+
+
+pub struct RCFCasterOptions {
+    add_error: bool,
+    calibration : Calibration,
+    forecast_horizon: usize,
+    error_horizon: Option<usize>,
+}
+
+pub trait RCFCasterOptionsBuilder: TRCFOptionsBuilder {
+    fn get_rcf_caster_options(&mut self) -> &mut RCFCasterOptions;
+    fn transform_decay(&mut self, transform_decay: f64) -> &mut Self {
+        self.get_trcf_options().transform_decay = Some(transform_decay);
+        self
+    }
+    fn calibration(&mut self, calibration: Calibration) -> &mut Self {
+        self.get_rcf_caster_options().calibration = calibration;
+        self
+    }
+    fn forecast_horizon(&mut self, forecast_horizon: usize) -> &mut Self {
+        self.get_rcf_caster_options().forecast_horizon = forecast_horizon;
+        self
+    }
+    fn error_horizon(&mut self, error_horizon: usize) -> &mut Self {
+        self.get_rcf_caster_options().error_horizon = Some(error_horizon);
+        self
+    }
+}
+
+
+impl Default for RCFCasterOptions {
+    fn default() -> Self {
+        RCFCasterOptions{
+            add_error: false,
+            calibration: MINIMAL,
+            forecast_horizon: 10,
+            error_horizon: None
+        }
+    }
+}
+
+pub struct RCFCasterBuilder {
+    id: u64,
+    input_dimensions: usize,
+    shingle_size: usize,
+    trcf_options: TRCFOptions,
+    rcf_options : RCFOptions<u64,u64>,
+    rcf_caster_options: RCFCasterOptions,
+}
+
+impl RCFOptionsBuilder<u64,u64> for RCFCasterBuilder {
+    fn get_rcf_options(&mut self) -> &mut RCFOptions<u64,u64> {
+        &mut self.rcf_options
+    }
+}
+
+impl TRCFOptionsBuilder for RCFCasterBuilder {
+    fn get_trcf_options(&mut self) -> &mut TRCFOptions {
+        &mut self.trcf_options
+    }
+}
+
+impl RCFCasterOptionsBuilder for RCFCasterBuilder {
+    fn get_rcf_caster_options(&mut self) -> &mut RCFCasterOptions {
+        &mut self.rcf_caster_options
+    }
+}
+
+impl RCFCasterBuilder {
+    pub fn new(id : u64,input_dimensions: usize, shingle_size: usize, forecast_horizon: usize) -> Self {
+        RCFCasterBuilder {
+            id,
+            input_dimensions,
+            shingle_size,
+            trcf_options: Default::default(),
+            rcf_options : Default::default(),
+            rcf_caster_options: RCFCasterOptions {forecast_horizon, ..Default::default()}
+        }
+    }
+
+    pub fn build(&self) -> Result<RCFCaster> {
+        check_argument(self.trcf_options.forest_mode!= STREAMING_IMPUTE, "not yet supported")?;
+        check_argument( self.input_dimensions > 0, "input_dimensions cannot be 0")?;
+        check_argument( self.shingle_size > 0, "shingle size cannot be 0")?;
+        self.rcf_options.validate()?;
+        self.trcf_options.validate(self.input_dimensions)?;
+        let output_after = self.rcf_options.output_after.unwrap_or(1 + self.rcf_options.capacity / 4);
+        let time_decay = self.rcf_options.time_decay.unwrap_or(0.1/self.rcf_options.capacity as f64);
+        let transform_decay = self.trcf_options.transform_decay.unwrap_or(0.1/self.rcf_options.capacity as f64);
+        let weights = match &self.trcf_options.weights {
+            Some(x) => x.clone(),
+            _ => vec![1.0; self.input_dimensions]
+        };
+        let random_seed = self.rcf_options.random_seed.unwrap_or( ChaCha20Rng::from_entropy().gen::<u64>());
+        let rcf = RCFBuilder::<u64,u64>::new(self.input_dimensions,self.shingle_size)
+            .tree_capacity(self.rcf_options.capacity).number_of_trees(self.rcf_options.number_of_trees)
+            .random_seed(random_seed)
+            .parallel_enabled(self.rcf_options.parallel_enabled).time_decay(time_decay)
+            .bounding_box_cache_fraction(self.rcf_options.bounding_box_cache_fraction)
+            .output_after(output_after)
+            .initial_accept_fraction(self.rcf_options.initial_accept_fraction).build_default()?;
+        let preprocessor = PreprocessorBuilder::new(self.input_dimensions,self.shingle_size)
+            .transform_decay(transform_decay)
+            .transform_method(self.trcf_options.transform_method)
+            .forest_mode(self.trcf_options.forest_mode)
+            .random_seed(random_seed+1)
+            .weights(&weights)
+            .start_normalization(self.trcf_options.start_normalization)
+            .stop_normalization(self.trcf_options.stop_normalization).build()?;
+        let predictor_corrector = PredictorCorrector::new(transform_decay,!self.trcf_options.verbose,self.input_dimensions)?;
+
+        let error_horizon= self.rcf_caster_options.error_horizon.unwrap_or(MAX_ERROR_HORIZON);
+        check_argument(error_horizon<=MAX_ERROR_HORIZON, "calibration horizon should be smaller")?;
+        let error_handler = ErrorHandler::new(self.rcf_caster_options.add_error,self.input_dimensions,self.rcf_caster_options.forecast_horizon,error_horizon,DEFAULT_ERROR_PERCENTILE);
+        Ok(RCFCaster{
+            forecast_horizon: self.rcf_caster_options.forecast_horizon,
+            rcf,
+            state: State::new(self.id,1,self.trcf_options.scoring_strategy,predictor_corrector,preprocessor)?,
+            error_handler,
+            calibration_method: self.rcf_caster_options.calibration
+        })
+    }
+}
diff --git a/Rust/src/trcf/transformer.rs b/Rust/src/trcf/transformer.rs
new file mode 100644
index 00000000..bf8efd49
--- /dev/null
+++ b/Rust/src/trcf/transformer.rs
@@ -0,0 +1,223 @@
+use crate::common::deviation::Deviation;
+use crate::common::rangevector::RangeVector;
+use crate::trcf;
+use crate::trcf::preprocessor::Preprocessor;
+use crate::trcf::types::TransformMethod;
+use crate::trcf::types::TransformMethod::{DIFFERENCE, NONE, NORMALIZE, NORMALIZE_DIFFERENCE, SUBTRACT_MA,WEIGHTED};
+use crate::util::check_argument;
+use crate::trcf::preprocessor::DEFAULT_DEVIATION_STATES;
+use crate::types::Result;
+
+#[repr(C)]
+#[derive(Clone)]
+pub struct WeightedTransformer {
+    transform_method : TransformMethod,
+    deviations : Vec<Deviation>,
+    input_length : usize,
+    weights : Vec<f32>,
+}
+
+impl WeightedTransformer {
+
+    pub fn new(transform_method : TransformMethod, input_length : usize, transform_decay: f64, weights : &[f32]) -> Result<Self> {
+        check_argument(input_length == weights.len(), "incorrect lengths")?;
+        let mut deviations : Vec<Deviation> = Vec::new();
+        for _i in 0..2*input_length {
+            deviations.push(Deviation::new(transform_decay)?);
+        }
+        for _i in 0..(DEFAULT_DEVIATION_STATES - 2) * input_length {
+            deviations.push(Deviation::new(0.1 * transform_decay)?);
+        }
+        if transform_method == NONE{
+            for w in weights {
+                check_argument( *w ==1.0, "incorrect setting for NONE transformation")?;
+            }
+        }
+        Ok(WeightedTransformer{
+            transform_method,
+            deviations,
+            input_length,
+            weights: Vec::from(weights)
+        })
+    }
+
+     pub fn update(&mut self, input: &[f32], previous: &[f32]) -> Result<()> {
+         check_argument(input.len() == self.input_length, " incorrect length")?;
+         check_argument(previous.len() == self.input_length, " incorrect length")?;
+         for i in 0..self.input_length {
+             self.deviations[i].update(input[i] as f64);
+             let deviation = self.deviations[i].deviation();
+             self.deviations[i + self.input_length].update((input[i] - previous[i]) as f64);
+             let difference_mean = self.deviations[i + self.input_length].mean();
+             let difference_deviation = self.deviations[i + self.input_length].deviation();
+             self.deviations[i + 2 * self.input_length].update(deviation);
+             self.deviations[i + 3 * self.input_length].update(difference_mean);
+             self.deviations[i + 4 * self.input_length].update(difference_deviation);
+         }
+         Ok(())
+     }
+
+    fn normalized_scale(&self, i: usize) -> f32 {
+        (self.deviations[ i + 2 * self.input_length].mean() + 1.0) as f32
+    }
+
+    fn basic_shift(&self, i: usize) -> f32 {
+        self.deviations[i].mean() as f32
+    }
+
+    fn shift_difference(&self, i: usize) -> f32 {
+        self.deviations[ i + self.input_length].mean()  as f32
+    }
+
+    fn basic_drift(&self, i: usize) -> f32 {
+        self.deviations[ i + 3*self.input_length].mean()  as f32
+    }
+
+    fn difference(&self, input : &mut [f32], previous : &[f32]) {
+         for (x,y) in input.iter_mut().zip(previous){
+             *x -= y;
+         }
+    }
+
+    fn add(&self, input : &mut [f32], previous : &[f32]) {
+        for (x,y) in input.iter_mut().zip(previous){
+            *x += y;
+        }
+    }
+
+    fn add_ma(&self, input : &mut [f32]) {
+        for i in 0..input.len() {
+            input[i] += self.basic_shift(i);
+        }
+    }
+
+    fn subtract_ma(&self, input : &mut [f32]) {
+        for i in 0..input.len() {
+            input[i] -=  self.basic_shift(i);
+        }
+    }
+
+    fn weight(&self, input : &mut[f32]){
+        for (x,y) in input.iter_mut().zip(&self.weights){
+            *x = *x * (*y);
+        }
+    }
+
+    fn weight_invert(&self, input : &mut[f32]){
+        for (x,y) in input.iter_mut().zip(&self.weights){
+            *x = if *y == 0.0 {0.0} else {*x/y};
+        }
+    }
+
+    fn normalize(&self, input : &mut [f32]){
+        for i in 0..input.len() {
+                input[i] -= self.basic_shift(i);
+                input[i] = input[i] /self.normalized_scale(i);
+        }
+    }
+
+    fn normalize_invert(&self, input : &mut [f32]){
+        for i in 0..input.len() {
+            input[i] = input[i]*self.normalized_scale(i);
+            input[i] += self.basic_shift(i);
+        }
+    }
+
+    fn normalize_difference(&self, input : &mut [f32], previous : &[f32]){
+        for i in 0..input.len() {
+            input[i] -= previous[i];
+            input[i] = input[i]/ self.normalized_scale(i);
+        }
+    }
+
+    fn normalize_difference_invert(&self, input : &mut [f32], previous : &[f32]) {
+        for i in 0..input.len() {
+            input[i] = input[i]* self.normalized_scale(i);
+            input[i] +=  previous[i];
+        }
+    }
+
+    pub fn transform(&self, input : &[f32], previous : &[f32]) -> Vec<f32> {
+        let mut answer: Vec<f32> = Vec::from(input);
+        match &self.transform_method {
+            NONE => {},
+            DIFFERENCE=> {self.difference(&mut answer,previous)},
+            SUBTRACT_MA=> {self.subtract_ma(&mut answer)},
+            NORMALIZE=> {self.normalize(&mut answer)},
+            NORMALIZE_DIFFERENCE => {self.normalize_difference(&mut answer, previous)},
+            WEIGHTED => {self.weight(&mut answer)},
+        };
+        answer
+    }
+
+    pub fn invert(&self, input : &[f32], previous : &[f32]) -> Vec<f32> {
+        let mut answer: Vec<f32> = Vec::from(input);
+        for (x,y) in answer.iter_mut().zip(&self.weights){
+            *x = if *y ==0.0 {0.0} else {*x/y};
+        }
+        match &self.transform_method {
+            NONE => {},
+            DIFFERENCE=> {self.add(&mut answer,previous)},
+            SUBTRACT_MA=> {self.add_ma(&mut answer)},
+            NORMALIZE=> {self.normalize_invert(&mut answer)},
+            NORMALIZE_DIFFERENCE => {self.normalize_difference_invert(&mut answer,previous)},
+            WEIGHTED => {self.weight_invert(&mut answer)},
+        };
+        answer
+    }
+
+    pub fn invert_forecast(&self, forecast :&mut RangeVector<f32>, previous : &[f32]) -> Result<()>{
+        let horizon = forecast.values.len() / self.input_length;
+        for i in 0..horizon {
+            for j in 0..self.input_length {
+                let factor = if self.weights[j] == 0.0 { 0.0 } else { 1.0 / self.weights[j] };
+                if self.transform_method != NONE {
+                    forecast.scale(i * self.input_length + j, factor as f32);
+                }
+
+                if self.transform_method == NORMALIZE || self.transform_method == NORMALIZE_DIFFERENCE {
+                    forecast.scale(i * self.input_length + j, self.normalized_scale(j));
+                }
+
+                forecast.shift(i * self.input_length + j, i as f32 * self.basic_drift(j));
+
+                if self.transform_method == NORMALIZE || self.transform_method == SUBTRACT_MA {
+                    forecast.shift(i * self.input_length + j, self.basic_shift(j));
+                }
+            }
+        }
+        if self.transform_method == DIFFERENCE || self.transform_method == NORMALIZE_DIFFERENCE {
+            forecast.cascaded_add(previous)?;
+        }
+        Ok(())
+    }
+
+    pub fn scale(&self) -> Vec<f32> {
+        let mut answer = self.weights.clone();
+        if self.transform_method == NORMALIZE || self.transform_method == NORMALIZE_DIFFERENCE {
+            for i in 0..self.input_length {
+                answer[i] *= self.normalized_scale(i);
+            }
+        }
+        answer
+    }
+
+    pub fn shift(&self) -> Vec<f32> {
+        let mut answer = vec![0.0;self.input_length];
+        if self.transform_method == NORMALIZE || self.transform_method == SUBTRACT_MA {
+            for i in 0..self.input_length {
+                answer[i] += self.basic_shift(i);
+            }
+        }
+        answer
+    }
+
+    pub fn difference_deviations(&self) -> Vec<f32> {
+        let mut answer = vec![0.0f32;self.input_length];
+        for i in 0..self.input_length {
+            answer[i] = self.deviations[ i + 4*self.input_length].mean() as f32;
+        }
+        answer
+    }
+
+}
diff --git a/Rust/src/trcf/types.rs b/Rust/src/trcf/types.rs
new file mode 100644
index 00000000..aee7acc7
--- /dev/null
+++ b/Rust/src/trcf/types.rs
@@ -0,0 +1,158 @@
+use std::fmt;
+
+#[derive(Clone, Copy)]
+#[derive(PartialEq)]
+pub enum TransformMethod {
+    NONE,
+    WEIGHTED,
+    DIFFERENCE,
+    SUBTRACT_MA,
+    NORMALIZE,
+    NORMALIZE_DIFFERENCE
+}
+
+impl fmt::Display for TransformMethod {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let printable = match *self {
+            TransformMethod::NONE => "NONE",
+            TransformMethod::NORMALIZE => "NORMALIZE" ,
+            TransformMethod::NORMALIZE_DIFFERENCE=> "NORMALIZE_DIFFERENCE",
+            TransformMethod::SUBTRACT_MA=> "SUBTRACT_MA",
+            TransformMethod::DIFFERENCE => "DIFFERENCE",
+            TransformMethod::WEIGHTED=> "WEIGHTED",
+        };
+        write!(f, "{}", printable)
+    }
+}
+
+#[derive(Clone, Copy)]
+#[derive(PartialEq)]
+pub enum ImputationMethod {
+
+    //use a fixed set of specified values (same as input dimension)
+    FIXED,
+    // last known value in each input dimension
+    PREVIOUS,
+    //next seen value in each input dimension
+    NEXT,
+    // linear interpolation
+    LINEAR,
+    // use the RCF imputation; but would often require a minimum number of
+    // observations and would use defaults (often LINEAR) till that point
+    USE_RCF
+}
+
+#[derive(Clone, Copy)]
+#[derive(PartialEq)]
+pub enum ForestMode {
+    /**
+     * a standard mode that uses shingling and most known applications; it uses the
+     * last K data points where K=1 would correspond to non time series (population)
+     * analysis
+     */
+    STANDARD,
+    /**
+     * time stamp is added automatically to data to correlate within RCF itself;
+     * this is useful for event streaams and for modeling sparse events. Option is
+     * provided to normalize the time gaps.
+     */
+    TIME_AUGMENTED,
+    /**
+     * uses various Fill-In strageies for data with gaps but not really sparse. Must
+     * have shingleSize greater than 1, typically larger shingle size is better, and
+     * so is fewer input dimensions
+     */
+    STREAMING_IMPUTE
+}
+
+// alternate scoring that can be thresholded differently
+
+#[derive(Clone, Copy)]
+#[derive(PartialEq)]
+pub enum ScoringStrategy{
+    EXPECTED_INVERSE_HEIGHT,
+    /**
+     * This is the same as STANDARD mode where the scoring function is switched to
+     * distances between the vectors. Since RCFs build a multiresolution tree, and
+     * in the aggregate, preserves distances to some approximation, this provides an
+     * alternate anomaly detection mechanism which can be useful for shingleSize = 1
+     * and (dynamic) population analysis via RCFs. Specifially it switches the
+     * scoring to be based on the distance computation in the Density Estimation
+     * (interpolation). This allows for a direct comparison of clustering based
+     * outlier detection and RCFs over numeric vectors. All transformations
+     * available to the STANDARD mode in the ThresholdedRCF are available for this
+     * mode as well; this does not affect RandomCutForest core in any way. For
+     * timeseries analysis the STANDARD mode is recommended, but this does provide
+     * another option in combination with the TransformMethods.
+     */
+    DISTANCE
+}
+
+#[derive(Clone, Copy)]
+#[derive(PartialEq)]
+pub enum CorrectionMode {
+
+    /**
+     * default behavior, no correction
+     */
+    NONE,
+
+    /**
+     * due to transforms, or due to input noise
+     */
+    NOISE,
+
+    /**
+     * elimination due to multi mode operation, not in use currently
+     */
+
+    MULTI_MODE,
+
+    /**
+     * effect of an anomaly in shingle
+     */
+
+    ANOMALY_IN_SHINGLE,
+
+    /**
+     * conditional forecast, using conditional fields
+     */
+
+    CONDITIONAL_FORECAST,
+
+    /**
+     * forecasted value was not very different
+     */
+
+    FORECAST,
+
+    /**
+     * data drifts and level shifts, will not be corrected unless level shifts are
+     * turned on
+     */
+
+    DATA_DRIFT
+
+}
+
+#[derive(Clone, Copy)]
+#[derive(PartialEq)]
+pub enum Calibration {
+
+    NONE,
+
+    /**
+     * a basic staring point where the intervals are adjusted to be the minimal
+     * necessary based on past error the intervals are smaller -- but the interval
+     * precision will likely be close to 1 - 2 * percentile
+     */
+    MINIMAL,
+
+    /**
+     * a Markov inequality based interval, where the past error and model errors are
+     * additive. The interval precision is likely higher than MINIMAL but so are the
+     * intervals.
+     */
+    SIMPLE,
+
+}
\ No newline at end of file
diff --git a/Rust/src/types.rs b/Rust/src/types.rs
index 919f9c06..7a19ef49 100644
--- a/Rust/src/types.rs
+++ b/Rust/src/types.rs
@@ -1,3 +1,4 @@
+use std::hash::Hash;
 use crate::errors;
 
 /// A trait that defines a maximum value constant.
@@ -17,13 +18,11 @@ impl Max for usize {
     const MAX: usize = usize::MAX;
 }
 
-pub type PointIndex = usize;
-
 /// The Location trait is used as a shorthand for the various traits needed by store (e.g., point
 /// store, node store) locations. These are the values vended by stores to reference a stored
 /// value.
 pub trait Location:
-    Copy + Max + std::cmp::PartialEq + TryFrom<usize> + std::marker::Send + Sync
+    Copy + Max + Eq + Hash + PartialEq + TryFrom<usize> + Send + Sync
 {
 }
 
diff --git a/Rust/src/util.rs b/Rust/src/util.rs
index 05ac1106..38f0d5fe 100644
--- a/Rust/src/util.rs
+++ b/Rust/src/util.rs
@@ -7,6 +7,18 @@ pub(crate) fn divide(a: &mut f64, b: usize) {
     *a /= b as f64;
 }
 
+pub(crate) fn maxf32(a : f32, b:f32) -> f32 {
+    if a<b {b} else {a}
+}
+
+pub(crate) fn minf32(a : f32, b:f32) -> f32 {
+    if a<b {a} else {b}
+}
+
+pub(crate) fn absf32(a : f32) -> f32 {
+    if a<0.0 {-a} else {a}
+}
+
 pub(crate) fn add_nbr(a: &(f64, usize, f64), b: &mut Vec<(f64, usize, f64)>) {
     b.push(*a)
 }
diff --git a/Rust/src/visitor/attributionvisitor.rs b/Rust/src/visitor/attributionvisitor.rs
index 8bf8fc97..63229208 100644
--- a/Rust/src/visitor/attributionvisitor.rs
+++ b/Rust/src/visitor/attributionvisitor.rs
@@ -4,6 +4,7 @@ use crate::{
     common::divector::DiVector,
     samplerplustree::nodeview::LargeNodeView,
     visitor::visitor::{Visitor, VisitorInfo},
+    types::Result,
 };
 
 #[repr(C)]
@@ -19,7 +20,7 @@ pub struct AttributionVisitor {
 }
 
 impl AttributionVisitor {
-    pub fn new(tree_mass: usize, dimension: usize, visitor_info: &VisitorInfo) -> Self {
+    pub fn new(tree_mass: usize, dimension: usize, _visitor_info: &VisitorInfo) -> Self {
         AttributionVisitor {
             tree_mass,
             leaf_index: usize::MAX,
@@ -48,28 +49,29 @@ impl Visitor<LargeNodeView, DiVector> for AttributionVisitor {
         point: &[f32],
         visitor_info: &VisitorInfo,
         node_view: &LargeNodeView,
-    ) {
-        let mass = node_view.get_mass();
-        self.leaf_index = node_view.get_leaf_index();
+    ) -> Result<()> {
+        let mass = node_view.mass();
+        self.leaf_index = node_view.leaf_index();
         if mass > visitor_info.ignore_mass {
             if node_view.is_duplicate() {
                 self.score = (visitor_info.damp)(mass, self.tree_mass)
-                    * (visitor_info.score_seen)(node_view.get_depth(), mass);
+                    * (visitor_info.score_seen)(node_view.depth(), mass);
                 self.hit_duplicate = true;
                 self.use_shadow_box = true;
             } else {
-                self.score = (visitor_info.score_unseen)(node_view.get_depth(), mass);
+                self.score = (visitor_info.score_unseen)(node_view.depth(), mass);
                 node_view.assign_probability_of_cut(&mut self.probability, point);
                 assert!(abs(self.probability.total() - 1.0) < 1e-6);
                 self.attribution.add_from(&self.probability, self.score);
             }
         } else {
-            self.score = (visitor_info.score_unseen)(node_view.get_depth(), mass);
+            self.score = (visitor_info.score_unseen)(node_view.depth(), mass);
             self.use_shadow_box = true;
         }
+        Ok(())
     }
 
-    fn accept(&mut self, point: &[f32], visitor_info: &VisitorInfo, node_view: &LargeNodeView) {
+    fn accept(&mut self, point: &[f32], visitor_info: &VisitorInfo, node_view: &LargeNodeView) -> Result<()>{
         if !self.converged {
             if !self.use_shadow_box {
                 node_view.assign_probability_of_cut(&mut self.probability, point);
@@ -81,7 +83,7 @@ impl Visitor<LargeNodeView, DiVector> for AttributionVisitor {
                 self.converged = true;
             } else {
                 let new_value =
-                    (visitor_info.score_unseen)(node_view.get_depth(), node_view.get_mass());
+                    (visitor_info.score_unseen)(node_view.depth(), node_view.mass());
                 if !self.hit_duplicate {
                     self.score = (1.0 - prob) * self.score + prob * new_value;
                 }
@@ -89,17 +91,18 @@ impl Visitor<LargeNodeView, DiVector> for AttributionVisitor {
                 self.attribution.add_from(&self.probability, new_value);
             }
         }
+        Ok(())
     }
 
-    fn result(&self, visitor_info: &VisitorInfo) -> DiVector {
+    fn result(&self, visitor_info: &VisitorInfo) -> Result<DiVector> {
         let t = (visitor_info.normalizer)(self.score, self.tree_mass);
         let mut answer = self.attribution.clone();
         answer.normalize(t);
-        answer
+        Ok(answer)
     }
 
-    fn is_converged(&self) -> bool {
-        self.converged
+    fn is_converged(&self) -> Result<bool> {
+        Ok(self.converged)
     }
 
     fn use_shadow_box(&self) -> bool {
diff --git a/Rust/src/visitor/imputevisitor.rs b/Rust/src/visitor/imputevisitor.rs
index e14b9ded..8acb9c6b 100644
--- a/Rust/src/visitor/imputevisitor.rs
+++ b/Rust/src/visitor/imputevisitor.rs
@@ -5,7 +5,9 @@ use rand_chacha::ChaCha20Rng;
 use crate::{
     samplerplustree::nodeview::MediumNodeView,
     visitor::visitor::{SimpleMultiVisitor, Visitor, VisitorInfo},
+    types::Result
 };
+use crate::util::check_argument;
 
 #[repr(C)]
 pub struct ImputeVisitor {
@@ -77,9 +79,9 @@ impl Visitor<MediumNodeView, (f64, usize, f64)> for ImputeVisitor {
         point: &[f32],
         visitor_info: &VisitorInfo,
         node_view: &MediumNodeView,
-    ) {
-        let mass = node_view.get_mass();
-        let leaf_point = node_view.get_leaf_point();
+    ) -> Result<()>{
+        let mass = node_view.mass();
+        let leaf_point = node_view.leaf_point();
         let mut new_point = Vec::from(point);
         for i in self.missing.iter() {
             new_point[*i] = leaf_point[*i];
@@ -90,69 +92,65 @@ impl Visitor<MediumNodeView, (f64, usize, f64)> for ImputeVisitor {
         if mass > visitor_info.ignore_mass || self.missing.len() != 0 {
             if node_view.is_duplicate() {
                 score = (visitor_info.damp)(mass, self.tree_mass)
-                    * (visitor_info.score_seen)(node_view.get_depth(), mass);
+                    * (visitor_info.score_seen)(node_view.depth(), mass);
                 converged = true;
             } else {
-                score = (visitor_info.score_unseen)(node_view.get_depth(), mass);
+                score = (visitor_info.score_unseen)(node_view.depth(), mass);
             }
         } else {
             // shadow box is undefined for missing values
             // for not missing values, this block corresponds to exact same evaluation
             // in score and attribution visitor
             // note that multi-visitors ignore the shadow box anyways
-            score = (visitor_info.score_unseen)(node_view.get_depth(), mass);
+            score = (visitor_info.score_unseen)(node_view.depth(), mass);
             self.use_shadow_box = true;
         }
         let dist = (visitor_info.distance)(&new_point, &leaf_point);
         self.stack.push(ImputeVisitorStackElement {
             converged,
             score,
-            index: node_view.get_leaf_index(),
+            index: node_view.leaf_index(),
             random: self.rng.gen::<f32>(),
             distance: dist,
         });
+        Ok(())
     }
 
-    fn accept(&mut self, point: &[f32], visitor_info: &VisitorInfo, node_view: &MediumNodeView) {
-        assert!(
-            self.stack.len() > 0,
-            " there should have been an accept_leaf call which would have created a non-null stack"
-        );
-        let mut top_of_stack = self.stack.pop().unwrap();
+    fn accept(&mut self, _point: &[f32], visitor_info: &VisitorInfo, node_view: &MediumNodeView) -> Result<()>{
+        let mut top_of_stack = self.stack.pop().expect(" stack cannot be empty");
         if !top_of_stack.converged {
             let prob = if !self.use_shadow_box {
-                // note that this probablity ignores any missing coordinates
+                // note that this probability ignores any missing coordinates
                 // which would be accurate since the value used is inside the box
-                node_view.get_probability_of_cut()
+                node_view.probability_of_cut()
             } else {
-                node_view.get_shadow_box_probability_of_cut()
+                node_view.shadow_box_probability_of_cut()
             };
             if prob == 0.0 {
                 top_of_stack.converged = true;
             } else {
                 let new_score = (1.0 - prob) * top_of_stack.score
                     + prob
-                        * (visitor_info.score_unseen)(node_view.get_depth(), node_view.get_mass());
+                        * (visitor_info.score_unseen)(node_view.depth(), node_view.mass());
                 top_of_stack.converged = false;
                 top_of_stack.score = new_score;
             }
             self.stack.push(top_of_stack);
         }
+        Ok(())
     }
 
-    fn result(&self, visitor_info: &VisitorInfo) -> (f64, usize, f64) {
-        assert_eq!(
-            self.stack.len(),
-            1,
+    fn result(&self, visitor_info: &VisitorInfo) -> Result<(f64, usize, f64)> {
+        check_argument(self.stack.len() == 1,
             "incorrect state, stack length should be 1"
-        );
-        let top_of_stack = self.stack.last().unwrap();
+        )?;
+        let top_of_stack = self.stack.last().expect("should be length 1");
         let t = (visitor_info.normalizer)(top_of_stack.score, self.tree_mass);
-        (t, top_of_stack.index, top_of_stack.distance)
+        Ok((t, top_of_stack.index, top_of_stack.distance))
     }
 
-    fn is_converged(&self) -> bool {
-        self.stack.len() != 0 && self.stack.last().unwrap().converged
+    fn is_converged(&self) -> Result<bool> {
+        Ok(self.stack.len() != 0 && self.stack.last().expect("cannot be empty").converged)
     }
 
     fn use_shadow_box(&self) -> bool {
@@ -166,10 +164,9 @@ impl SimpleMultiVisitor<MediumNodeView, (f64, usize, f64)> for ImputeVisitor {
         _point: &[f32],
         _node_view: &MediumNodeView,
         visitor_info: &VisitorInfo,
-    ) {
-        assert!(self.stack.len() >= 2, "incorrect state");
-        let mut top_of_stack = self.stack.pop().unwrap();
-        let mut next_of_stack = self.stack.pop().unwrap();
+    ) -> Result<()>{
+        let mut top_of_stack = self.stack.pop().expect("has to be size 1, corrupt state");
+        let mut next_of_stack = self.stack.pop().expect("has to be size 2, corrupt state");
 
         if self.adjusted_score(&top_of_stack, &visitor_info)
             < self.adjusted_score(&next_of_stack, &visitor_info)
@@ -180,5 +177,6 @@ impl SimpleMultiVisitor<MediumNodeView, (f64, usize, f64)> for ImputeVisitor {
             next_of_stack.converged = top_of_stack.converged || next_of_stack.converged;
             self.stack.push(next_of_stack);
         }
+        Ok(())
     }
 }
diff --git a/Rust/src/visitor/interpolationvisitor.rs b/Rust/src/visitor/interpolationvisitor.rs
index 1ec598dd..a8dac0bb 100644
--- a/Rust/src/visitor/interpolationvisitor.rs
+++ b/Rust/src/visitor/interpolationvisitor.rs
@@ -2,7 +2,9 @@ use crate::{
     common::{directionaldensity::InterpolationMeasure},
     samplerplustree::nodeview::LargeNodeView,
     visitor::visitor::{Visitor, VisitorInfo},
+    types::Result,
 };
+use crate::errors::RCFError;
 
 #[repr(C)]
 pub struct InterpolationVisitor {
@@ -44,28 +46,31 @@ impl Visitor<LargeNodeView, InterpolationMeasure> for InterpolationVisitor {
         point: &[f32],
         visitor_info: &VisitorInfo,
         node_view: &LargeNodeView,
-    ) {
-        let mass = node_view.get_mass();
-        self.leaf_index = node_view.get_leaf_index();
+    ) ->Result<()>{
+        let mass = node_view.mass();
+        self.leaf_index = node_view.leaf_index();
         if mass > visitor_info.ignore_mass {
             if node_view.is_duplicate() {
                 self.score = (visitor_info.damp)(mass, self.tree_mass)
-                    * (visitor_info.score_seen)(node_view.get_depth(), mass);
+                    * (visitor_info.score_seen)(node_view.depth(), mass);
                 self.hit_duplicate = true;
                 self.use_shadow_box = true;
             } else {
-                let t = (visitor_info.score_unseen)(node_view.get_depth(), mass);
+                let t = (visitor_info.score_unseen)(node_view.depth(), mass);
                 self.score = t;
-                let bounding_box = node_view.bounding_box();
-                self.interpolation_measure.update(point, &bounding_box, t);
+                match &node_view.bounding_box() {
+                    Some(x) => {self.interpolation_measure.update(point, x, t); Ok(())},
+                    _ => Err(RCFError::InvalidArgument {msg :" incorrect state"})
+                }?;
             }
         } else {
-            self.score = (visitor_info.score_unseen)(node_view.get_depth(), mass);
+            self.score = (visitor_info.score_unseen)(node_view.depth(), mass);
             self.use_shadow_box = true;
         }
+        Ok(())
     }
 
-    fn accept(&mut self, point: &[f32], visitor_info: &VisitorInfo, node_view: &LargeNodeView) {
+    fn accept(&mut self, point: &[f32], visitor_info: &VisitorInfo, node_view: &LargeNodeView) -> Result<()>{
         if !self.converged {
             let bounding_box = if !self.use_shadow_box {
                 node_view.bounding_box()
@@ -73,10 +78,11 @@ impl Visitor<LargeNodeView, InterpolationMeasure> for InterpolationVisitor {
                 node_view.shadow_box()
             };
             let new_value =
-                (visitor_info.score_unseen)(node_view.get_depth(), node_view.get_mass());
-            let prob = self
-                .interpolation_measure
-                .update(point, &bounding_box, new_value);
+                (visitor_info.score_unseen)(node_view.depth(), node_view.mass());
+            let prob = match &bounding_box {
+                Some(x) => Ok(self.interpolation_measure.update(point, &x, new_value)),
+                _ => Err(RCFError::InvalidArgument {msg: "incorrect state"})
+            }?;
             if prob == 0.0 {
                 self.converged = true;
             } else {
@@ -85,17 +91,18 @@ impl Visitor<LargeNodeView, InterpolationMeasure> for InterpolationVisitor {
                 }
             }
         }
+        Ok(())
     }
 
-    fn result(&self, visitor_info: &VisitorInfo) -> InterpolationMeasure {
+    fn result(&self, visitor_info: &VisitorInfo) -> Result<InterpolationMeasure> {
         let t = (visitor_info.normalizer)(self.score, self.tree_mass);
         let mut answer = self.interpolation_measure.clone();
         answer.measure.normalize(t);
-        answer
+        Ok(answer)
     }
 
-    fn is_converged(&self) -> bool {
-        self.converged
+    fn is_converged(&self) -> Result<bool> {
+        Ok(self.converged)
     }
 
     fn use_shadow_box(&self) -> bool {
diff --git a/Rust/src/visitor/scalarscorevisitor.rs b/Rust/src/visitor/scalarscorevisitor.rs
index 0b82e302..9e6c5c88 100644
--- a/Rust/src/visitor/scalarscorevisitor.rs
+++ b/Rust/src/visitor/scalarscorevisitor.rs
@@ -1,6 +1,7 @@
 use crate::{
     samplerplustree::nodeview::SmallNodeView,
     visitor::visitor::{Visitor, VisitorInfo},
+    types::Result,
 };
 
 #[repr(C)]
@@ -30,46 +31,48 @@ impl Visitor<SmallNodeView, f64> for ScalarScoreVisitor {
         _point: &[f32],
         visitor_info: &VisitorInfo,
         node_view: &SmallNodeView,
-    ) {
-        let mass = node_view.get_mass();
-        self.leaf_index = node_view.get_leaf_index();
+    ) ->Result<()> {
+        let mass = node_view.mass();
+        self.leaf_index = node_view.leaf_index();
         if mass > visitor_info.ignore_mass {
             if node_view.is_duplicate() {
                 self.score = (visitor_info.damp)(mass, self.tree_mass)
-                    * (visitor_info.score_seen)(node_view.get_depth(), mass);
+                    * (visitor_info.score_seen)(node_view.depth(), mass);
                 self.converged = true;
             } else {
-                self.score = (visitor_info.score_unseen)(node_view.get_depth(), mass);
+                self.score = (visitor_info.score_unseen)(node_view.depth(), mass);
             }
         } else {
-            self.score = (visitor_info.score_unseen)(node_view.get_depth(), mass);
+            self.score = (visitor_info.score_unseen)(node_view.depth(), mass);
             self.use_shadow_box = true;
         }
+        Ok(())
     }
 
-    fn accept(&mut self, point: &[f32], visitor_info: &VisitorInfo, node_view: &SmallNodeView) {
+    fn accept(&mut self, _point: &[f32], visitor_info: &VisitorInfo, node_view: &SmallNodeView) -> Result<()>{
         if !self.converged {
             let prob = if !self.use_shadow_box {
-                node_view.get_probability_of_cut()
+                node_view.probability_of_cut()
             } else {
-                node_view.get_shadow_box_probability_of_cut()
+                node_view.shadow_box_probability_of_cut()
             };
             if prob == 0.0 {
                 self.converged = true;
             } else {
                 self.score = (1.0 - prob) * self.score
                     + prob
-                        * (visitor_info.score_unseen)(node_view.get_depth(), node_view.get_mass());
+                        * (visitor_info.score_unseen)(node_view.depth(), node_view.mass());
             }
         }
+        Ok(())
     }
 
-    fn result(&self, visitor_info: &VisitorInfo) -> f64 {
-        (visitor_info.normalizer)(self.score, self.tree_mass)
+    fn result(&self, visitor_info: &VisitorInfo) -> Result<f64> {
+        Ok((visitor_info.normalizer)(self.score, self.tree_mass))
     }
 
-    fn is_converged(&self) -> bool {
-        self.converged
+    fn is_converged(&self) -> Result<bool> {
+        Ok(self.converged)
     }
 
     fn use_shadow_box(&self) -> bool {
diff --git a/Rust/src/visitor/visitor.rs b/Rust/src/visitor/visitor.rs
index 2e0315ed..98b21fac 100644
--- a/Rust/src/visitor/visitor.rs
+++ b/Rust/src/visitor/visitor.rs
@@ -4,6 +4,7 @@ use crate::{
         damp, displacement_normalizer, identity, normalizer, score_seen, score_seen_displacement,
         score_unseen, score_unseen_displacement,
     },
+    types::Result,
 };
 
 #[repr(C)]
@@ -16,29 +17,29 @@ pub struct VisitorInfo {
     pub distance: fn(&[f32], &[f32]) -> f64,
 }
 
-pub trait Visitor<NodeView, Result> {
-    fn accept(&mut self, point: &[f32], visitor_info: &VisitorInfo, node_view: &NodeView);
-    fn accept_leaf(&mut self, point: &[f32], visitor_info: &VisitorInfo, node_view: &NodeView);
-    fn is_converged(&self) -> bool;
-    fn result(&self, visitor_info: &VisitorInfo) -> Result;
+pub trait Visitor<NodeView, R> {
+    fn accept(&mut self, point: &[f32], visitor_info: &VisitorInfo, node_view: &NodeView) -> Result<()>;
+    fn accept_leaf(&mut self, point: &[f32], visitor_info: &VisitorInfo, node_view: &NodeView) -> Result<()>;
+    fn is_converged(&self) -> Result<bool>;
+    fn result(&self, visitor_info: &VisitorInfo) -> Result<R>;
     fn use_shadow_box(&self) -> bool;
 }
 
-pub trait SimpleMultiVisitor<NodeView, Result>: Visitor<NodeView, Result> {
+pub trait SimpleMultiVisitor<NodeView, R>: Visitor<NodeView, R> {
     fn combine_branches(
         &mut self,
         point: &[f32],
         _node_view: &NodeView,
         visitor_info: &VisitorInfo,
-    );
+    ) -> Result<()>;
 }
 
-pub trait UniqueMultiVisitor<NodeView, Result>: SimpleMultiVisitor<NodeView, Result> {
+pub trait UniqueMultiVisitor<NodeView, R>: SimpleMultiVisitor<NodeView, R> {
     fn trigger(&self, point: &[f32], node_view: &NodeView, visitor_info: &VisitorInfo) -> bool;
     fn unique_answer(&self, visitor_info: &VisitorInfo) -> Vec<f32>;
 }
 
-pub trait StreamingMultiVisitor<NodeView, Result>: UniqueMultiVisitor<NodeView, Result> {
+pub trait StreamingMultiVisitor<NodeView, R>: UniqueMultiVisitor<NodeView, R> {
     fn initialize_branch_split(
         &mut self,
         point: &[f32],
diff --git a/Rust/tests/anomalydetectionattributionupdate.rs b/Rust/tests/anomalydetectionattributionupdate.rs
index 4336b923..706668a9 100644
--- a/Rust/tests/anomalydetectionattributionupdate.rs
+++ b/Rust/tests/anomalydetectionattributionupdate.rs
@@ -7,8 +7,9 @@ use rand::{Rng, SeedableRng};
 use rand_chacha::ChaCha20Rng;
 use rcflib::{
     common::multidimdatawithkey::MultiDimDataWithKey,
-    rcf::{create_rcf, RCF},
+    rcf::{RCF},
 };
+use rcflib::rcf::{RCFBuilder, RCFOptionsBuilder};
 
 /// try cargo test --release
 /// these tests are designed to be longish
@@ -21,7 +22,6 @@ fn anomalydetection_attribution_and_update() {
     let number_of_trees = 30;
     let capacity = 256;
     let initial_accept_fraction = 0.1;
-    let dimensions = shingle_size * base_dimension;
     let _point_store_capacity = capacity * number_of_trees + 1;
     let time_decay = 0.1 / capacity as f64;
     let bounding_box_cache_fraction = 1.0;
@@ -32,20 +32,18 @@ fn anomalydetection_attribution_and_update() {
     let internal_rotation = false;
     let noise = 5.0;
 
-    let mut forest: Box<dyn RCF> = create_rcf(
-        dimensions,
-        shingle_size,
-        capacity,
-        number_of_trees,
-        random_seed,
-        store_attributes,
-        parallel_enabled,
-        internal_shingling,
-        internal_rotation,
-        time_decay,
-        initial_accept_fraction,
-        bounding_box_cache_fraction,
-    );
+    let mut forest = RCFBuilder::<u64,u64>::new(base_dimension,shingle_size)
+            .tree_capacity(capacity)
+            .number_of_trees(number_of_trees)
+            .random_seed(random_seed)
+            .store_attributes(store_attributes)
+            .parallel_enabled(parallel_enabled)
+            .internal_shingling(internal_shingling)
+            .internal_rotation(internal_rotation)
+            .time_decay(time_decay)
+            .initial_accept_fraction(initial_accept_fraction)
+            .bounding_box_cache_fraction(bounding_box_cache_fraction).build().unwrap();
+
     let mut rng = ChaCha20Rng::seed_from_u64(42);
     let mut amplitude = Vec::new();
     for _i in 0..base_dimension {
@@ -58,7 +56,7 @@ fn anomalydetection_attribution_and_update() {
         noise,
         0,
         base_dimension.into(),
-    );
+    ).unwrap();
 
     let mut score: f64 = 0.0;
     let _next_index = 0;
diff --git a/Rust/tests/anomalydetectionimputescoreupdate.rs b/Rust/tests/anomalydetectionimputescoreupdate.rs
index 3a4048d2..26364a7f 100644
--- a/Rust/tests/anomalydetectionimputescoreupdate.rs
+++ b/Rust/tests/anomalydetectionimputescoreupdate.rs
@@ -6,8 +6,9 @@ use rand::{Rng, SeedableRng};
 use rand_chacha::ChaCha20Rng;
 use rcflib::{
     common::multidimdatawithkey::MultiDimDataWithKey,
-    rcf::{create_rcf, RCF},
+    rcf::{RCF},
 };
+use rcflib::rcf::{RCFBuilder, RCFOptionsBuilder};
 
 /// try cargo test --release
 /// these tests are designed to be longish
@@ -20,7 +21,6 @@ fn anomalydetection_impute_score_and_update() {
     let number_of_trees = 30;
     let capacity = 256;
     let initial_accept_fraction = 0.1;
-    let dimensions = shingle_size * base_dimension;
     let _point_store_capacity = capacity * number_of_trees + 1;
     let time_decay = 0.1 / capacity as f64;
     let bounding_box_cache_fraction = 1.0;
@@ -31,20 +31,18 @@ fn anomalydetection_impute_score_and_update() {
     let internal_rotation = false;
     let noise = 5.0;
 
-    let mut forest: Box<dyn RCF> = create_rcf(
-        dimensions,
-        shingle_size,
-        capacity,
-        number_of_trees,
-        random_seed,
-        store_attributes,
-        parallel_enabled,
-        internal_shingling,
-        internal_rotation,
-        time_decay,
-        initial_accept_fraction,
-        bounding_box_cache_fraction,
-    );
+    let mut forest: Box<dyn RCF> = RCFBuilder::<u64,u64>::new(base_dimension,shingle_size)
+        .tree_capacity(capacity)
+        .number_of_trees(number_of_trees)
+        .random_seed(random_seed)
+        .store_attributes(store_attributes)
+        .parallel_enabled(parallel_enabled)
+        .internal_shingling(internal_shingling)
+        .internal_rotation(internal_rotation)
+        .time_decay(time_decay)
+        .initial_accept_fraction(initial_accept_fraction)
+        .bounding_box_cache_fraction(bounding_box_cache_fraction).build_default().unwrap();
+
     let mut rng = ChaCha20Rng::seed_from_u64(42);
     let mut amplitude = Vec::new();
     for _i in 0..base_dimension {
@@ -57,7 +55,7 @@ fn anomalydetection_impute_score_and_update() {
         noise,
         0,
         base_dimension.into(),
-    );
+    ).unwrap();
 
     let mut score: f64 = 0.0;
     let _next_index = 0;
@@ -67,7 +65,7 @@ fn anomalydetection_impute_score_and_update() {
     for i in 0..data_with_key.data.len() {
         if i > 200 {
             let next_values = forest.extrapolate(1).unwrap().values;
-            assert!(next_values.len() == base_dimension);
+            assert_eq!(next_values.len(), base_dimension);
             error += next_values
                 .iter()
                 .zip(&data_with_key.data[i])
diff --git a/Rust/tests/anomalydetectionscoreupdate.rs b/Rust/tests/anomalydetectionscoreupdate.rs
index 0b5830df..07b402b7 100644
--- a/Rust/tests/anomalydetectionscoreupdate.rs
+++ b/Rust/tests/anomalydetectionscoreupdate.rs
@@ -6,8 +6,9 @@ use rand::{Rng, SeedableRng};
 use rand_chacha::ChaCha20Rng;
 use rcflib::{
     common::multidimdatawithkey::MultiDimDataWithKey,
-    rcf::{create_rcf, RCF},
+    rcf::{RCF},
 };
+use rcflib::rcf::{RCFBuilder, RCFOptionsBuilder};
 
 /// try cargo test --release
 /// these tests are designed to be longish
@@ -20,7 +21,6 @@ fn anomalydetection_score_and_update() {
     let number_of_trees = 30;
     let capacity = 256;
     let initial_accept_fraction = 0.1;
-    let dimensions = shingle_size * base_dimension;
     let _point_store_capacity = capacity * number_of_trees + 1;
     let time_decay = 0.1 / capacity as f64;
     let bounding_box_cache_fraction = 1.0;
@@ -31,20 +31,18 @@ fn anomalydetection_score_and_update() {
     let internal_rotation = false;
     let noise = 5.0;
 
-    let mut forest: Box<dyn RCF> = create_rcf(
-        dimensions,
-        shingle_size,
-        capacity,
-        number_of_trees,
-        random_seed,
-        store_attributes,
-        parallel_enabled,
-        internal_shingling,
-        internal_rotation,
-        time_decay,
-        initial_accept_fraction,
-        bounding_box_cache_fraction,
-    );
+    let mut forest: Box<dyn RCF> = RCFBuilder::<u64,u64>::new(base_dimension,shingle_size)
+        .tree_capacity(capacity)
+        .number_of_trees(number_of_trees)
+        .random_seed(random_seed)
+        .store_attributes(store_attributes)
+        .parallel_enabled(parallel_enabled)
+        .internal_shingling(internal_shingling)
+        .internal_rotation(internal_rotation)
+        .time_decay(time_decay)
+        .initial_accept_fraction(initial_accept_fraction)
+        .bounding_box_cache_fraction(bounding_box_cache_fraction).build_default().unwrap();
+
     let mut rng = ChaCha20Rng::seed_from_u64(42);
     let mut amplitude = Vec::new();
     for _i in 0..base_dimension {
@@ -57,7 +55,7 @@ fn anomalydetection_score_and_update() {
         noise,
         0,
         base_dimension.into(),
-    );
+    ).unwrap();
 
     let mut score: f64 = 0.0;
     let _next_index = 0;
diff --git a/Rust/tests/basicrcftest.rs b/Rust/tests/basicrcftest.rs
index 71703870..924d1439 100644
--- a/Rust/tests/basicrcftest.rs
+++ b/Rust/tests/basicrcftest.rs
@@ -5,9 +5,10 @@ extern crate rcflib;
 use num::abs;
 use rcflib::{
     common::multidimdatawithkey::MultiDimDataWithKey,
-    rcf::{create_rcf, RCF},
+    rcf::{RCF},
     visitor::visitor::VisitorInfo,
 };
+use rcflib::rcf::{RCFBuilder, RCFOptionsBuilder};
 
 /// try cargo test --release
 /// these tests are designed to be longish
@@ -24,7 +25,7 @@ fn two_distribution_test_static() {
     let scale = vec![vec![0.1f32; dimensions], vec![0.1f32; dimensions]];
     let mean = vec![vec1.clone(), vec2.clone()].clone();
     let data_with_key =
-        MultiDimDataWithKey::mixture(data_size, &mean, &scale, &vec![0.5f32, 0.5f32], 0);
+        MultiDimDataWithKey::mixture(data_size, &mean, &scale, &vec![0.5f32, 0.5f32], 0).unwrap();
 
     let shingle_size = 1;
     let number_of_trees = 50;
@@ -39,35 +40,32 @@ fn two_distribution_test_static() {
     let internal_shingling: bool = false;
     let internal_rotation = false;
 
-    let mut forest: Box<dyn RCF> = create_rcf(
-        dimensions,
-        shingle_size,
-        capacity,
-        number_of_trees,
-        random_seed,
-        store_attributes,
-        parallel_enabled,
-        internal_shingling,
-        internal_rotation,
-        time_decay,
-        initial_accept_fraction,
-        bounding_box_cache_fraction,
-    );
+    let mut forest = RCFBuilder::<u64,u64>::new(dimensions,shingle_size)
+        .tree_capacity(capacity)
+        .number_of_trees(number_of_trees)
+        .random_seed(random_seed)
+        .store_attributes(store_attributes)
+        .parallel_enabled(parallel_enabled)
+        .internal_shingling(internal_shingling)
+        .internal_rotation(internal_rotation)
+        .time_decay(time_decay)
+        .initial_accept_fraction(initial_accept_fraction)
+        .bounding_box_cache_fraction(bounding_box_cache_fraction).build().unwrap();
+
+
+    let mut another_forest =
+        RCFBuilder::<u64,u64>::new(dimensions,shingle_size)
+            .tree_capacity(2*capacity)
+            .number_of_trees(number_of_trees)
+            .random_seed(random_seed)
+            .store_attributes(store_attributes)
+            .parallel_enabled(parallel_enabled)
+            .internal_shingling(internal_shingling)
+            .internal_rotation(internal_rotation)
+            .time_decay(time_decay)
+            .initial_accept_fraction(initial_accept_fraction)
+            .bounding_box_cache_fraction(bounding_box_cache_fraction).build().unwrap();
 
-    let mut another_forest: Box<dyn RCF> = create_rcf(
-        dimensions,
-        shingle_size,
-        capacity * 2,
-        number_of_trees,
-        random_seed,
-        store_attributes,
-        parallel_enabled,
-        internal_shingling,
-        internal_rotation,
-        time_decay,
-        initial_accept_fraction,
-        bounding_box_cache_fraction,
-    );
 
     for i in 0..data_with_key.data.len() {
         forest.update(&data_with_key.data[i], 0).unwrap();
diff --git a/Rust/tests/basictrcftest.rs b/Rust/tests/basictrcftest.rs
index 3017bcae..9e3153c1 100644
--- a/Rust/tests/basictrcftest.rs
+++ b/Rust/tests/basictrcftest.rs
@@ -5,19 +5,37 @@ use rand::{Rng, SeedableRng};
 use rand_chacha::ChaCha20Rng;
 use rcflib::{
     common::multidimdatawithkey,
-    trcf::basictrcf::BasicTRCF
+    trcf::basictrcf::BasicTRCF,
+    trcf::types::TransformMethod::NONE
 };
+use rcflib::trcf::basictrcf::BasicTRCFBuilder;
+use rcflib::trcf::types::ForestMode::STANDARD;
+use rcflib::trcf::types::{TransformMethod};
+use rcflib::trcf::types::TransformMethod::{DIFFERENCE, NORMALIZE, NORMALIZE_DIFFERENCE, SUBTRACT_MA, WEIGHTED};
+use crate::rcflib::rcf::RCFOptionsBuilder;
+use crate::rcflib::trcf::basictrcf::TRCFOptionsBuilder;
+#[cfg(test)]
+parameterized_test::create! { test_basic_trcf, (method), {
+basic_trcf(method);
+}}
 
+#[cfg(test)]
+parameterized_test::create! { basic_trcf_scale, (method,base_dimension,verbose), {
+    trcf_scale(method,base_dimension,verbose,false);
+}}
 
-#[test]
-fn test_basic_trcf() {
+#[cfg(test)]
+parameterized_test::create! { trcf_scale_spikes, (method,base_dimension,verbose), {
+    trcf_scale(method,base_dimension,verbose,true);
+}}
+
+fn basic_trcf(transform_method : TransformMethod) {
     let shingle_size = 8;
     let base_dimension = 5;
     let data_size = 1000;
-    let number_of_trees = 30;
+    let number_of_trees = 50;
     let capacity = 256;
     let initial_accept_fraction = 0.1;
-    let dimensions = shingle_size * base_dimension;
     let _point_store_capacity = capacity * number_of_trees + 1;
     let time_decay = 0.1 / capacity as f64;
     let bounding_box_cache_fraction = 1.0;
@@ -25,17 +43,13 @@ fn test_basic_trcf() {
     let parallel_enabled: bool = false;
     let noise = 5.0;
 
-    let mut trcf = BasicTRCF::new(
-        dimensions,
-        shingle_size,
-        capacity,
-        number_of_trees,
-        random_seed, parallel_enabled,
-        time_decay,
-        0.01,
-        initial_accept_fraction,
-        bounding_box_cache_fraction,
-    );
+    let mut trcf = BasicTRCFBuilder::new(base_dimension,shingle_size)
+        .tree_capacity(capacity).number_of_trees(number_of_trees).random_seed(random_seed)
+        .transform_method(transform_method)
+        .forest_mode(STANDARD).parallel_enabled(parallel_enabled).verbose(true)
+        .time_decay(time_decay).transform_decay(time_decay).initial_accept_fraction(initial_accept_fraction)
+        .bounding_box_cache_fraction(bounding_box_cache_fraction).build().unwrap();
+
 
     let mut rng = ChaCha20Rng::seed_from_u64(42);
     let mut amplitude = Vec::new();
@@ -50,10 +64,11 @@ fn test_basic_trcf() {
         noise,
         42,
         base_dimension.into(),
-    );
+    ).unwrap();
 
     let mut next_index = 0;
 
+    println!("{}", transform_method);
     for i in 0..data_with_key.data.len() {
         if next_index < data_with_key.change_indices.len() && data_with_key.change_indices[next_index] == i {
             print!("timestamp {} INJECT [ {}", i, data_with_key.changes[next_index][0]);
@@ -63,42 +78,76 @@ fn test_basic_trcf() {
             println!("]");
             next_index += 1;
         }
-        let result = trcf.process(&data_with_key.data[i], 0).unwrap();
+        let result = trcf.process(&data_with_key.data[i], i as u64).unwrap();
         if result.anomaly_grade > 0.0 {
             print!("timestamp {} ", i);
-            if result.relative_index.unwrap() != 0 {
-                let gap = -result.relative_index.unwrap();
+            let gap = -result.last_anomaly.as_ref().unwrap().relative_index;
+            if gap != 0 {
                 if gap == 1 {
                     print!("1 step ago, ");
                 } else {
                     print!("{} steps ago, ", gap);
                 }
             }
-            if result.forecast_reasonable {
-                if let Some(expected_list) = result.expected_values_list {
-                    let expected = &expected_list[0];
-                    let past = &result.past_values.unwrap();
-                    print!("DETECT [ {}", (past[0] - expected[0]));
-                    for j in 1..base_dimension {
-                        print!(", {}", (past[j] - expected[j]));
-                    }
-                    print!("]");
-                }
+
+            let expected = &result.last_anomaly.as_ref().unwrap().expected_values_list[0];
+            let past = &result.last_anomaly.as_ref().unwrap().past_values;
+            print!("DETECT [ {}", (past[0] - expected[0]));
+            for j in 1..base_dimension {
+                print!(", {}", (past[j] - expected[j]));
             }
+            print!("]");
+
             println!(" score {}, grade {}", result.score, result.anomaly_grade);
         }
     }
 }
 
-#[test]
-fn test_basic_trcf_scale() {
+test_basic_trcf! {
+    a1: NONE,
+    a2: NORMALIZE,
+    a3: SUBTRACT_MA,
+    a4: NORMALIZE_DIFFERENCE,
+    a5: DIFFERENCE,
+    a6: WEIGHTED,
+}
+
+basic_trcf_scale! {
+    b1: (NONE,3,false),
+    b2: (NONE,3,true),
+    b3: (NORMALIZE,3,false),
+    b4: (NORMALIZE,3,true),
+    b5: (SUBTRACT_MA,3,false),
+    b6: (SUBTRACT_MA,3,true),
+    b7: (NORMALIZE_DIFFERENCE,3,false),
+    b8: (NORMALIZE_DIFFERENCE,3,true),
+    b9: (DIFFERENCE,3,false),
+    b10: (DIFFERENCE,3,true),
+    b11: (WEIGHTED,3,false),
+    b12: (WEIGHTED,3,true),
+}
+
+trcf_scale_spikes! {
+    c1: (NONE,1,false),
+    c2: (NONE,1,true),
+    c3: (NORMALIZE,1,false),
+    c4: (NORMALIZE,1,true),
+    c5: (SUBTRACT_MA,1,false),
+    c6: (SUBTRACT_MA,1,true),
+    c7: (NORMALIZE_DIFFERENCE,1,false),
+    c8: (NORMALIZE_DIFFERENCE,1,true),
+    c9: (DIFFERENCE,1,false),
+    c10: (DIFFERENCE,1,true),
+    c11: (WEIGHTED,1,false),
+    c12: (WEIGHTED,1,true),
+}
+
+fn trcf_scale(transform_method:TransformMethod, base_dimension: usize, verbose:bool, add_spikes: bool) {
     let shingle_size = 8;
-    let base_dimension = 5;
     let data_size = 100000;
-    let number_of_trees = 30;
+    let number_of_trees = 50;
     let capacity = 256;
     let initial_accept_fraction = 0.1;
-    let dimensions = shingle_size * base_dimension;
     let _point_store_capacity = capacity * number_of_trees + 1;
     let time_decay = 0.1 / capacity as f64;
     let bounding_box_cache_fraction = 1.0;
@@ -106,40 +155,42 @@ fn test_basic_trcf_scale() {
     let parallel_enabled: bool = false;
     let noise = 5.0;
 
-    let mut trcf = BasicTRCF::new(
-        dimensions,
-        shingle_size,
-        capacity,
-        number_of_trees,
-        random_seed, parallel_enabled,
-        time_decay,
-        0.01,
-        initial_accept_fraction,
-        bounding_box_cache_fraction,
-    );
+    println!("At scale {}, add spikes? {} verbose = {} ", transform_method, add_spikes, verbose);
+    let mut trcf : BasicTRCF = BasicTRCFBuilder::new(base_dimension,shingle_size)
+        .tree_capacity(capacity).number_of_trees(number_of_trees).random_seed(random_seed)
+        .transform_method(transform_method)
+        .forest_mode(STANDARD).parallel_enabled(parallel_enabled).verbose(verbose)
+        .time_decay(time_decay).transform_decay(time_decay).initial_accept_fraction(initial_accept_fraction)
+        .bounding_box_cache_fraction(bounding_box_cache_fraction).build().unwrap();
 
     let mut rng = ChaCha20Rng::from_entropy();
     let mut amplitude = Vec::new();
     for _i in 0..base_dimension {
         amplitude.push((1.0 + 0.2 * rng.gen::<f32>()) * 60.0);
     }
-    let data_with_key = multidimdatawithkey::MultiDimDataWithKey::multi_cosine(
+    let mut data_with_key = multidimdatawithkey::MultiDimDataWithKey::multi_cosine(
         data_size,
         &vec![60; base_dimension],
         &amplitude,
         noise,
         rng.gen::<u64>(),
         base_dimension.into(),
-    );
+    ).unwrap();
 
     let mut potential_anomalies:Vec<usize> = Vec::new();
 
+    let mut next = 100 + (rng.gen::<f32>()*100.0) as usize;
     for i in 0..data_with_key.data.len() {
+        if add_spikes && i == next {
+            data_with_key.data[i][0] += 100.0 * ( 1.0 + 0.05*rng.gen::<f32>());
+            next = 100 + (rng.gen::<f32>()*100.0) as usize;
+        }
+
         let result = trcf.process(&data_with_key.data[i], 0).unwrap();
         if result.anomaly_grade > 0.0 {
             // some anomalies will be detected late
             // we will keep the vector unsorted, so out of order detection will be penalized
-            potential_anomalies.push((i as i32 + result.relative_index.unwrap()) as usize);
+            potential_anomalies.push((i as i32 + result.last_anomaly.as_ref().unwrap().relative_index) as usize);
         }
     }
 
diff --git a/Rust/tests/clustertest.rs b/Rust/tests/clustertest.rs
index a2e9cf19..65b57e31 100644
--- a/Rust/tests/clustertest.rs
+++ b/Rust/tests/clustertest.rs
@@ -9,11 +9,11 @@ use rand::{prelude::ThreadRng, Rng, SeedableRng};
 use rand_chacha::ChaCha20Rng;
 use rand_core::RngCore;
 use rcflib::{
-    common::{multidimdatawithkey::MultiDimDataWithKey, samplesummary::summarize},
-    l1distance, l2distance, linfinitydistance,
+    common::{multidimdatawithkey::MultiDimDataWithKey},
+    l1distance, l2distance,
 };
 use rcflib::common::cluster::{Center, multi_cluster_as_object_with_weight_array, multi_cluster_as_ref, multi_cluster_as_weighted_ref, multi_cluster_obj, persist, single_centroid_cluster_slice_with_weight_arrays, single_centroid_cluster_weighted_vec, single_centroid_cluster_weighted_vec_with_distance_over_slices, single_centroid_unweighted_cluster_slice};
-use rcflib::errors::RCFError;
+
 
 fn gen_data(data_size:usize, test_dimension:usize, seed:u64,yard_stick : f32) -> MultiDimDataWithKey {
     let mut mean = Vec::new();
@@ -34,7 +34,7 @@ fn gen_data(data_size:usize, test_dimension:usize, seed:u64,yard_stick : f32) ->
         &scale,
         &vec![0.5 / test_dimension as f32; 2 * test_dimension],
         seed,
-    )
+    ).unwrap()
 }
 
 fn test_center(result: &mut Vec<Center>,test_dimension:usize, yard_stick : f32) -> bool {
@@ -51,7 +51,7 @@ fn test_center(result: &mut Vec<Center>,test_dimension:usize, yard_stick : f32)
     answer
 }
 
-fn bad_distance<T :?Sized>(a : &T, b:&T) -> f64{
+fn bad_distance<T :?Sized>(_a : &T, _b:&T) -> f64{
     -1.0
 }
 
@@ -64,32 +64,32 @@ fn test_config() {
     for i in 0..data_with_key.data.len() {
         input.push((data_with_key.data[i].clone(), 1.0f32));
     }
-    let mut result = single_centroid_cluster_weighted_vec_with_distance_over_slices(&input, bad_distance, 2 * test_dimension + 3, false);
+    let result = single_centroid_cluster_weighted_vec_with_distance_over_slices(&input, bad_distance, 2 * test_dimension + 3, false);
 
     match &result {
-        Ok(x) => assert!(false),
-        Err(y) => assert!(true),
+        Ok(_x) => assert!(false),
+        Err(_y) => assert!(true),
     };
 
-    let mut result = single_centroid_cluster_weighted_vec_with_distance_over_slices(&input, l2distance, 0, false);
+    let result = single_centroid_cluster_weighted_vec_with_distance_over_slices(&input, l2distance, 0, false);
 
     match &result {
-        Ok(x) => assert!(false),
-        Err(y) => assert!(true),
+        Ok(_x) => assert!(false),
+        Err(_y) => assert!(true),
     };
 
-    let mut result = single_centroid_cluster_weighted_vec_with_distance_over_slices(&input, l2distance, 200, false);
+    let result = single_centroid_cluster_weighted_vec_with_distance_over_slices(&input, l2distance, 200, false);
 
     match &result {
-        Ok(x) => assert!(false),
-        Err(y) => assert!(true),
+        Ok(_x) => assert!(false),
+        Err(_y) => assert!(true),
     };
 
-    let mut result = single_centroid_cluster_weighted_vec_with_distance_over_slices(&input, l2distance, 20, false);
+    let result = single_centroid_cluster_weighted_vec_with_distance_over_slices(&input, l2distance, 20, false);
 
     match &result {
-        Ok(x) => assert!(true),
-        Err(y) => assert!(false),
+        Ok(_x) => assert!(true),
+        Err(_y) => assert!(false),
     };
 }
 
@@ -256,7 +256,7 @@ fn multi_as_vec(
         input.push(data_with_key.data[i].clone());
     }
     let mut result = multi_cluster_obj(&input,   vec_dist, 5,0.1,true,2 * test_dimension + 3, false).unwrap();
-    let mut answer = (result.len() == 2 * test_dimension);
+    let mut answer = result.len() == 2 * test_dimension;
     for i in 0..test_dimension {
         result.sort_by(|a, b| a.representatives()[0].0[i].partial_cmp(&b.representatives()[0].0[i]).unwrap());
         answer = answer && abs(result[0].representatives()[0].0[i] + 2.0 * yard_stick) < 0.5;
@@ -300,7 +300,7 @@ fn multi_as_ref(
         input.push(&data_with_key.data[i]);
     }
     let mut result = multi_cluster_as_ref(&input,   vec_dist, 5,0.1,true,2 * test_dimension + 3, false).unwrap();
-    let mut answer = (result.len() == 2 * test_dimension);
+    let mut answer = result.len() == 2 * test_dimension;
     for i in 0..test_dimension {
         result.sort_by(|a, b| a.representatives()[0].0[i].partial_cmp(&b.representatives()[0].0[i]).unwrap());
         answer = answer && abs(result[0].representatives()[0].0[i] + 2.0 * yard_stick) < 0.5;
@@ -344,7 +344,7 @@ fn multi_as_weighted_ref(
         input.push((&data_with_key.data[i],1.0f32));
     }
     let mut result = multi_cluster_as_weighted_ref(&input,   vec_dist, 5,0.1,true,2 * test_dimension + 3, false).unwrap();
-    let mut answer = (result.len() == 2 * test_dimension);
+    let mut answer = result.len() == 2 * test_dimension;
     for i in 0..test_dimension {
         result.sort_by(|a, b| a.representatives()[0].0[i].partial_cmp(&b.representatives()[0].0[i]).unwrap());
         answer = answer && abs(result[0].representatives()[0].0[i] + 2.0 * yard_stick) < 0.5;
@@ -389,9 +389,9 @@ fn multi_as_vec_weighted(
         input.push(data_with_key.data[i].clone());
     }
     let weights = vec![1.0f32;data_with_key.data.len()];
-    let mut ref_result = multi_cluster_as_object_with_weight_array(&input,  &weights, vec_dist, 5,0.1,true,2 * test_dimension + 3, false).unwrap();
+    let ref_result = multi_cluster_as_object_with_weight_array(&input,  &weights, vec_dist, 5,0.1,true,2 * test_dimension + 3, false).unwrap();
     let mut result = persist(&ref_result);
-    let mut answer = (result.len() == 2 * test_dimension);
+    let mut answer = result.len() == 2 * test_dimension;
     for i in 0..test_dimension {
         result.sort_by(|a, b| a.representatives()[0].0[i].partial_cmp(&b.representatives()[0].0[i]).unwrap());
         answer = answer && abs(result[0].representatives()[0].0[i] + 2.0 * yard_stick) < 0.5;
diff --git a/Rust/tests/dynamicdensitytest.rs b/Rust/tests/dynamicdensitytest.rs
index b544e5cd..070dbde6 100644
--- a/Rust/tests/dynamicdensitytest.rs
+++ b/Rust/tests/dynamicdensitytest.rs
@@ -8,15 +8,16 @@ use rand::{Rng, SeedableRng};
 use rand_chacha::ChaCha20Rng;
 use rcflib::{
     common::multidimdatawithkey::MultiDimDataWithKey,
-    rcf::{create_rcf, RCF},
+    rcf::{ RCF},
 };
+use rcflib::rcf::{RCFBuilder, RCFOptionsBuilder};
 
 /// try cargo test --release
 /// these tests are designed to be longish
 
 #[test]
 fn dynamic_density() {
-    let dimensions = 2;
+    let base_dimension = 2;
     let shingle_size = 1;
     let number_of_trees = 50;
     let capacity = 256;
@@ -30,20 +31,18 @@ fn dynamic_density() {
     let internal_shingling: bool = false;
     let internal_rotation = false;
 
-    let mut forest: Box<dyn RCF> = create_rcf(
-        dimensions,
-        shingle_size,
-        capacity,
-        number_of_trees,
-        random_seed,
-        store_attributes,
-        parallel_enabled,
-        internal_shingling,
-        internal_rotation,
-        time_decay,
-        initial_accept_fraction,
-        bounding_box_cache_fraction,
-    );
+    let mut forest = RCFBuilder::<u64,u64>::new(base_dimension,shingle_size)
+        .tree_capacity(capacity)
+        .number_of_trees(number_of_trees)
+        .random_seed(random_seed)
+        .store_attributes(store_attributes)
+        .parallel_enabled(parallel_enabled)
+        .internal_shingling(internal_shingling)
+        .internal_rotation(internal_rotation)
+        .time_decay(time_decay)
+        .initial_accept_fraction(initial_accept_fraction)
+        .bounding_box_cache_fraction(bounding_box_cache_fraction).build().unwrap();
+
 
     let data: Vec<Vec<f32>> = generate_fan(1000, 3);
     let query_point = vec![0.7, 0.0f32];
@@ -138,7 +137,7 @@ fn generate_fan(num_per_blade: usize, blades: usize) -> Vec<Vec<f32>> {
         &vec![vec![0.05, 0.2]],
         &vec![1.0f32],
         0,
-    );
+    ).unwrap();
     let mut rng = ChaCha20Rng::seed_from_u64(72345);
     for point in data_with_key.data {
         let toss: f64 = rng.gen();
diff --git a/Rust/tests/gladtest.rs b/Rust/tests/gladtest.rs
index 2cea49dc..39a73344 100644
--- a/Rust/tests/gladtest.rs
+++ b/Rust/tests/gladtest.rs
@@ -9,12 +9,11 @@ use rand::{prelude::ThreadRng, Rng, SeedableRng};
 use rand_chacha::ChaCha20Rng;
 use rand_core::RngCore;
 use rcflib::{
-    common::{multidimdatawithkey::MultiDimDataWithKey, samplesummary::summarize},
-    l1distance, l2distance, linfinitydistance,
+    common::{multidimdatawithkey::MultiDimDataWithKey},
+    l2distance,
 };
-use rcflib::common::cluster::{Center, multi_cluster_as_object_with_weight_array, multi_cluster_as_ref, multi_cluster_as_weighted_ref, multi_cluster_obj, MultiCenter, persist, single_centroid_cluster_slice_with_weight_arrays, single_centroid_cluster_weighted_vec, single_centroid_cluster_weighted_vec_with_distance_over_slices, single_centroid_unweighted_cluster_slice};
+use rcflib::common::cluster::MultiCenter;
 use rcflib::common::multidimdatawithkey::new_vec;
-use rcflib::errors::RCFError;
 use rcflib::glad::GlobalLocalAnomalyDetector;
 
 
@@ -26,7 +25,7 @@ fn rotate_clockwise(point: &[f32], theta: f32) -> Vec<f32> {
 }
 
 fn gen_numeric_data(data_size:usize, seed:u64, shift : (f32,f32), number_of_fans: usize) -> MultiDimDataWithKey {
-    let mut vec_mean = vec![shift.0,shift.1];
+    let vec_mean = vec![shift.0,shift.1];
     let scale = vec![1.0,0.5/number_of_fans as f32];
     let mut data :Vec<Vec<f32>> = Vec::new();
     let mut labels:Vec<usize> = Vec::new();
@@ -55,7 +54,7 @@ fn vec_dist(a: &Vec<f32>, b : &Vec<f32>) -> f64 {
     l2distance(a,b)
 }
 
-fn bad_distance<T :?Sized>(a : &T, b:&T) -> f64{
+fn bad_distance<T :?Sized>(_a : &T, _b:&T) -> f64{
     -0.0001
 }
 
@@ -66,18 +65,17 @@ fn numeric_glad() {
     let mut generator = ThreadRng::default();
     let one_seed: u64 = generator.gen();
     println!(" single seed is {}", one_seed);
-    let mut rng = ChaCha20Rng::seed_from_u64(one_seed);
     let capacity = 2000;
     let time_decay = 1.0 /capacity as f64;
     let data_with_key = gen_numeric_data(data_size,one_seed,(5.0 + 1.0/number_of_fans as f32,0.0),number_of_fans);
-    let mut glad = GlobalLocalAnomalyDetector::<Vec<f32>>::new(2000,0,time_decay,5, 0.1,true);
+    let mut glad = GlobalLocalAnomalyDetector::<Vec<f32>>::new(2000,0,time_decay,5, 0.1,true).unwrap();
 
     glad.set_z_factor(6.0 + number_of_fans as f32/4.0);
 
     let mut false_neg = 0;
     let mut false_pos = 0;
     let mut true_pos = 0;
-    let mut print_clusters = false;
+    let print_clusters = false;
     // set the above to see the cluster centers printed with associated relative mass
     // each block is separated by two println!()
     // a simple visualization tool can plot an animation of the clusters
@@ -132,8 +130,8 @@ pub fn toy_d(a:&Vec<char>, b: &Vec<char>) -> f64 {
     if a.len() > b.len() {
         return toy_d(b, a);
     }
-    let mut one = vec![0.0;(b.len()+1)];
-    let mut two = vec![0.0;(b.len()+1)];
+    let mut one = vec![0.0;b.len()+1];
+    let mut two = vec![0.0;b.len()+1];
 
     for j in 0..b.len()+1 {
         one[j] = j as f64;
@@ -231,7 +229,7 @@ fn string_glad() {
 
     let print_clusters_strings = true;
 
-    let mut glad = GlobalLocalAnomalyDetector::<Vec<char>>::new(2000,0,time_decay,5, 0.1,false);
+    let mut glad = GlobalLocalAnomalyDetector::<Vec<char>>::new(2000,0,time_decay,5, 0.1,false).unwrap();
 
     // we will not store the points but perform streaming
 
@@ -252,7 +250,7 @@ fn string_glad() {
             let prob = if rng.gen::<f64>() < 0.5 {
                 gap_prob_of_a
             } else {
-                (1.0 - gap_prob_of_a )
+                1.0 - gap_prob_of_a
             };
             injected = false;
             point = get_ab_array(string_size, prob, &mut rng, flag, 0.25 * i as f64/ data_size as f64);
diff --git a/Rust/tests/imputedifferentperiod.rs b/Rust/tests/imputedifferentperiod.rs
index 6adabaa7..19623ba7 100644
--- a/Rust/tests/imputedifferentperiod.rs
+++ b/Rust/tests/imputedifferentperiod.rs
@@ -6,8 +6,9 @@ use rand::{Rng, SeedableRng};
 use rand_chacha::ChaCha20Rng;
 use rcflib::{
     common::multidimdatawithkey::MultiDimDataWithKey,
-    rcf::{create_rcf, RCF},
+    rcf::{RCF},
 };
+use rcflib::rcf::{RCFBuilder, RCFOptionsBuilder};
 
 /// try cargo test --release
 /// these tests are designed to be longish
@@ -20,7 +21,6 @@ fn impute_different_period() {
     let number_of_trees = 100;
     let capacity = 256;
     let initial_accept_fraction = 0.1;
-    let dimensions = shingle_size * base_dimension;
     let _point_store_capacity = capacity * number_of_trees + 1;
     let time_decay = 0.1 / capacity as f64;
     let bounding_box_cache_fraction = 1.0;
@@ -31,20 +31,18 @@ fn impute_different_period() {
     let internal_rotation = false;
     let noise = 5.0;
 
-    let mut forest: Box<dyn RCF> = create_rcf(
-        dimensions,
-        shingle_size,
-        capacity,
-        number_of_trees,
-        random_seed,
-        store_attributes,
-        parallel_enabled,
-        internal_shingling,
-        internal_rotation,
-        time_decay,
-        initial_accept_fraction,
-        bounding_box_cache_fraction,
-    );
+    let mut forest= RCFBuilder::<u64,u64>::new(base_dimension,shingle_size)
+        .tree_capacity(capacity)
+        .number_of_trees(number_of_trees)
+        .random_seed(random_seed)
+        .store_attributes(store_attributes)
+        .parallel_enabled(parallel_enabled)
+        .internal_shingling(internal_shingling)
+        .internal_rotation(internal_rotation)
+        .time_decay(time_decay)
+        .initial_accept_fraction(initial_accept_fraction)
+        .bounding_box_cache_fraction(bounding_box_cache_fraction).build().unwrap();
+
     let mut rng = ChaCha20Rng::seed_from_u64(42);
     let mut amplitude = Vec::new();
     for _i in 0..base_dimension {
@@ -62,7 +60,7 @@ fn impute_different_period() {
         noise,
         0,
         base_dimension.into(),
-    );
+    ).unwrap();
 
     let _next_index = 0;
     let mut error = 0.0;
@@ -71,7 +69,7 @@ fn impute_different_period() {
     for i in 0..data_with_key.data.len() {
         if i > 200 {
             let next_values = forest.extrapolate(1).unwrap().values;
-            assert!(next_values.len() == base_dimension);
+            assert_eq!(next_values.len(), base_dimension);
             error += next_values
                 .iter()
                 .zip(&data_with_key.data[i])
diff --git a/Rust/tests/imputesameperiod.rs b/Rust/tests/imputesameperiod.rs
index 8c404564..812d850c 100644
--- a/Rust/tests/imputesameperiod.rs
+++ b/Rust/tests/imputesameperiod.rs
@@ -6,8 +6,9 @@ use rand::{Rng, SeedableRng};
 use rand_chacha::ChaCha20Rng;
 use rcflib::{
     common::multidimdatawithkey::MultiDimDataWithKey,
-    rcf::{create_rcf, RCF},
+    rcf::{ RCF},
 };
+use rcflib::rcf::{RCFBuilder, RCFOptionsBuilder};
 
 /// try cargo test --release
 /// these tests are designed to be longish
@@ -20,7 +21,6 @@ fn impute_same_period() {
     let number_of_trees = 30;
     let capacity = 256;
     let initial_accept_fraction = 0.1;
-    let dimensions = shingle_size * base_dimension;
     let _point_store_capacity = capacity * number_of_trees + 1;
     let time_decay = 0.1 / capacity as f64;
     let bounding_box_cache_fraction = 1.0;
@@ -31,20 +31,18 @@ fn impute_same_period() {
     let internal_rotation = false;
     let noise = 5.0;
 
-    let mut forest: Box<dyn RCF> = create_rcf(
-        dimensions,
-        shingle_size,
-        capacity,
-        number_of_trees,
-        random_seed,
-        store_attributes,
-        parallel_enabled,
-        internal_shingling,
-        internal_rotation,
-        time_decay,
-        initial_accept_fraction,
-        bounding_box_cache_fraction,
-    );
+    let mut forest: Box<dyn RCF> = RCFBuilder::<u64,u64>::new(base_dimension,shingle_size)
+            .tree_capacity(capacity)
+            .number_of_trees(number_of_trees)
+            .random_seed(random_seed)
+            .store_attributes(store_attributes)
+            .parallel_enabled(parallel_enabled)
+            .internal_shingling(internal_shingling)
+            .internal_rotation(internal_rotation)
+            .time_decay(time_decay)
+            .initial_accept_fraction(initial_accept_fraction)
+            .bounding_box_cache_fraction(bounding_box_cache_fraction).build_default().unwrap();
+
     let mut rng = ChaCha20Rng::seed_from_u64(42);
     let mut amplitude = Vec::new();
     for _i in 0..base_dimension {
@@ -57,7 +55,7 @@ fn impute_same_period() {
         noise,
         0,
         base_dimension.into(),
-    );
+    ).unwrap();
 
     let _next_index = 0;
     let mut error = 0.0;
@@ -66,7 +64,7 @@ fn impute_same_period() {
     for i in 0..data_with_key.data.len() {
         if i > 200 {
             let next_values = forest.extrapolate(1).unwrap().values;
-            assert!(next_values.len() == base_dimension);
+            assert_eq!(next_values.len(), base_dimension);
             error += next_values
                 .iter()
                 .zip(&data_with_key.data[i])
diff --git a/Rust/tests/multitrcftest.rs b/Rust/tests/multitrcftest.rs
new file mode 100644
index 00000000..7cae5c31
--- /dev/null
+++ b/Rust/tests/multitrcftest.rs
@@ -0,0 +1,133 @@
+extern crate rand;
+extern crate rand_chacha;
+extern crate rcflib;
+
+use std::collections::{HashMap, HashSet};
+use rand::Rng;
+use rand_chacha::ChaCha20Rng;
+use rand_core::SeedableRng;
+use rcflib::common::deviation::Deviation;
+use rcflib::common::multidimdatawithkey;
+use rcflib::rcf::{ RCFOptionsBuilder};
+use rcflib::trcf::basictrcf::TRCFOptionsBuilder;
+use rcflib::trcf::multitrcf::{MultiTRCF, MultiTRCFBuilder};
+use rcflib::trcf::types::ScoringStrategy::EXPECTED_INVERSE_HEIGHT;
+use rcflib::trcf::types::TransformMethod;
+use rcflib::trcf::types::TransformMethod::{NONE,NORMALIZE};
+
+#[cfg(test)]
+parameterized_test::create! { multi_trcf_basic, (method,parallel_enabled), {
+    multi_trcf(method,parallel_enabled);
+}}
+
+multi_trcf_basic! {
+    d1: (NONE,false),
+    d2: (NONE,true),
+}
+
+#[test]
+pub fn multi_trcf_single_threaded(){
+    multi_trcf(NORMALIZE,false);
+}
+
+#[test]
+pub fn multi_trcf_multi_threaded(){
+    multi_trcf(NORMALIZE,true);
+}
+
+pub fn multi_trcf(transform_method:TransformMethod,parallel_enabled:bool) {
+    let shingle_size = 10;
+    let input_dimensions = 1;
+    let data_size = 1000;
+    let noise = 5.0;
+    let number_of_series = 1000;
+    // as number_of_series is increased the prec-recall for a fixed number of arms
+    let scoring_strategy = EXPECTED_INVERSE_HEIGHT;
+
+    let mut total_injected =0;
+    let mut total_found = 0;
+    let mut total_overlap = 0;
+    let mut late = 0;
+    let number_of_models = 3; // more than 10 may not be a great idea
+    let mut multi_trcf : MultiTRCF = MultiTRCFBuilder::new(input_dimensions, shingle_size, number_of_models, 2*number_of_series)
+        .scoring_strategy(scoring_strategy).parallel_enabled(parallel_enabled).build().unwrap();
+
+    let mut period_map = HashMap::new();
+
+    let mut rng = ChaCha20Rng::seed_from_u64(42);
+    let mut data_with_key = Vec::new();
+    for y in 0..number_of_series {
+        let mut amplitude = Vec::new();
+        let mut period = Vec::new();
+        for _i in 0..input_dimensions {
+            amplitude.push((1.0 + 0.2 * rng.gen::<f32>()) * 60.0);
+            // ranges from [30,90)
+            period.push(30 + ((rng.gen::<f32>())* 60.0) as usize);
+        }
+
+        period_map.insert(y as u64,period.clone());
+
+        data_with_key.push(multidimdatawithkey::MultiDimDataWithKey::multi_cosine(
+            data_size,
+            &period,
+            &amplitude,
+            noise,
+            rng.gen::<u64>(),
+            input_dimensions.into(),
+        ).unwrap());
+    }
+    let mut next_index = vec![0;number_of_series];
+    let mut late_discovered = vec![HashSet::new();shingle_size];
+
+    for i in 0..data_size {
+        let mut injected  = HashSet::new();
+        let mut map : HashMap<u64,(&[f32],u64)> = HashMap::new();
+        for j in 0..number_of_series {
+            if next_index[j] < data_with_key[j].change_indices.len() && data_with_key[j].change_indices[next_index[j]] == i {
+                next_index[j] += 1;
+                injected.insert(j);
+            }
+            map.insert(j as u64, (&data_with_key[j].data[i],i as u64));
+        }
+        total_injected += injected.len();
+
+        let result = multi_trcf.process(map).unwrap();
+        let y : usize = result.iter().map(|x| if x.relative_index == 0 && injected.contains(&(x.id as usize)) {1} else {0}).sum();
+        let z : usize = result.iter().map(|x| if x.relative_index != 0 {
+            let q = (i as i32 + x.relative_index) as usize;
+            if late_discovered[ q % shingle_size].contains(&(x.id as usize)) {1} else {0}
+        } else {0}).sum();
+        total_overlap += y;
+        total_found += result.len();
+        late += z;
+        late_discovered[ i % shingle_size] = injected;
+    }
+    println!("number of time series: {} size {} each, {} arms,  parallel enabled: {}",number_of_series,data_size,number_of_models,parallel_enabled);
+    println!("shingle size: {}, normalization: {}, anomalies in total {}",shingle_size,transform_method,total_injected);
+    println!("spot precision {} recall {}",((total_overlap as f64)/(total_found as f64)),
+        ((total_overlap as f64)/(total_injected as f64)));
+    println!("with late detection, precision {} recall {}",(((total_overlap + late) as f64)/(total_found as f64)),
+             (((total_overlap+late) as f64)/(total_injected as f64)));
+    println!("nontrivial bandit switches {}, affirmations {}",multi_trcf.switches(),multi_trcf.affirmations());
+    print!("model updates across different arms:");
+    for y in multi_trcf.updates() {
+        print!("({}, {}) ",y.0,y.1)
+    }
+    println!();
+    // lets check the period_map; just for the first dimension
+    let mut result = multi_trcf.states().iter().map(|x| (x.bandit.current_model(),x.id,period_map.get(&x.id).unwrap()[0]))
+        .collect::<Vec<(usize,u64,usize)>>();
+    result.sort();
+    let mut a = result[0].0;
+    let mut stat = vec![Deviation::new(0.0).unwrap();number_of_models];
+    for y in result {
+        if a == y.0 {
+            stat[y.0].update(y.2 as f64);
+        } else {
+            a = y.0;
+        }
+    }
+    for x in 0..number_of_models {
+        println!("Model {},  chosen by {}, average period {}, deviation {} ",x,stat[x].count,stat[x].mean(),stat[x].deviation());
+    }
+}
diff --git a/Rust/tests/samplesummarytest.rs b/Rust/tests/samplesummarytest.rs
index a7a65e19..1fae6f53 100644
--- a/Rust/tests/samplesummarytest.rs
+++ b/Rust/tests/samplesummarytest.rs
@@ -12,7 +12,6 @@ use rcflib::{
     common::{multidimdatawithkey::MultiDimDataWithKey, samplesummary::summarize},
     l1distance, l2distance, linfinitydistance,
 };
-use rcflib::common::cluster::multi_cluster_as_ref;
 use rcflib::common::samplesummary::multi_summarize_ref;
 
 #[cfg(test)]
@@ -46,7 +45,7 @@ fn core(
         &scale,
         &vec![0.5 / test_dimension as f32; 2 * test_dimension],
         seed,
-    );
+    ).unwrap();
 
     let mut input = Vec::new();
     for i in 0..data_with_key.data.len() {
@@ -140,7 +139,7 @@ fn core_ref(
         &scale,
         &vec![0.5 / test_dimension as f32; 2 * test_dimension],
         seed,
-    );
+    ).unwrap();
 
     let mut input:Vec<(&[f32],f32)> = Vec::new();
     for i in 0..data_with_key.data.len() {