ta4j/ta4j

A Java library for technical analysis.

ta4j

Technical Analysis For Java

Ta4j is an open source Java library for technical analysis. It provides the basic components for creation, evaluation and execution of trading strategies.

---

Features

• 100% Pure Java - works on any Java Platform version 11 or later
• More than 130 technical indicators (Aroon, ATR, moving averages, parabolic SAR, RSI, etc.)
• A powerful engine for building custom trading strategies
• Utilities to run and compare strategies
• Minimal 3rd party dependencies
• Simple integration
• One more thing: it's MIT licensed

Maven configuration

Ta4j is available on Maven Central. You just have to add the following dependency in your pom.xml file.

<dependency>
  <groupId>org.ta4j</groupId>
  <artifactId>ta4j-core</artifactId>
  <version>0.15</version>
</dependency>

For snapshots, add the following repository to your pom.xml file.

<repository>
    <id>sonatype snapshots</id>
    <url>https://oss.sonatype.org/content/repositories/snapshots</url>
</repository>

The current snapshot version is 0.16-SNAPSHOT from the develop branch.

<dependency>
  <groupId>org.ta4j</groupId>
  <artifactId>ta4j-core</artifactId>
  <version>0.16-SNAPSHOT</version>
</dependency>

You can also download example code from the maven central repository by adding the following dependency to your pom.xml:

<dependency>
  <groupId>org.ta4j</groupId>
  <artifactId>ta4j-examples</artifactId>
  <version>0.15</version>
</dependency>

Getting Help

The wiki is the best place to start learning about ta4j. For more detailed questions, please use the issues tracker.

Contributing to ta4j

Here are some ways for you to contribute to ta4j:

• Take a look at the Roadmap items
• Fork this repository and submit pull requests.
• Take a look at How to contribute

See also: the contribution policy and Code of Conduct

   

ta4j's Issues

Is there any way to reset indicator?

I tried to use TrailingStopLossIndicator for testing my strategy. I found out, that it's not useful in real world.
After trade is closed, indicator value is not reset, so it can't be used as valid exit rule for next trade.
How can I avoid this? Is there any way to reset indicator or clean its cache, when trade is closed?
Thanks

release 0.10

(initially accidentially created) Reused for finalizing the release 0.10

RAVI-Indicator does not use Abs

ta4j-ravi does not use "abs" in its ravi calculation.

According to https://www.tradesignalonline.com/de/lexicon/view.aspx?id=RAVI+Indicator+(RAVI)&olang=de, the formula should be Abs(shortMa-longMa)/longMa*100).

However, it seems there are two versions of ravi, one with ABS and without ABS (look at https://www.tradingview.com/ ->chart->search indicators->3 x ravi->view code).

Please check out, which version is the right one.

Donchian Channel Indicator

Donchian Channel Indicator.

http://www.investopedia.com/terms/d/donchianchannels.asp

Indicator package: "experimental"

Adding new indicators to this repository will increase its value on the one hand, on the other hand it will be more difficult to maintenance them all. Especially for not so common indicators and indicators for that there are no scientifically proved (web) ressources.

I would suggest to create a new package named experimental for this kind of indicators. So we can guarantee a wide range of different indicators and a good maintenance of well-established indicators at the same time.

Merge develop into master and make maven release

I want to merge the develop branch with #49 and #52 into master and want to make a 0.10-SNAPSHOT maven release next monday 23 October

Fix snapshot build

Currently only available snapshot dated 20170907. Please fix snapshot build creation.

Improve performance and API with Decimals for very big and very small values

Right now we have a custom implemented Decimal class. This class solves issues like:

• MathContext
• decimal precision

Sadly it still leaves out some other issues:

• performance (dpalic I would really like to have some use cases in unit tests to have a better decision if any performance tuning is really needed with nowadays CPUs)
• handling of international currencies is right now missing (e.g. you trade in EUR but you work on US-market, this is our current API not aware of)
• using standard solutions (e.g. Joda money which very probably will be replaced with JSR-354 Money and Currency and will be probably integrated in JDK10)
• plain BigDecimal

Personally I prefer using standards. Previously I used Joda Time, and the integration into the JDK made many things much easier. So I assume also that the integration of Money and Currency JSR will also make many things pretty simple. Here a short intro http://www.baeldung.com/java-money-and-currency

Also JSR-354 has already considerations about the tradeoff of performance and precision. E.g. the user of our API could himself decide which precision he/she wants to use by using either Money (BigDecimal based) or FastMoney (long based) implementation.
Since it will make its way into the JDK it will soon be obsolete as a additional dependency right it is now as the reference implementation.

Good readings for the decision:
mdeverdelhan/ta4j-origins#19, mdeverdelhan/ta4j-origins#28, mdeverdelhan/ta4j-origins#4 (comment)

Also related to this are: #24 and #21

The rework for this Decimal issue will take some time, therefore I would like to move it to version 0.11
What do you think about the proposed Java Money and Currency and about the move to release 0.11?

Little changes in Criterions and order creation needed

Regarding: mdeverdelhan/ta4j-origins#194 (comment)

Ccob:

After further investigation there appears to be many of the Criterion classes all using the close price of the index the trade occurred instead of looking at the price of the order within the entry and exit trade. So for forward testing I'm guessing a whole set needs to be made or they need to be adjusted to look at close price or actual order price?

In my opinion it does not make much difference at the moment. But it needs to be fixed for the sake of accuracy

Release 0.10 and 0.11-SNAPSHOT available on maven central

I am happy to inform you that the next release version of ta4j is available on maven central as of now.

<dependency>
  <groupId>org.ta4j</groupId>
  <artifactId>ta4j-core</artifactId>
  <version>0.10</version>
</dependency>

The new 0.11-SNAPSHOT will represent the state of our develop branch and will be periodically updated:

<dependency>
  <groupId>org.ta4j</groupId>
  <artifactId>ta4j-core</artifactId>
  <version>0.11-SNAPSHOT</version>
</dependency>

It is also the first release under the new direction of the ta4j organization. If you have questions or suggestions please don't hesitate to ask. Furthermore don't hesitate to contribute to this repository.

Changelog:

0.10 (2017-10-31)

VERY Important notes!!!!

• With the release 0.10 we have changed the previous java package definition to org.ta4j or to be more specific to org.ta4j.core (the new organisation). You have to reorganize all your refernces to the new packages!
  In eclipse you can do this easily by selecting your sources and run "Organize imports"
  
• Changed ownership of the ta4j repository: from mdeverdelhan/ta4j (stopped the maintenance) to ta4j/ta4j (new organization)

Fixed

• ParabolicSarIndicator: wrong calculation fixed
• KAMAIndicator: stack overflow bug fixed
• AroonUpIndicator and AroonDownIndicator: wrong calculations fixed and can handle NaN values now

Changed

• BREAKING: new package structure change eu.verdelhan.ta4j to org.ta4j.ta4j-core
• new package adx: new location of AverageDirectionalMovementIndicator and DMI+/DMI-
• Ownership of the ta4j repository: from mdeverdelhan/ta4j (stopped the maintenance) to ta4j/ta4j (new organization)
• ParabolicSarIndicator: old constructor removed (there was no need for time frame parameter after big fix). Three new constructors for default and custom parameters.
• HighestValueIndicator and LowestValueIndicator: ignore also NaN values if they are at the current index

Added

• AroonOscillatorIndicator: New indicator based on AroonUp/DownIndicator
• AroonUpIndicator and AroonDownIndicator: New constructor with parameter for custom indicator for min price and max price calculation
• DirectionalMovementPlusIndicator: New indicator for Directional Movement System (DMI+)
• DirectionalMovementDownIndicator: New indicator for Directional Movement System (DMI-)
• InSlopeRule: New Rule that is satisfied if the slope of two indicators are within a boundary
• IsEqualRule: New Rule that is satisfied if two indicators are equal
• AroonUpIndicator and AroonDownIndicator: New constructor with parameter for custom indicator for min price and max price calculation
• Pivot Point Indicators Package: New package with Indicators for calculating standard, Fibonacci and DeMark pivot points and reversals
  • PivotPointIndicator: New indicator for calculating the standard pivot point
    • StandardReversalIndicator: New indicator for calculating the standard reversals (R3,R2,R1,S1,S2,S3)
    • FibonacciReversalIndicator: New indicator for calculating the Fibonacci reversals (R3,R2,R1,S1,S2,S3)
  • DeMarkPivotPointIndicator: New indicator for calculating the DeMark pivot point
    • DeMarkReversalIndicator: new indicator for calculating the DeMark resistance and the DeMark support
• IsFallingRule: New Rule that is satisfied if indicator strictly decreases within the timeFrame.
• IsRisingRule: New Rule that is satisfied if indicator strictly increases within the timeFrame.
• IsLowestRule: New Rule that is satisfied if indicator is the lowest within the timeFrame.
• IsHighestRule: New Rule that is satisfied if indicator is the highest within the timeFrame.

KAMAIndicator causes StackOverflowError when a value has fallen out of the cache at a deep index

Reading the code for KAMAIndicator and CachedIndicator it seems like RecursiveCachedIndicator does exactly what is needed: Iteratively calculate the value instead of recursively.

Lack of performance

Hello guys,

I'm watching this project since few months. It seems to be good (tests, docs, etc.). But.. this framework has a lack of performance.

Here is an example:

`
@test
public void testIfQuickEnough() {
long start = System.currentTimeMillis();
int initialCapacity = 54 * 5 * 24 * 60 * 3;

    double[] input = new double[initialCapacity];
    for (int i = 0; i < input.length; i++) {
        input[i] = 5d;
    }

    /**
     * just adding close price instead timestamp with close price:
     *   AnotherMockTimeSeries: ticks.add(new MockTick(data[i]));
         //MockTimeSeries: ticks.add(new MockTick(ZonedDateTime.now().with(ChronoField.MILLI_OF_SECOND, i), data[i]));
     */
    TimeSeries timeSeries = new AnotherMockTimeSeries(input);

    Decimal average = null;
    for (int h = 2; h < 3; h++) {
        SMAIndicator quoteSMA = new SMAIndicator(new ClosePriceIndicator(timeSeries), h);
        for (int i = 0; i < timeSeries.getTickCount(); i++) {
            average = quoteSMA.getValue(i);
        }
    }
    long end = System.currentTimeMillis();
    System.out.println("average = " + average);

    System.out.println("Time elapsed: " + (end - start));
}

`

Output:
average = 5
Time elapsed: 15811

if you use int h = 2; h < 200 instead h < 3:
... stopped java process... too slow.... 200x15811~3 000 000 ms ~50 min.

... VERY SLOW...

Used Macbook Pro Mid 2014.
Looks like this framework is only for realtime trading :)

For comparison:

Are there any roadmap issues to increase performance?

evaluate to include a 3rd math-lib

When I have this:

SimpleLinearRegressionIndicator reg = new SimpleLinearRegressionIndicator(close, 7);

and it outputs this for index n:

closeprice(n): "27.82"
simpleLinearReg(n): "27.7761"

does this mean the following ?:

For index n the value of n+1 is probably around "27.7761" (= prediction value).

Does "SimpleLinearRegressionIndicator" outputs the "predictionValue" for the next comming index?

Is this something like this from commons-math "SimpleLinearRegression":
http://commons.apache.org/proper/commons-math/userguide/stat.html

System.out.println(regression.predict(1.5d))
// displays predicted y value for x = 1.5

add "normalized" and "relative" version of ATR

Actually ATR (Average True Range) returns only absolute values, which makes it difficult to compare against other issues.

• Want to add the normalised version of ATR (=NATR)
• Want to add the relative version of ATR (ARTR), which consists of the relative version of TR (RTR).

Formula:

• http://vtadwiki.vtad.de/index.php/Ma%C3%9Fe_f%C3%BCr_Beweglichkeit

Join Chat

@dpalic Some discussion is happening in chat here: https://riot.im/app/#/room/#ta4j:matrix.org

It would be great if you could join for more impromptu discussion 👍 🙂 (Feel free to close the issue afterwards.)

add "KalmanFilterIndicator"

Please add "KalmanFilterIndicator.java":

• http://edmond.mires.co/GES816/22-Predicting%20Market%20Data%20Using%20The%20Kalman%20Filter(1).pdf
• http://www.bzarg.com/p/how-a-kalman-filter-works-in-pictures/
• https://www.quantopian.com/lectures/kalman-filters#notebook
• https://www.tradingview.com/script/0qwdAQxS-Kalman-Filter-Moving-Average/

How to change your remote url to the successor

You can clone this new one:
git clone https://github.com/ta4j/ta4j.git

or set new remote and merge:

git remote set-url origin https://github.com/ta4j/ta4j.git
git fetch
git merge

Introduce "Wilders Moving Average"

Actually, ta4j have a few indicators from w.wilders:

• Average True Range (ATR)
• Directional Movement System (ADX/DI+/DI-)
• Relative Strength Index (RSI)

ta4j uses a common moving average (SMA?) for these indicators. However, to be in accordance with the origin indicators, ta4j should normally use the "Wilder Moving Average" (http://www.macroption.com/atr-calculation/, http://www.macroption.com/atr-period/).

So please introduce a new Moving Average Indicator "Wilder Moving Average" and make use of it within the wilders indicators (ATR, ADX, RSI, ..) of ta4j.

(Maybe these indicators could have an optional constructor to put the type of moving average (SMA, EMA, WMA) into these indicators. For example, there are variations of ADX which uses the EMA internally.)

The indicators should be at least implemented with the original formula and normally this should be the default. However, I would let SMA for these indicators to be the default and would provide new constructors to put another moving average instead of the default.

Renko Charts

We can add new renko charts for new analysis
http://stockcharts.com/school/doku.php?id=chart_school:chart_analysis:renko

release 1.0

(initially accidentially created) reuse for tracking the todo of release 1.0

regarding Decimal and implication of using double with rounding

Hi, I can see that Decimal is an essential class for maintaining precision across different calculations, however not only it creates lots of garbage and hits the performance but also makes the code quite unreadable (all 3 of these are quite important to me).

Now i've been using double with rounding for a while and i never saw critical difference in outcome of calculations. Is there something i'm not aware of with this lib? maybe some indicators are doing something where double is significantly inaccurate and keeps amplifying itself?

Handle Decimal.NaN values (especially in Aroon Up/Down indicator)

Regarding an old issue: mdeverdelhan/ta4j-origins#187 i think there is a important question still unanswered.

• How to handle NaN values?

In my opinion an indicator should return NaN if the input values are NaN.

For example the AroonUpIndicator and AroonDownIndicator returns zero instead of NaN. But zero is a admissible value for this indicator and would be interpreted totally different as a "Not a number" information.

moving all packages to org.ta4j

I think we should move also all packages to org.ta4j to make the new library also findable on the long run via the webpage.
Also this makes the statement clearer, that the lib is living independently of a person.
I would suggest to switch these with version 0.11. What do you think?

Establish a build and release process

right now the old build and release process looks very manual. We need to define, what we want to do in the future.

So my view:
I would stick to maven, even if I also see that gradle has done a great job, but many persons know maven and this makes it also easier for us to get rid of any "build usage issues".

regarding release process. I would like to have at least a branch per major release. Every released version should have at least a tagged/labled version in the repository too, so it is easy to recreate any issues from the tags and branches.

Of course the build and release process needs to be documented in the wiki as well, for:

• contributors
• users (how to build/rebuild)

New Double Top/Double Bottom indicator should be added.

I think doubletop/bottom indicator should be added. It gives a lot of positive or negative signal.

This can be taken as future enhancement.

mdeverdelhan/ta4j-origins#193

Values of ADX/DMI+/DMI- incorrect?

I compared the values of ADX/DMI+/DMI- with 2 other chart-software and it seems either of one returns wrong values. So please check out, if ta4j really returns the right values.

For example,

ta4j returns this (I rounded the returned values):

AverageDirectionalMovementIndicator=1.4131
AverageDirectionalMovementUpIndicator=0.1937
AverageDirectionalMovementDownIndicator=0.1808
DirectionalMovementIndicator timeFrame: 12=3.4463
DirectionalMovementUpIndicator=0.04
DirectionalMovementDownIndicator=0.0

But the Chart-Software with the same timeframe on the same "tick" returns these values:

ADX=35,126
PDI=13,323
MDI=36,644

And other ticks have also completly different values. So I am in doubt, which returns the right values. Please double-check this out.

Using milestones for having a proper tracking of next changelogs?

I have just created the milestone 0.10, hope we can use the milestones for a proper tracking what will be part of the next release.
will also create 0.11 for the next to the next release.
a 1.0 for the next major release
and a backlog for any release in the future

Backlog from previous repository

Here are some changes which may be put in the backlog. I let you judge of the relevancy of each point:

• Improve the Decimal class (performance & API) or replace it by a better decimal number from elsewhere. See: mdeverdelhan/ta4j-origins#19, mdeverdelhan/ta4j-origins#28, mdeverdelhan/ta4j-origins#4 (comment)

• Generalize the cache system (today it only concerns the indicator, tomorrow it might be extended to time series, trading records, etc.) and provide an abstraction layer to let the user choose which caching technology fits its needs. See: mdeverdelhan/ta4j-origins#20, mdeverdelhan/ta4j-origins#25, mdeverdelhan/ta4j-origins#111, mdeverdelhan/ta4j-origins#138, mdeverdelhan/ta4j-origins#9 (comment)

• Keep the last tick values uncached. See: mdeverdelhan/ta4j-origins#72

• Completely remove the possibility to create "constrained" time series (now we can create a constrained time series using this constructor). They were used only for backtesting but they are not relevant anymore since I added start/end indexes to the run(...) methods.

• Remove the maximum tick count concept of the TimeSeries interface. It has to be only part of an implementation of TimeSeries (BaseTimeSeries for instance) but not of all of them (for example : if your time series is backed by a database you should not have to limit the number of your ticks).

Marc

RSI values differ from other chart-data

I have this:

ClosePriceIndicator price = new ClosePriceIndicator(series);
RSIIndicator indicator = new RSIIndicator(price, 9);

The calculated values differ from the values from other chart-providers (same timeframe, closePrice and data).

I compared the values with http://www.teletrader.com/ and https://www.tradingview.com/. Both show different values in compare to ta4j.

For example:

..
ta4j shows rsi=50.0, while the other shows on the same tick/bar rsi=53,316.
ta4j shows rsi=46.1538, while the other shows on the same tick/bar rsi=52,826.
..

The ta4j-rsi-values on each tick are all different in compare to the other providers.

Please check out.

Schaff Trend Cycle

I want to add Schaff Trend Cycle Indicator:

• http://www.investopedia.com/articles/forex/10/schaff-trend-cycle-indicator.asp
• https://www.technicalindicators.net/indicators-technical-analysis/169-stc-schaff-trend-cycle
• https://www.tradingview.com/script/dbxXeuw2-Indicator-Schaff-Trend-Cycle-STC/
• http://www.binarytribune.com/forex-trading-indicators/schaff-trend-cycle

TradingRecord tracking an order that has not been filled?

Sorry if this is an obvious question, I have been reviewing how ta4j works lately and trying some coding and am a bit confused by something. It seems that you use the TradingRecord to enter a trade and then it will enter it right away. The problem is that, when using an API for a trading platform, the actual order may sit unfilled (open) for some time, as the price that the order was put in for may be lower than the current trading price (as tick data is usually out of date by some amount of time). Is there a way to account for this within a trading record so that it shows that an order has been placed but that a position is not actually currently held in that asset?

Pivot points implementation

Will be nice to see Pivot points implementation in ta4j.

enhance "JustOnceRule"

JustOnceRule should assert that a rule is fired only one time and then never again. It should behave like the rule for "CrossedUp/CrossedDownRule" (which only fires one time as soon as the rule is satisfied and then never again).

However, I cannot put a rule within JustOnceRule, which I want to fire only one time. So for example, this is actually not possible:

// Fires only one time as soon as the actual value is higher than its two previous values.
// Even if the "next value" is also higher than its 2 previous values, 
// the rule is no more fired, because of JustOnceRule.
new JustOnceRule(isRisingRule(2));

Would be nice to enhance the "JustOnceRule" to made the above example possible.

TradingRecord Requirements / Rewrite

Hi all, I think most of you probably agree that the current TradingRecord is somewhat limited and could be improved. I wanted to open this issue so we can identify current shortcomings and gather requirements for a potentially new/alternative implementation.

Shortcomings

• It is not possible to have multiple open orders.
• Analysis over the entire range of a TimeSeries isn't intended/supported easily.

Wishlist

1. Be able to have multiple open positions (i.e. entry trades w/o corresponding exit).
2. Provide metrics for a given TimeSeries/TradingRecord combination at every tick in the timeseries. This somewhat ties into the analysis.criteria package. As far as I understand it these are currently intended for analysis of finished TimeSeries only. For graphing/visual inspection of strategies it would be nice to turn these things into something similar to Indicator so that the value can be easily extracted for any point in the TimeSeries.
3. Provide an interface for Trade, if possible turn TradingRecord into a plain list of Trades.
4. Maybe integrate fees into Trade to end up with more realistic analysis.

Non-Goals

• Anything related to execution of Trades. For now it should be the end-users task to deal with slippage, actual execution prices etc.

---

What would you like to see added/changed about the current TradingRecord implementation? Or maybe there is something you think it should not be concerned with?

formula of "randomWalkIndex" correct?

I compared the computed values of ta4j and it differs from that of tradingView. Please check out.

According to tradingView or other sources (http://www.fmlabs.com/reference/default.htm?url=RWI.htm, https://www.technicalindicators.net/indicators-technical-analysis/168-rwi-random-walk-index), the randomWalkIndexHigh/Low is calculated by returning the maximum computed value of all the values from the formula within a timeFrame:

However, I dont see any recursive call or loop within the actual ta4j-formula, it only computes the value of the actual index without comparing this to all the other computed rwi-values within the timeFrame.

According to tradingView, the formula must have something like a loop to compare all other calculated rwi-values and return the highest of that value for the actual index:

// loop through the ticks within the timeFrame
for i = minp to maxp 
    // calculate each rwi and return the highest one
    rwihi:=i==minp?(high-low[i])/(atr(i)*sqrt(i)):max((high-low[i])/(atr(i)*sqrt(i)),rwihi)
    rwilo:=i==minp?(high[i]-low)/(atr(i)*sqrt(i)):max((high[i]-low)/(atr(i)*sqrt(i)),rwilo)
rwi=rwihi-rwilo 

HighestValueIndicator has one bug

@Override
protected Decimal calculate(int index) {
    if (indicator.getValue(index).isNaN() && timeFrame != 1)
        **return new LowestValueIndicator(indicator,timeFrame-1).getValue(index-1);**
    int end = Math.max(0, index - timeFrame + 1);
    Decimal highest = indicator.getValue(index);
    for (int i = index - 1; i >= end; i--) {
        if (highest.isLessThan(indicator.getValue(i))) {
            highest = indicator.getValue(i);
        }
    }
    return highest;
}

I think that 4th row should be "new HighestValueIndicator(......)"

Create new Javadoc for next release

We have to create a new java doc and maintain it. The current is from eu.vanderhan link
I would do so but i dont no how to start.

add new Indicator: Chaikin Oscillator

I want to add: "Chaikin Oscillator":

http://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:chaikin_oscillator

Laguerre Indicator

I want to add Laguerre Indicator.

Parabolic SAR is incorrect

Please check Parabolic SAR calculations. Indicator results looks incorrect. Comparation with MT4 SAR fails with a bang.

Support for Leveraged Trading Orders

Greetings. I have to say that the development of the library has really been boosted since moving to ta4j.org. Thank you devs, for all of your hard and outstanding work. I think it would be very useful if the library supported leveraged trading. Derivatives are an important tool in hedging risk for many markets. It would be very useful if the library supported derivatives by adding FuturesTrade, a mechanism to support contracts. As well as support for calculation of PL via ProfitLossCriterion.

put "MeanDeviationIndicator" to package "indicators.statistics"

Please move "MeanDeviationIndicator.java" (actually in indicators.helpers) to package "indicators.statistics", whitin this already exist "StandardDeviationIndicator.java" and it fits better there.

SuperTrend Indicator

Super Trend indicator can be a good addition to this library.

http://www.freebsensetips.com/blog/detail/7/What-is-supertrend-indicator-its-calculation

What you guys suggest. I can start working on this with the formula provided in the link above.

BASIC UPPERBAND = (HIGH + LOW) / 2 + Multiplier * ATR
BASIC LOWERBAND = (HIGH + LOW) / 2 - Multiplier * ATR
FINAL UPPERBAND = IF( (Current BASICUPPERBAND < Previous FINAL UPPERBAND) and (Previous Close > Previous FINAL UPPERBAND)) THEN (Current BASIC UPPERBAND) ELSE Previous FINALUPPERBAND)
FINAL LOWERBAND = IF( (Current BASIC LOWERBAND > Previous FINAL LOWERBAND) and (Previous Close < Previous FINAL LOWERBAND)) THEN (Current BASIC LOWERBAND) ELSE Previous FINAL LOWERBAND)
SUPERTREND = IF(Current Close <= Current FINAL UPPERBAND ) THEN Current FINAL UPPERBAND ELSE Current FINAL LOWERBAND

Kindly suggest

Corrected Moving Average

I want to add "Corrected Moving Average"-Indicator:

Formula:

• https://www.prorealcode.com/prorealtime-indicators/corrected-moving-average/
• https://www.mql5.com/en/code/923
• https://www.mql5.com/en/code/viewcode/923/129022/corrected_average.mq5

difference of Decimal("0.67") vs Decimal(0.67)

Is there a (rounding) difference of Decimal("0.33") and Decimal(0.33) or Decimal.valueOf("-0.999") and Decimal.valueOf(-0.999)? String will be converted directly to (Big)Decimal while the other uses double and convert it to (Big)Decimal. Any difference in precision?

InverseFisherIndicator needed

ta4j has the "FisherIndicator.java", however, would be nice to implement the "InverseFisherIndicator.java" and put it as a new indicator into ta4j-indicator.

I did not find a exp-method within the Decimal-class so I have to use that of java.math.exp and convert back and forth from double to Decimal. Maybe this is not optimal (rounding issues?).

Feature request - support for bars and ticks.

Hello

It would be great if this product supported ticks, in their traditional sense, and bars.

A tick can be thought of as a moment in time - and in the case of FX - is a price change in the currency pair, whereas a bar is a timespan, typically of 1m, 5m, 15m, 30... 1h, 4h, 8h, 1d etc.

Retroactively tag releases in Git

Previous releases should be tagged in this repository for future reference.

Set up continuous integration

The original project had Travis integration set up, which is useful to have on PRs (for required statuses) and just generally for quality control purposes. Since the old Travis config is still in the repo, it should just be a matter of flipping a switch on https://travis-ci.org/?

Extract interface of BigDecimal to provide calculations with other data types

Issue #75 shows that there is also a big demand for increasing the performance of ta4j. It also shows that with BigDecimal the potential of increasing performance is very limited.

To satisfy the demand for performance and precision, I think it will be a good solution to create several classes like FastDecimal and ExactDecimal which implement an interface of the current Decimal class.

• FastDecimal will have a double as delegate and will be standard (?)

• ExactDecimal will have a BigDecimal as delegate and can be used as parameter by creating a Tick/TimeSeries

With a Decimal interface it will be also possible to have further data types for calculation. E.g. if someone needs only integers he can do so with a custom class that implement the interface.