Yet Another Technical Analysis library [for Rust]

Last update: Dec 29, 2022

Overview

YATA

Yet Another Technical Analysis library

YaTa implements most common technical analysis methods and indicators.

It also provides you an interface to create your own indicators.

[dependencies]
yata = "0.4"

Available moving averages:

Simple moving average (SMA);
Weighted moving average (WMA);
Exponential moving average family: EMA, DMA, TMA, DEMA, TEMA;
Simple moving median (SMM);
Linear regression moving average (LSMA);
Volume weighted moving average (VWMA);
Symmetrically weighted moving average (SWMA);
Hull moving average (HMA);
Running Moving Average (RMA);
Triangular Moving Average (TRIMA);
Wilder’s Smoothing Average (WSMA);
Kaufman Adaptive Moving Average (KAMA);
Convolution Moving Average;
Variable Index Dynamic Average (Vidya);

See all

Timeseries conversion

Some commonly used methods:

Accumulation-distribution index;
Commodity channel index;
Cross / CrossAbove / CrossUnder;
Derivative (differential);
Highest / Lowest / Highest-Lowest Delta;
Highest Index / Lowest Index;
Integral (sum);
Mean absolute deviation;
Median absolute deviation;
Momentum;
Past;
Rate Of Change (ROC);
Reversal points;
Standard Deviation;
True Range;
True Strength Index;
Volatility;

See all

Some commonly used indicators:

And many others. See all

Method usage example

use yata::prelude::*;
use yata::methods::EMA;

// EMA of length=3
let mut ema = EMA::new(3, 3.0).unwrap();

ema.next(3.0);
ema.next(6.0);

assert_eq!(ema.next(9.0), 6.75);
assert_eq!(ema.next(12.0), 9.375);

Indicator usage example

use yata::helpers::{RandomCandles, RegularMethods};
use yata::indicators::MACD;
use yata::prelude::*;

let mut candles = RandomCandles::new();
let mut macd = MACD::default();
macd.period3 = 4; // setting signal period MA to 4

macd.method1 = "sma".parse().unwrap(); // one way of defining methods inside indicators

macd.method3 = RegularMethods::TEMA; // another way of defining methods inside indicators

let mut macd = macd.init(candles.first()).unwrap();

for candle in candles.take(10) {
	let result = macd.next(candle);

	println!("{:?}", result);
}

Benchmarks

Methods

_w10 - method with window length=10
_w100 - method with window length=100

test bench_adi_w10                   ... bench:           7 ns/iter (+/- 0)
test bench_adi_w100                  ... bench:           7 ns/iter (+/- 0)
test bench_cci_w10                   ... bench:          16 ns/iter (+/- 0)
test bench_cci_w100                  ... bench:         133 ns/iter (+/- 8)
test bench_conv_w10                  ... bench:          23 ns/iter (+/- 2)
test bench_conv_w100                 ... bench:         197 ns/iter (+/- 0)
test bench_cross                     ... bench:           5 ns/iter (+/- 0)
test bench_cross_above               ... bench:           3 ns/iter (+/- 0)
test bench_cross_under               ... bench:           3 ns/iter (+/- 0)
test bench_dema_w10                  ... bench:           7 ns/iter (+/- 0)
test bench_dema_w100                 ... bench:           6 ns/iter (+/- 0)
test bench_derivative_w10            ... bench:           4 ns/iter (+/- 0)
test bench_derivative_w100           ... bench:           3 ns/iter (+/- 0)
test bench_dma_w10                   ... bench:           5 ns/iter (+/- 0)
test bench_dma_w100                  ... bench:           5 ns/iter (+/- 0)
test bench_ema_w10                   ... bench:           5 ns/iter (+/- 0)
test bench_ema_w100                  ... bench:           5 ns/iter (+/- 0)
test bench_heikin_ashi               ... bench:           4 ns/iter (+/- 0)
test bench_highest_index_w10         ... bench:           6 ns/iter (+/- 0)
test bench_highest_index_w100        ... bench:           6 ns/iter (+/- 0)
test bench_highest_lowest_delta_w10  ... bench:          10 ns/iter (+/- 0)
test bench_highest_lowest_delta_w100 ... bench:          10 ns/iter (+/- 0)
test bench_highest_w10               ... bench:           6 ns/iter (+/- 0)
test bench_highest_w100              ... bench:           7 ns/iter (+/- 0)
test bench_hma_w10                   ... bench:          14 ns/iter (+/- 0)
test bench_hma_w100                  ... bench:          15 ns/iter (+/- 0)
test bench_integral_w10              ... bench:           7 ns/iter (+/- 0)
test bench_integral_w100             ... bench:           7 ns/iter (+/- 0)
test bench_lin_reg_w10               ... bench:           8 ns/iter (+/- 1)
test bench_lin_reg_w100              ... bench:           8 ns/iter (+/- 0)
test bench_linear_volatility_w10     ... bench:           4 ns/iter (+/- 0)
test bench_linear_volatility_w100    ... bench:           4 ns/iter (+/- 0)
test bench_lowest_index_w10          ... bench:           6 ns/iter (+/- 0)
test bench_lowest_index_w100         ... bench:           7 ns/iter (+/- 0)
test bench_lowest_w10                ... bench:           6 ns/iter (+/- 0)
test bench_lowest_w100               ... bench:           6 ns/iter (+/- 0)
test bench_mean_abs_dev_w10          ... bench:          11 ns/iter (+/- 0)
test bench_mean_abs_dev_w100         ... bench:         123 ns/iter (+/- 4)
test bench_median_abs_dev_w10        ... bench:          31 ns/iter (+/- 7)
test bench_median_abs_dev_w100       ... bench:         190 ns/iter (+/- 8)
test bench_momentum_w10              ... bench:           3 ns/iter (+/- 0)
test bench_momentum_w100             ... bench:           3 ns/iter (+/- 0)
test bench_past_w10                  ... bench:           3 ns/iter (+/- 0)
test bench_past_w100                 ... bench:           3 ns/iter (+/- 0)
test bench_rate_of_change_w10        ... bench:           3 ns/iter (+/- 0)
test bench_rate_of_change_w100       ... bench:           3 ns/iter (+/- 0)
test bench_reverse_high_w10          ... bench:           5 ns/iter (+/- 0)
test bench_reverse_high_w100         ... bench:           5 ns/iter (+/- 0)
test bench_reverse_low_w10           ... bench:           5 ns/iter (+/- 0)
test bench_reverse_low_w100          ... bench:           5 ns/iter (+/- 0)
test bench_reverse_signal_w10        ... bench:           9 ns/iter (+/- 0)
test bench_reverse_signal_w100       ... bench:           9 ns/iter (+/- 0)
test bench_rma_w10                   ... bench:           4 ns/iter (+/- 0)
test bench_rma_w100                  ... bench:           4 ns/iter (+/- 0)
test bench_sma_w10                   ... bench:           3 ns/iter (+/- 0)
test bench_sma_w100                  ... bench:           3 ns/iter (+/- 0)
test bench_smm_w10                   ... bench:          17 ns/iter (+/- 1)
test bench_smm_w100                  ... bench:          35 ns/iter (+/- 2)
test bench_st_dev_w10                ... bench:           7 ns/iter (+/- 0)
test bench_st_dev_w100               ... bench:           7 ns/iter (+/- 0)
test bench_swma_w10                  ... bench:           8 ns/iter (+/- 0)
test bench_swma_w100                 ... bench:           8 ns/iter (+/- 0)
test bench_tema_w10                  ... bench:           8 ns/iter (+/- 0)
test bench_tema_w100                 ... bench:           7 ns/iter (+/- 0)
test bench_tma_w10                   ... bench:           5 ns/iter (+/- 0)
test bench_tma_w100                  ... bench:           5 ns/iter (+/- 1)
test bench_trima_w10                 ... bench:           5 ns/iter (+/- 0)
test bench_trima_w100                ... bench:           5 ns/iter (+/- 1)
test bench_tsi_w10                   ... bench:           9 ns/iter (+/- 0)
test bench_tsi_w100                  ... bench:          10 ns/iter (+/- 0)
test bench_vidya_w10                 ... bench:           8 ns/iter (+/- 1)
test bench_vidya_w100                ... bench:           8 ns/iter (+/- 0)
test bench_vwma_w10                  ... bench:           5 ns/iter (+/- 0)
test bench_vwma_w100                 ... bench:           5 ns/iter (+/- 0)
test bench_wma_w10                   ... bench:           6 ns/iter (+/- 1)
test bench_wma_w100                  ... bench:           6 ns/iter (+/- 0)

Indicators

test bench_awesome_oscillator                  ... bench:          36 ns/iter (+/- 0)
test bench_bollinger_bands                     ... bench:          53 ns/iter (+/- 2)
test bench_chaikin_money_flow                  ... bench:          22 ns/iter (+/- 0)
test bench_chaikin_oscillator                  ... bench:          23 ns/iter (+/- 0)
test bench_chande_kroll_stop                   ... bench:          58 ns/iter (+/- 0)
test bench_chande_momentum_oscillator          ... bench:          25 ns/iter (+/- 0)
test bench_commodity_channel_index             ... bench:          38 ns/iter (+/- 0)
test bench_coppock_curve                       ... bench:          38 ns/iter (+/- 2)
test bench_detrended_price_oscillator          ... bench:          10 ns/iter (+/- 0)
test bench_ease_of_movement                    ... bench:          20 ns/iter (+/- 0)
test bench_elders_force_index                  ... bench:          17 ns/iter (+/- 1)
test bench_envelopes                           ... bench:          14 ns/iter (+/- 0)
test bench_fisher_transform                    ... bench:         125 ns/iter (+/- 13)
test bench_hull_moving_average                 ... bench:          28 ns/iter (+/- 0)
test bench_ichimoku_cloud                      ... bench:          65 ns/iter (+/- 7)
test bench_indicator_aroon                     ... bench:          46 ns/iter (+/- 12)
test bench_indicator_average_directional_index ... bench:          49 ns/iter (+/- 1)
test bench_kaufman                             ... bench:          34 ns/iter (+/- 3)
test bench_keltner_channel                     ... bench:          26 ns/iter (+/- 2)
test bench_klinger_volume_oscillator           ... bench:          40 ns/iter (+/- 1)
test bench_know_sure_thing                     ... bench:          41 ns/iter (+/- 0)
test bench_macd                                ... bench:          23 ns/iter (+/- 0)
test bench_momentum_index                      ... bench:          13 ns/iter (+/- 0)
test bench_money_flow_index                    ... bench:          59 ns/iter (+/- 12)
test bench_parabolic_sar                       ... bench:          17 ns/iter (+/- 2)
test bench_pivot_reversal_strategy             ... bench:          30 ns/iter (+/- 4)
test bench_relative_strength_index             ... bench:          35 ns/iter (+/- 1)
test bench_relative_vigor_index                ... bench:          59 ns/iter (+/- 0)
test bench_smi_ergodic_indicator               ... bench:          30 ns/iter (+/- 2)
test bench_stochastic_oscillator               ... bench:          48 ns/iter (+/- 4)
test bench_trend_strength_index                ... bench:          46 ns/iter (+/- 2)
test bench_trix                                ... bench:          32 ns/iter (+/- 10)
test bench_true_strength_index                 ... bench:          38 ns/iter (+/- 16)
test bench_woodies_cci                         ... bench:          68 ns/iter (+/- 6)

Current unsafe status

By default, there is no unsafe code in the crate. But you can optionally enable unsafe_performance feature throw you Cargo.toml or by --feature flag in your CLI.

usafe_performance enables some unsafe code blocks, most of them are unsafe access to a vector's elements. For some methods it may increase performance by ~5-10%.

Features

serde - enables serde crate support;
period_type_u16 - sets PeriodType to u16;
period_type_u32 - sets PeriodType to u32;
period_type_u64 - sets PeriodType to u64;
value_type_f32 - sets ValueType to f32;
unsafe_performance - enables optional unsafe code blocks, which may increase performance;

Rust version

YaTa library supports Rust stable except that you can't run benchmarks with it.

Suggestions

You are welcome to give any suggestions about implementing new indicators and methods.

Say thanks

If you like this library, and you want to say thanks, you can do it also by donating to bitcoin address 1P3gTnaTK9LKSYx2nETrKe2zjP4HMkdhvK

Comments

Instance snapshotting

Is it feasible to make an indicator instance cloneable, to make a snapshot and process new values without reapplying full history?

P.S. great library, best by far for Rust

opened by agubarev 8
`Indicator`s use `RegularMethods` instead of `Method`

Most Indicators use the RegularMethods type. For me to use an existing indicator with a new Method I make I have to clone the source and add the new method to RegularMethods. Why don't they just use a Method?

Related to this is that by using the RegularMethods you are forcing the usage of Box and possible multiple-calculation of the same thing. If I want to use MACD and Keltner Channels in which one of the methods and its period is the same we are making double calculations. If Indicators take instead &'a dyn Method we would be both generalizing and allowing for more optimizations.
enhancement

opened by raimundomartins 8
Allow peeking at last method update
I have been working with yata's EMA struct and I am missing some functionality that makes it a bit frustrating to work with.

Right now, the only way to get at the current value of the average is to call item.next(new_value), but I want to check back later to see if this value has changed and I won't necessarily have new data when I want to check on the value. Obviously, I could write a simple wrapper like this, but I think this functionality could be useful to others.

PeekableWrapper { ema: EMA, last: Option<f64> }

I haven't looked at all the Method implementations in this library, so it may not be efficient or possible to peek at for all of them due to implementation challenges. To work around this, I suggest adding a new trait Peekable that lets you peek at the last updated value and implement this trait where it is possible. This wouldn't break backwards compatibility and it would allow future implementations of Peekable if it becomes possible later.

Maybe even add a .into_peekable(self) -> PeekableWrapper<Self> method on Method that takes an un-peekable item and wraps it into a peekable struct by storing the current value.

What are your thoughts on this? If you are open I would be happy to write something up in a PR.
enhancement
opened by msdrigg 7
How do I use this with CSV data

Hi,

Looking at docs its really hard to tell how to import CSV data (Date,Open,High,Low,Close,Volume) and which struct to use for it.

I was looking at the RandomCandles struct and had no idea how to make one thats not actually random.

Please show an example of working with a CSV file and constructing candles off of it.

opened by whyCPPgofast 6
Allow to access indicator instance
There might be some Rust knowledge I don't have that fixes this problem and if so, I apologize but a bit of help would be great.

I was trying to create an Historyobject that would store various indicators for specific timeframes (1min, 5min, ..). And at each trade event I would get from the exchange feed, I could simply update the candle of the specific timeframes I'm tracking and for each timeframe, update the indicator accordingly with the next() method (a bit of a "rolling indicator" idea where the indicator is always with the latest data).

However, it appears that one must .init() the indicator with a first candle in order to get an indicator instance object (which is not publicly available, deriving the IndicatorInstance trait).

And so this is a problem because it means that every time I want to compute let say the RSI of a specific timeframe, I need all 14 historical candle and next() them all which is a bit of a waste considering an indicator in the first place can just keep the rolling value.

Would it be possible to have something like:

pub struct History { rsi: RelativeStrengthIndexInstance, }

and so one can simply update the rsi has trade events occur taken from the exchange feed. Or even better, simply having the RSI objectbe able to initialize itself at the first next() ?

Note that I tried to use rsi: Box<dyn IndicatorInstance<Config = RSI>> but that fail to build due to a trait requirement (Sized).

Wondering your thought here or if I'm missing something. Thanks!
opened by dgoulet 6
ADI seems incorrect?

Hi folks, while working on a little Alpaca experiment, I was looking at yata and ended up poking at the adi method. Unfortunately, in testing things out, it gave me rather bad data. Looking at the code, it seems that it is using the clv against the single bar inputs rather than the 'day' low/high, which as I understand it is not correct? When I plugged in a custom implementation based on the days values, it seemed to correct the problem. Perhaps I'm reading it incorrectly?

opened by All8Up 4
ohlcv merge operator

Hi Dmitry, first of all great work on this library, I also wanted to fork ta so it saves me a lot of time.

I'm using candles with more added info, and figured it would be good to use the sequence operators with a custom candle type.

opened by Igosuki 4
RelativeStrengthIndex indicator is inverted

I think the RelativeStrengthIndex indicator is reversed. When it should send SELL it sends BUY and vice versa. Where are the tests covering this indicator? I cannot find them.
question indicator

opened by lephyrius 4

BollingerBands results compared to ta-rs

Try to compare yata with ta-rs, the BollingerBands results shows differently:

    use yata::indicators::{BollingerBands};
    use yata::prelude::*;

    use ta::indicators::{BollingerBands as TaBollingerBands, BollingerBandsOutput};
    use ta::Next;

    // ta
    let mut bb = TaBollingerBands::new(3, 2.0_f64).unwrap();
    println!("[ta-bb] \n{:?}\n{:?}\n{:?}\n{:?}", &bb.next(1.0), &bb.next(2.0), &bb.next(4.0), &bb.next(8.0));

    // yata
    let mut boll = BollingerBands::default();
    boll.set("avg_size", String::from("3")).unwrap();
    let mut bb = boll.init(&Candle { close: 1.0, ..Candle::default() }).unwrap();
    println!("[yata-bb] \n{:?}\n{:?}\n{:?}",
        &bb.next(&Candle { close: 2.0, ..Candle::default() }),
        &bb.next(&Candle { close: 4.0, ..Candle::default() }),
        &bb.next(&Candle { close: 8.0, ..Candle::default() }),
    );

The outputs:

[ta-bb] 
BollingerBandsOutput { average: 1.0, upper: 1.0, lower: 1.0 }
BollingerBandsOutput { average: 1.5, upper: 2.5, lower: 0.5 }
BollingerBandsOutput { average: 2.3333333333333335, upper: 4.8277715911826276, lower: -0.1611049245159606 }
BollingerBandsOutput { average: 4.666666666666667, upper: 9.655543182365255, lower: -0.3222098490319212 }
[yata-bb] 
S: [+0.58], V: [ 2.4880,  1.3333,  0.1786]
S: [+0.55], V: [ 5.3884,  2.3333, -0.7217]
S: [+0.55], V: [10.7768,  4.6667, -1.4434]

The question is why it shows different results?

opened by mithriljs-cn 3

calculation for standard deviation seems wrong

fn main() {
  let v = vec![1.0, 1.0, 2.0];
  let mut stdev = StDev::new(3, &v[0]).unwrap();
  stdev.next(&v[1]);
  assert_eq!(stdev.next(&v[2]), 0.4714045207910317);
}

assert failed.

opened by flameoftheforest 2

How to get the avg from SMA method?
Hello Yata!

Great repo, I was trying to learn how to use this repo by starting with the SMA indicator. I'm not sure what I am doing wrong but I can't seem to get the avg / value from the SMA.

Here is my code:

let mut sma = SMA::new(30, &f64::NAN).unwrap(); for i in 0..sma.get_window().len() { sma.next(&(i as f64)); } println!("{:?}", sma.peek());

However this returns NaN? I was wondering how to get the moving average from the window? Do I have to manually calculate it or does yata do this for me?

Thank you :)
opened by frozenranger 2
`IndicatorResult` needs refactoring
For now every indicator must implements both values and signals calculation logic. That might be a problem if you want to use values to implement your own signals logic because of performance degradation.

So the current proposal is to make an IndicatorResult as a trait which will only be responsible for representing values. The idea behind is that every indicator should have it's own IndicatorResult type. This will help keep indicators values more verbose. A single struct, that implements IndicatorResult, must contain all the values, that indicator returns. As a bonus there might be different types of values: not only f64 like now.

Then for signals create another trait Signal and make two internal signal types: BinarySignal for signals like {-1; 0; +1} and FloatSignal for signals in range [-1.0; 1.0]. Every single signal must have it's own struct representation.

This approach has next pros:

Every indicator may produce different type of values: not only f64s like now;

Every IndicatorResult may have more verbose documentation and explanation;

You may choose which signals you want to calculate and which not waste performance on;

More clear differentiation on signal types;

Custom signal types might be created for your personal indicator.

Cons: More code must be written to get a signal from indicator: you need to create IndicatorConfig, then initialize IndicatorInstance (like now), then calculate IndicatorResult, then initialize appropriate Signal, then throw IndicatorResult into Signal and finally get your signal.
enhancement
opened by amv-dev 1
Divergence Detector

The ability to detect a divergence between the price and an indicator is really a powerful one. I personally have noted many situations where divergences results in good trades (It does fail from time to time as well). It would be good to have a divergence detector as a generic component that takes in a Source and an Indicator and detects bullish, bearish, hidden bullish and hidden bearish divergences. Example: https://www.tradingview.com/script/sxZRzQzQ-Divergence-Indicator-any-oscillator/
question method

opened by hardvain 1
Categorize indicators
Categorize the indicators based on their characteristics. The main 3 types of indicators are

Momentum Based Indicators

Volume Based Indicators and

Volatility Based Indicators

question
opened by hardvain 1
Contribution Guidelines

Hi @amv-dev, I have been creating a technical analysis library in rust for my personal use for sometime now and I stumbled upon yata. Yata is much more comprehensive, performant than what I have managed to create. I wanted to understand what are the features planned for yata so that I can also start contributing. I am a beginner when it comes to rust knowledge but would be happy to contribute in whatever way I can. Please let me know your thoughts on the same.

Apart from the indicators, I also wanted to have a system to do backtest on the data as well. So please let me know if you also plan to include some backtesting module in yata.

opened by hardvain 3

Releases(v0.6.0)

v0.6.0(Feb 13, 2022)
collapse_timeframe now returns same type as source values;

removed Debug trait requirement on Method trait.

Source code(tar.gz)
Source code(zip)
v0.5.1(Jan 29, 2022)

Added Peekable and Buffered traits.
Source code(tar.gz)
Source code(zip)
v0.5.0(Dec 6, 2021)

Switching between methods is made now without dynamic dispatching.
Source code(tar.gz)
Source code(zip)
v0.4.7(Jun 17, 2021)
Fixed Trixs set method implementation;

Fixed RelativeStrengthIndex result value at the very first iteration;

Optimized RelativeStrengthIndex;

Window docs update;

Fixed new clippy warnings;

Reduced trait bounds for many methods of Sequence;

Typos fix;

Source code(tar.gz)
Source code(zip)
v0.4.6(Jun 4, 2021)
Typos fix;

Sequence trait code style refactoring;

Fixed #2 signal for ChandeKrollStop;

Added [non_exhaustive] attribute to some enums.

Source code(tar.gz)
Source code(zip)
v0.4.5(Mar 28, 2021)
Improved serde support;

Removed useless fields in Derivative method;

Removed useless fields in ADI method;

Removed useless fields in LinReg method;

Improved Window performance;

Fixed clippy warnings;

Added additional SMM test checks.

Source code(tar.gz)
Source code(zip)
v0.4.4(Feb 24, 2021)
helpers::assert_eq_float made available from non-test environment;

added impl<T: Copy> AsRef<T> for Window<T>;

added is_rising/is_falling methods for OHLCV;

docs fix.

Source code(tar.gz)
Source code(zip)
v0.4.3(Feb 9, 2021)
Added more strict IndicatorInstances Config associated type trait bound;

Removed unnecessary Copy trait bound for Methods Output associated type;

Some docs updates;

Added Renko conversion method;

Added timeframe conversion method;

Added From<&dyn OHLCV> for Candle implementation.

Source code(tar.gz)
Source code(zip)
v0.4.2(Jan 18, 2021)
Refactored Momentum method;

Refactored MeanAbsDev method;

Refactored MedianAbsDev method;

Fixed helpers/assert_eq_float behavior when value is near zero;

Improved StDev method performance and precision;

Small SMM method performance tweaks;

Small Window performance tweaks;

fixed unsafe Window's newest method;

Added anyhow support for core::Error;

added Donchian Channel indicator;

added TR method;

Several docs and readme fixes.

Source code(tar.gz)
Source code(zip)
v0.4.1(Jan 2, 2021)
fixed SMI Ergodic Indicator;

fixed Woodies CCI;

added indicators benchmarks;

fixed and improved SMM;

added Heikin Ashi coversion support;

added time-frame conversion support;

fixed Bollinger Bands;

Source code(tar.gz)
Source code(zip)
v0.4.0(Dec 12, 2020)
Refactored core Traits;

Refactored Sequence (it was a struct, now it's a trait);

Added dynamic dispatching support for indicators;

Added indicators docs;

Vidya moved from indicators to methods;

Added TSI method (True Strength Index);

Added Trend Strength Index indicator;

Changed Window indexes order;

Fixed Fisher Transform indicator;

Fixed serde rename support;

Fixed Commodity Channel Index indicator;

Fixed Woodies CCI indicator

Source code(tar.gz)
Source code(zip)
v0.2.1(Nov 5, 2020)
Fixed many typos

Docs update for Aroon indicator

Docs update for Average Directional Index indicator

Docs update for Awesome Oscillator indicator

Docs update for Bollinger Bands indicator

Docs update for Chaikin Money Flow indicator

Docs update for Chaikin Oscillator indicator

Docs update for Chande Kroll Stop indicator

fixed IndicatorResult values debug implementation

added clippy lints

Source code(tar.gz)
Source code(zip)
v0.2.0(Oct 4, 2020)
Redefined the way all the methods and indicators are creating. Now instead of simple "give me that thing or panic" you receive complete rust-way Result.

added MedianAbsDev method;

added MeanAbsDev method;

optimized StDev method;

fixed missed docs warning when period_type_# feature enabled;

SignalType forced to be always u8;

added optional unsafe perfomance blocks;

changed OHLC's TR-method template;

optimized Conv method;

modifed OHLC(V) validation;

optimized SMM method;

added over method on IndicatorInitializer;

optimized SWMA method;

small WMA method optimization;

fixed highest/lowest methods when value is NaN;

fixed SMM method when value is NaN;

added Detrendede Price Oscillator indicator.

Source code(tar.gz)
Source code(zip)
v0.1.7(Sep 27, 2020)
removed useless inline directives;

fixed value_type_f32 feature;

optimized methods Highest, Lowest, HighestLowestDelta;

removed unused field on SMM method;

benchmark updates;

added methods HighestIndex, LowestIndex;

action internal SignalType made the same as PeriodType;

removed useless Default implementations for methods;

added Aroon indicator;

added Chande Kroll Stop indicator;

added WSMA (Wilder's Smoothing Average) method;

modified AverageDirectionalIndex;

added Detrendede Price Oscillator indicator;

Source code(tar.gz)
Source code(zip)
v0.1.6(Sep 22, 2020)
Added benchmarks to all the methods;

Some docs fixes;

Added implementations for From<tuple of 4 or 5 floats> for Candle;

Methods Pivot* renamed to Reverse*

Source code(tar.gz)
Source code(zip)

Owner

Dmitry

GitHub

A fast, powerful, flexible and easy to use open source data analysis and manipulation tool written in Rust

fisher-rs fisher-rs is a Rust library that brings powerful data manipulation and analysis capabilities to Rust developers, inspired by the popular pan

5 Sep 6, 2023

Analysis of Canadian Federal Elections Data

Canadian Federal Elections election is a small Rust program for processing vote data from Canadian Federal Elections. After building, see election --h

2 Sep 26, 2021

Rust DataFrame library

Polars Blazingly fast DataFrames in Rust & Python Polars is a blazingly fast DataFrames library implemented in Rust. Its memory model uses Apache Arro

11.9k Jan 8, 2023

Rayon: A data parallelism library for Rust

Rayon Rayon is a data-parallelism library for Rust. It is extremely lightweight and makes it easy to convert a sequential computation into a parallel

7.8k Jan 8, 2023

sparse linear algebra library for rust

sprs, sparse matrices for Rust sprs implements some sparse matrix data structures and linear algebra algorithms in pure Rust. The API is a work in pro

311 Dec 18, 2022

ConnectorX - Fastest library to load data from DB to DataFrames in Rust and Python

ConnectorX enables you to load data from databases into Python in the fastest and most memory efficient way.

939 Jan 5, 2023

A bit vector with the Rust standard library's portable SIMD API

bitsvec A bit vector with the Rust standard library's portable SIMD API Usage Add bitsvec to Cargo.toml: bitsvec = "x.y.z" Write some code like this:

31 Dec 21, 2022

A rust library built to support building time-series based projection models

TimeSeries TimeSeries is a framework for building analytical models in Rust that have a time dimension. Inspiration The inspiration for writing this i

12 Dec 7, 2022

Polars is a blazingly fast DataFrames library implemented in Rust using Apache Arrow Columnar Format as memory model.

Polars Python Documentation | Rust Documentation | User Guide | Discord | StackOverflow Blazingly fast DataFrames in Rust, Python & Node.js Polars is

11.8k Jan 8, 2023

Library for scripting analyses against crates.io's database dumps

crates.io database dumps Library for scripting analyses against crates.io's database dumps. These database dumps contain all information exposed by th

52 Dec 14, 2022

A cross-platform library to retrieve performance statistics data.

A toolkit designed to be a foundation for applications to monitor their performance.

155 Nov 12, 2022

This library provides a data view for reading and writing data in a byte array.

Docs This library provides a data view for reading and writing data in a byte array. This library requires feature(generic_const_exprs) to be enabled.

2 Nov 2, 2022

Dataflow is a data processing library, primarily for machine learning

Dataflow Dataflow is a data processing library, primarily for machine learning. It provides efficient pipeline primitives to build a directed acyclic

9 Dec 19, 2022

Dataframe structure and operations in Rust

Utah Utah is a Rust crate backed by ndarray for type-conscious, tabular data manipulation with an expressive, functional interface. Note: This crate w

139 Sep 26, 2022

A Rust DataFrame implementation, built on Apache Arrow

Rust DataFrame A dataframe implementation in Rust, powered by Apache Arrow. What is a dataframe? A dataframe is a 2-dimensional tabular data structure

287 Nov 11, 2022

A Rust crate that reads and writes tfrecord files

tfrecord-rust The crate provides the functionality to serialize and deserialize TFRecord data format from TensorFlow. Features Provide both high level

22 Nov 3, 2022

Official Rust implementation of Apache Arrow

Native Rust implementation of Apache Arrow Welcome to the implementation of Arrow, the popular in-memory columnar format, in Rust. This part of the Ar

1.3k Jan 9, 2023

Fastest and safest Rust implementation of parquet. `unsafe` free. Integration-tested against pyarrow

Parquet2 This is a re-write of the official parquet crate with performance, parallelism and safety in mind. The five main differentiators in compariso

237 Jan 1, 2023

Apache TinkerPop from Rust via Rucaja (JNI)

Apache TinkerPop from Rust An example showing how to call Apache TinkerPop from Rust via Rucaja (JNI). This repository contains two directories: java

8 Sep 27, 2022