Add indicators using opclo price

src/strategy_team/mod.rs

@@ -14,13 +14,13 @@ use crate::database_control::*;
 use crate::decimal_funcs::*;
 use crate::value_estimation_team::datapoints::price_data::RealtimePriceData;
 use crate::value_estimation_team::indicators::bollingerband::{bollingerband, BollingerBandData};
-use crate::value_estimation_team::indicators::ema::{ema, EmaData};
+use crate::value_estimation_team::indicators::ema::{ema, ema_opclo, EmaData};
 use crate::value_estimation_team::indicators::heatmap_volume::{
     heatmap_volume, HeatMapLevel, HeatmapVolumeData,
 };
 use crate::value_estimation_team::indicators::macd::{ema_macd, MacdData};
 use crate::value_estimation_team::indicators::rsi::{rsi, RsiData};
-use crate::value_estimation_team::indicators::sma::{sma, SmaData};
+use crate::value_estimation_team::indicators::sma::{sma, sma_opclo, SmaData};
 use crate::value_estimation_team::indicators::stoch_rsi::{stoch_rsi, StochRsiData};
 use crate::value_estimation_team::indicators::supertrend::{supertrend, SupertrendData};
 use crate::value_estimation_team::indicators::adx::{AdxData, adx};

src/value_estimation_team/indicators/ema.rs

@@ -93,3 +93,73 @@ pub async fn ema(
     let a = ema_data_wrapper_arc.lock().await.to_owned();
     Ok(a)
 }
+
+// Binance EMA ((open+close)/2)
+pub async fn ema_opclo(
+    moving_number: usize,
+    input_rt_data: &Vec<(String, Vec<RealtimePriceData>)>,
+    filtered_symbols: &Vec<FilteredData>,
+) -> Result<Vec<(String, Vec<EmaData>)>, Box<dyn std::error::Error + Send + Sync>> {
+    if filtered_symbols.is_empty() {
+        Err("Err")?;
+    }
+
+    let alpha: f64 = 2.0 / (moving_number as f64 + 1.0);
+    let mut ema_t: f64 = 0.0;
+    let mut ema_prev: f64 = 0.0;
+
+    let mut ema_data_wrapper: Vec<(String, Vec<EmaData>)> = Vec::new();
+    let mut ema_data_wrapper_arc = Arc::new(Mutex::new(ema_data_wrapper));
+    let mut task_vec = Vec::new();
+    for filtered_elem in filtered_symbols {
+        let symbol_search_result = input_rt_data.iter().position(|x| x.0 == *filtered_elem.symbol);
+
+        match symbol_search_result {
+            Some(T) => {
+                let ema_data_wrapper_arc_c = Arc::clone(&ema_data_wrapper_arc);
+                let filtered_elem_c = filtered_elem.clone();
+                let mut ema_data = EmaData::new();
+                let mut ema_data_vec: Vec<EmaData> = Vec::new();
+                let input_rt_data_c = input_rt_data.clone();
+                task_vec.push(tokio::spawn(async move {
+                    if input_rt_data_c[T].1.len() < moving_number {
+                        ema_data.ema_value = 0.0;
+                        ema_data.close_time = 0;
+                        ema_data_vec.push(ema_data.clone());
+                    } else {
+                        let partial_vec1 = input_rt_data_c[T].1.get(..moving_number).unwrap();
+                        let partial_vec2 = input_rt_data_c[T].1.get(moving_number..).unwrap();
+
+                        let mut sma_for_initial_value = 0.0;
+                        for element in partial_vec1 {
+                            sma_for_initial_value += element.opclo_price;
+                        }
+                        sma_for_initial_value /= moving_number as f64;
+
+                        ema_data.ema_value = sma_for_initial_value;
+                        ema_data.close_time = partial_vec1.last().unwrap().close_time;
+                        ema_data_vec.push(ema_data.clone());
+
+                        ema_prev = sma_for_initial_value;
+
+                        for element in partial_vec2 {
+                            ema_t = (1.0 - alpha) * ema_prev + alpha * element.opclo_price;
+
+                            ema_data.ema_value = ema_t;
+                            ema_data.close_time = element.close_time;
+                            ema_data_vec.push(ema_data.clone());
+
+                            ema_prev = ema_t;
+                        }
+                    }
+                    let mut ema_data_wrapper_lock = ema_data_wrapper_arc_c.lock().await;
+                    ema_data_wrapper_lock.push((filtered_elem_c.symbol.clone(), ema_data_vec.clone()));
+                }));
+            }
+            None => {}
+        }
+    }
+    try_join_all(task_vec).await?;
+    let a = ema_data_wrapper_arc.lock().await.to_owned();
+    Ok(a)
+}

src/value_estimation_team/indicators/sma.rs

@@ -72,3 +72,51 @@ pub async fn sma(
     let a = sma_data_wrapper_arc.lock().await.to_owned();
     Ok(a)
 }
+
+// Binance MA ((open+close)/2)
+pub async fn sma_opclo(
+    moving_number: usize,
+    input_rt_data: &Vec<(String, Vec<RealtimePriceData>)>,
+    filtered_symbols: &Vec<FilteredData>,
+) -> Result<Vec<(String, Vec<SmaData>)>, Box<dyn std::error::Error + Send + Sync>> {
+    if filtered_symbols.is_empty() {
+        Err("Err")?;
+    }
+
+    let mut sma_data_wrapper: Vec<(String, Vec<SmaData>)> = Vec::new();
+    let mut sma_data_wrapper_arc = Arc::new(Mutex::new(sma_data_wrapper));
+
+    let mut task_vec = Vec::new();
+    for filtered_symbol in filtered_symbols {
+        let filtered_symbol_c = filtered_symbol.clone();
+        let sma_data_wrapper_arc_c = Arc::clone(&sma_data_wrapper_arc);
+        let input_rt_data_c = input_rt_data.clone();
+        task_vec.push(tokio::spawn(async move {
+            let search_result = input_rt_data_c.iter().position(|x| x.0 == *filtered_symbol_c.symbol);
+            if search_result.is_some() {
+                let mut sma_data = SmaData::new();
+                let mut sma_data_vec: Vec<SmaData> = Vec::new();
+                
+                if input_rt_data_c[search_result.unwrap()].1.len() >= moving_number {
+                    let mut iter = input_rt_data_c[search_result.unwrap()].1.windows(moving_number);
+                    for buffer in iter {
+                        let mut avg = 0.0;
+                        for element in buffer {
+                            avg += element.opclo_price;
+                        }
+                        avg /= (moving_number as f64);
+
+                        sma_data.sma_value = avg;
+                        sma_data.close_time = buffer.last().unwrap().close_time;
+                        sma_data_vec.push(sma_data.clone());
+                    }
+                }
+                let mut sma_data_wrapper_lock = sma_data_wrapper_arc_c.lock().await;
+                sma_data_wrapper_lock.push((filtered_symbol_c.symbol.clone(), sma_data_vec.clone()));
+            }
+        }));
+    }
+    try_join_all(task_vec).await?;
+    let a = sma_data_wrapper_arc.lock().await.to_owned();
+    Ok(a)
+}