Sik/tradingbot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Change input pamaneters

Browse Source
This commit is contained in:
Sik Yoon 2024-01-01 12:36:53 +09:00
parent 5858b97667
commit c0344961bf
2 changed files with 80 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

163
src/value_estimation_team/indicators/bollingerband.rs
View File

@ -3,8 +3,8 @@
use crate::database_control::*; use crate::database_control::*;
use crate::value_estimation_team::datapoints::price_data::RealtimePriceData; use crate::value_estimation_team::datapoints::price_data::RealtimePriceData;
use crate::value_estimation_team::indicators::sma::SmaData; use crate::value_estimation_team::indicators::sma::{SmaData, sma};
use csv::{DeserializeRecordsIter, StringRecord}; use crate::strategy_team::FilteredData;
use futures::future::try_join_all; use futures::future::try_join_all;
use serde::Deserialize; use serde::Deserialize;
use sqlx::FromRow; use sqlx::FromRow;
@ -33,111 +33,96 @@ impl BollingerBandData {
// Binance Bollingerband (SMA) // Binance Bollingerband (SMA)
pub async fn bollingerband( pub async fn bollingerband(
period: usize, // this value should be same as moving size of sma period: usize,
sd_factor: f64, sd_factor: f64,
input_sma_data: &Vec<(String, Vec<SmaData>)>,
input_rt_data: &Vec<(String, Vec<RealtimePriceData>)>, input_rt_data: &Vec<(String, Vec<RealtimePriceData>)>,
filtered_symbols: &Vec<(String, i64)>, filtered_symbols: &Vec<FilteredData>,
) -> Result<Vec<(String, Vec<BollingerBandData>)>, Box<dyn std::error::Error + Send + Sync>> { ) -> Result<Vec<(String, Vec<BollingerBandData>)>, Box<dyn std::error::Error + Send + Sync>> {
if filtered_symbols.is_empty() { if filtered_symbols.is_empty() {
Err(("Err"))?; Err(("Err"))?;
} }
let mut read_rt_data_vec: Vec<(String, Vec<RealtimePriceData>)> = input_rt_data.clone(); let mut sma_data_vec: Vec<(String, Vec<SmaData>)> = sma(period, input_rt_data, filtered_symbols).await?;
let mut read_sma_data_vec: Vec<(String, Vec<SmaData>)> = input_sma_data.clone();
let mut bb_data_wrapper: Vec<(String, Vec<BollingerBandData>)> = Vec::new(); let mut bb_data_wrapper: Vec<(String, Vec<BollingerBandData>)> = Vec::new();
let mut bb_data_wrapper_arc = Arc::new(Mutex::new(bb_data_wrapper)); let mut bb_data_wrapper_arc = Arc::new(Mutex::new(bb_data_wrapper));
let mut task_vec = Vec::new(); let mut task_vec = Vec::new();
for symbol in filtered_symbols { for filtered_symbol in filtered_symbols {
let symbol_search_result1 = read_rt_data_vec.iter().position(|x| x.0 == *symbol.0); let filtered_symbol_c = filtered_symbol.clone();
let symbol_search_result2 = read_sma_data_vec.iter().position(|x| x.0 == *symbol.0); let rt_data_vec_c: Vec<(String, Vec<RealtimePriceData>)> = input_rt_data.clone();
let sma_data_vec_c = sma_data_vec.clone();
let bb_data_wrapper_arc_c = Arc::clone(&bb_data_wrapper_arc);
task_vec.push(tokio::spawn(async move {
let search_result1 = rt_data_vec_c.clone().iter().position(|x| x.0 == *filtered_symbol_c.symbol);
let search_result2 = sma_data_vec_c.iter().position(|x| x.0 == *filtered_symbol_c.symbol);
match symbol_search_result1 { if search_result1.is_some() && search_result2.is_some() {
Some(rt_index) => { let mut bb_data = BollingerBandData::new();
match symbol_search_result2 { let mut bb_data_vec: Vec<BollingerBandData> = Vec::new();
Some(sma_index) => {
let bb_data_wrapper_arc_c = Arc::clone(&bb_data_wrapper_arc); // if the data has shorter than buffer
let mut bb_data = BollingerBandData::new(); if sma_data_vec_c[search_result2.unwrap()].1.len() > period {
let mut bb_data_vec: Vec<BollingerBandData> = Vec::new(); let result = rt_data_vec_c[search_result1.unwrap()].1.binary_search_by_key(
let read_rt_data_vec_c = read_rt_data_vec.clone(); &sma_data_vec_c[search_result2.unwrap()].1.first().unwrap().close_time,
let read_sma_data_vec_c = read_sma_data_vec.clone(); |RealtimePriceData {
let symbol_c = symbol.clone(); opclo_price,
task_vec.push(tokio::spawn(async move { open_price,
// if the data has shorter than buffer close_price,
if read_sma_data_vec_c[sma_index].1.len() < period { high_price,
bb_data.sma = 0.0; low_price,
bb_data.upperband = 0.0; close_time,
bb_data.lowerband = 0.0; quote_asset_volume,
bb_data.close_time = 0; candle_type,
bb_data_vec.push(bb_data.clone()); }| *close_time,
} else { );
let result = read_rt_data_vec_c[rt_index].1.binary_search_by_key(
&read_sma_data_vec_c[sma_index].1.first().unwrap().close_time,
|RealtimePriceData {
opclo_price,
open_price,
close_price,
high_price,
low_price,
close_time,
quote_asset_volume,
candle_type,
}| *close_time,
);
match result { match result {
Ok(T) => { Ok(T) => {
if T <= period - 1 { if T <= period - 1 {
let mut read_data_iter = let mut read_data_iter =
read_sma_data_vec_c[sma_index].1.iter(); sma_data_vec_c[search_result2.unwrap()].1.iter();
for _ in T..period - 1 { for _ in T..period - 1 {
read_data_iter.next(); read_data_iter.next();
} }
let window_iter = let window_iter =
read_rt_data_vec_c[rt_index].1.windows(period); rt_data_vec_c[search_result1.unwrap()].1.windows(period);
for buffer in window_iter { for buffer in window_iter {
let mut sd_mean = 0.0; let mut sd_mean = 0.0;
let mut standard_deviation = 0.0; let mut standard_deviation = 0.0;
for element in buffer { for element in buffer {
sd_mean += element.close_price; sd_mean += element.close_price;
} }
sd_mean /= (period as f64); sd_mean /= (period as f64);
for element in buffer { for element in buffer {
standard_deviation += standard_deviation +=
(element.close_price - sd_mean).powi(2); (element.close_price - sd_mean).powi(2);
} }
standard_deviation = sd_factor standard_deviation = sd_factor
* ((standard_deviation / period as f64).sqrt()); * ((standard_deviation / period as f64).sqrt());
match read_data_iter.next() { match read_data_iter.next() {
Some(T) => { Some(T) => {
bb_data.sma = T.sma_value; bb_data.sma = T.sma_value;
bb_data.upperband = bb_data.upperband =
T.sma_value + standard_deviation; T.sma_value + standard_deviation;
bb_data.lowerband = bb_data.lowerband =
T.sma_value - standard_deviation; T.sma_value - standard_deviation;
bb_data.close_time = T.close_time; bb_data.close_time = T.close_time;
bb_data_vec.push(bb_data.clone()); bb_data_vec.push(bb_data.clone());
} }
None => {} None => {}
} }
}
}
}
Err(E) => {}
} }
let mut bb_data_wrapper_lock = bb_data_wrapper_arc_c.lock().await;
bb_data_wrapper_lock
.push((symbol_c.0.clone(), bb_data_vec.clone()));
} }
})); }
Err(E) => {}
} }
None => {} let mut bb_data_wrapper_lock = bb_data_wrapper_arc_c.lock().await;
bb_data_wrapper_lock
.push((filtered_symbol_c.symbol.clone(), bb_data_vec.clone()));
} }
} }
None => {} }));
}
} }
try_join_all(task_vec).await?; try_join_all(task_vec).await?;
let a = bb_data_wrapper_arc.lock().await.to_owned(); let a = bb_data_wrapper_arc.lock().await.to_owned();

12
src/value_estimation_team/indicators/sma.rs
View File

@ -3,7 +3,7 @@
use crate::database_control::*; use crate::database_control::*;
use crate::value_estimation_team::datapoints::price_data::RealtimePriceData; use crate::value_estimation_team::datapoints::price_data::RealtimePriceData;
use csv::{DeserializeRecordsIter, StringRecord}; use crate::strategy_team::FilteredData;
use futures::future::try_join_all; use futures::future::try_join_all;
use serde::Deserialize; use serde::Deserialize;
use sqlx::FromRow; use sqlx::FromRow;
@ -29,7 +29,7 @@ impl SmaData {
pub async fn sma( pub async fn sma(
moving_number: usize, moving_number: usize,
input_rt_data: &Vec<(String, Vec<RealtimePriceData>)>, input_rt_data: &Vec<(String, Vec<RealtimePriceData>)>,
filtered_symbols: &Vec<(String, i64)>, filtered_symbols: &Vec<FilteredData>,
) -> Result<Vec<(String, Vec<SmaData>)>, Box<dyn std::error::Error + Send + Sync>> { ) -> Result<Vec<(String, Vec<SmaData>)>, Box<dyn std::error::Error + Send + Sync>> {
if filtered_symbols.is_empty() { if filtered_symbols.is_empty() {
Err("Err")?; Err("Err")?;
@ -39,13 +39,13 @@ pub async fn sma(
let mut sma_data_wrapper_arc = Arc::new(Mutex::new(sma_data_wrapper)); let mut sma_data_wrapper_arc = Arc::new(Mutex::new(sma_data_wrapper));
let mut task_vec = Vec::new(); let mut task_vec = Vec::new();
for symbol in filtered_symbols { for filtered_symbol in filtered_symbols {
let symbol_search_result = input_rt_data.iter().position(|x| x.0 == *symbol.0); let symbol_search_result = input_rt_data.iter().position(|x| x.0 == *filtered_symbol.symbol);
match symbol_search_result { match symbol_search_result {
Some(T) => { Some(T) => {
let sma_data_wrapper_arc_c = Arc::clone(&sma_data_wrapper_arc); let sma_data_wrapper_arc_c = Arc::clone(&sma_data_wrapper_arc);
let symbol_c = symbol.clone(); let symbol_c = filtered_symbol.symbol.clone();
let mut sma_data = SmaData::new(); let mut sma_data = SmaData::new();
let mut sma_data_vec: Vec<SmaData> = Vec::new(); let mut sma_data_vec: Vec<SmaData> = Vec::new();
let input_rt_data_c = input_rt_data.clone(); let input_rt_data_c = input_rt_data.clone();
@ -69,7 +69,7 @@ pub async fn sma(
} }
} }
let mut sma_data_wrapper_lock = sma_data_wrapper_arc_c.lock().await; let mut sma_data_wrapper_lock = sma_data_wrapper_arc_c.lock().await;
sma_data_wrapper_lock.push((symbol_c.0.clone(), sma_data_vec.clone())); sma_data_wrapper_lock.push((symbol_c.clone(), sma_data_vec.clone()));
})); }));
} }
None => {} None => {}