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.

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?

Hi I want to use this library for Android App. But this library uses ZonedDateTime class which is supported only in Oreo (API 26) based Android devices. You can confirm it from below URL : https://developer.android.com/reference/java/time/ZonedDateTime.html So my question is how I can use this library function for older API based devices. Oreo is not available on almost 80% of total Android devices as of now.

Fixes #186 .

Changes proposed in this pull request:

• Fixed requirements as mentioned in #186

• Use Num in AnalysisCriterion

• But keep Criterion parameters as primitives

• [x] added an entry to the unreleased section of CHANGES.md

Notes:

• There was 1 test, namely NumberOfTradesTest::calculateWithOneTrade that passed the TimeSeries as null, but I changed this to some series, otherwise series.numOf() would give a null pointer exception,
• LinearTransactionCostCriterionTest is giving different results, it's not consistent anymore with external data, nor the test data, it looks to me like a precision diff between double/Num. Please check it. I think we should change the xls/tests to reflect the new outcome. (Because of this the tests are currently failing)
• Don't merge yet, until LinearTransactionCostCriterion(Test) is fixed :)

Hello,

I am trying to build Stochastic RSI indicator. In StochasticRSI there are K, D, Rsi and Stochastic parameters.

I want build StochRSI(14, 9, 3, 3):

• RSI = 14
• Stoch = 9
• K = 3
• D = 3

StochasticOscillatorKIndicator k = new StochasticOscillatorKIndicator(series, 3);
StochasticOscillatorDIndicator d = new StochasticOscillatorDIndicator(k);
RSIIndicator rsi = new RSIIndicator(d, 14); // I think it's wrong
StochasticRSIIndicator stochRsi = new StochasticRSIIndicator(rsi, 9);

Result of the stochRsi calculation is totally wrong when compare to result with exchange's graphs. How can I construct StochasticRSIIndicator properly?

We know a trade is not an order. However, ta4j uses Trade and Order in a confusing way.

• in ta4j, a trade is a pair of entry and exit order, however, an order is not a trade and even two orders are not a trade.

Maybe we should consider to rename the followings: -rename Order.class to Trade.class -rename Trade.classto TradePair.class (or other better names?)

Or?

Fixes:

Fixed numOf() inside calculate() for ADX related indicators using existing final instance field pattern.

Changes proposed in this pull request:

Added constructors so ADX and related objects can be created and used with substantially fewer "child" indicators. Reduces the number of array lists (27 to 12, by my count) if ADX and +/-DI are used together in a strategy. Might improve processing a little. These constructors will create 1 instance of each object, rather than separate objects that end up calculating and caching the same numbers.

Moved DX to adx package. The ADX constructor is the only place DX is referenced.

+DM and -DM were also moved to adx package, only being referenced by +/-DI respectively. There is a small chance these 3 moves will break import statements in 0.13 user code, but it seems unlikely that people would instantiate these objects independently.

Added getBarCount() and toString to ATR.

Fixes #287 Implemented a way to find the best result for multiple strategies by submitting a range of numbers while backtesting

• [x] added an entry to the unreleased section of CHANGES.md

I have a timeseries s and want to create a new subseries s1 from it. s has 20 ticks with index 0 to 19. s1 should be a subseries from s containing only the last 10 ticks from the actual index backwards.

TimeSeries s1 = new BaseTimeSeries(s, index - 10, index);

However, after printing "s1.getTickData()" and "series.getTickData()", both timeseries has the same ticks included. s1 normally should have only 10 ticks included and not 20. What is wrong?

Changes proposed in this pull request:

• ConvergenceDivergenceIndicator.java

• ChaikinOscillator.java

• add parameter "name" in (Base)Strategy.java

• [x] added an entry to the unreleased section of CHANGES.md

Fixes #198 .

Changes proposed in this pull request:

• PrecisionNum introduction

• add Num numOf(String, int)

• more tests in NumTest

• add TestUtils.assertIndicatorEquals() with delta for inexact matching

• logging

• rename DoubleNumVsBigDecimalNum to CompareNumTypes, add error percentage reporting

• [ ] added an entry to the unreleased section of CHANGES.md

Fixes #926

Changes proposed in this pull request:

• Fixed ExpectancyCriterion calculation

• Updated unit tests

• updated changelog

• [X] added an entry with related ticket number(s) to the unreleased section of CHANGES.md

I have checked existing issues and wiki

• [X] I could not find similar issues
• [X] I could not find a solution in the wiki or faq section

Describe the bug The Expectancy calculation is incorrect. In it's current form, it can only ever be negative or zero.

To Reproduce Steps to reproduce the behavior:

1. Run ExpectancyCriterionTest.calculateOnlyWithProfitPositions(). The trading record has 100% win rate with positive overall profit yet the expectancy score is 0.

Expected behavior In the above unit test the expectancy should be 1.0

Additional context The expectancy formula linked in the comments (https://www.straightforex.com/advanced-forex-course/money-management/two-important-things-to-be-considered/) is incorrect, which is likely the root cause of this bug.

Create Fork ta4j

Fixes #.

Changes proposed in this pull request:

• [ ] added an entry with related ticket number(s) to the unreleased section of CHANGES.md

I have checked existing issues and wiki

• [x] I could not find similar issues
• [ ] I could not find a solution in the wiki or faq section

Is it possible to add the Supertrend indicator? I found a beginning of the solution in https://stackoverflow.com/questions/68063996/java-implementation-of-supertrend

Thank you

I have checked existing issues and wiki

• [X] I could not find similar issues
• [X] I could not find a solution in the wiki or faq section

If possible provide a minimal working example!

ta4j is the most complete ta library I found as far as indicators are concerned. Awesome job !

I was considering using it until I met the strategy implementation. This one brought a lot of questions to me about entry and exit rules.

Actually, the exist rule was what really buged me.

When trading, the exist rule is usally a mix between a stop loss and a take profit orders which are placed according to a predifined risk ratio.

Let's say I'm willing to have a 1:1 risk ratio. Which means I'll risk as much as I'm targeting to profit. To defined my profit target, I'll first set my stop loss. There are several ways to do so, but let's say the PSAR will be used. When an entry signal is detected, my exist rule should be both:

• a stop loss order at the PSAR value
• a take profit order at the current price + (current price - PSAR value)

ta4j makes possible to implement such a rule. But unfortunately, it won't work on a trading bot.

Let's say the bot is trading on the 1h time frame. The exist rule will be evaluated at the next received bar (= the next hour). The exit decision will be taken too late risking way more than the risk management strategy allows. The only way to comply with the risk management is to place orders which will be executed directly by the broker.

What I've considered was to ignore the exist rule (or use it for short entry signals) and create orders I'll push to the broker according to the entry signal. However, it makes the strategy unable to be backtested as it does not take into account the possibility to have stop loss order.

I considered using the exist rule to simulate the stop loss order on backtesting. But doing so would result in having at least 2 implementations of the same strategy for :

• live trading which will only detect entry signals
• backtesting which will detect entry signals as the live trading does but with an hack on exist rule to simulate stop loss and take profit executions (making the use of exit rule for short position impossible)

What I would have expected would be to have one single strategy and being able to use it in both backtesting and live trading contexts.

My question is then : how do you manage stop loss (and take profit) within a single strategy ?

Actually, the user must know which value to set for Strategy#unstablePeriod. However, this is not user friendly, because the user is not always aware of the technical details of the indicators (e.g. SARIndicator needs at least 200 bars before the values can be calculated correctly, other indicators needs at least its barCount, etc.). How should the user know such technical issues beforehand?

It's better to have this implemented and documented within each Indicator. The implementor of the indicator must provide this information within the source code of the indicator. Thus, I created https://github.com/ta4j/ta4j/pull/918 (which is a work in progress, as I do not know the right unstablePeriod for each indicator). However, we should be obliged to implement and improve the unstablePeriod within the indicator.

After that, we can consider to implement some ideas from:

• https://github.com/ta4j/ta4j/issues/101#issuecomment-346143435
• https://github.com/ta4j/ta4j/issues/101#issue-275653040
• https://github.com/ta4j/ta4j/issues/526#issue-574805289

@team172011, I think your suggestions would be the next step:

It is also necessary to determine the behavior of the Indicator.calculates(index) function regarding this issue. At the moment it is inconsistent. If it is not possible to calculate a value (e.g. because of index < size of timeFrame) some indicators return NaN, others zero while others modify timeFrame (make it smaller). I would suggest to return NaN whenever it is not possible to calculate the correct value

We must not, under any circumstances, give users false calculated values; calculated indicator values ​​during the "warm-up" of the indicators are inherently wrong and should never be passed to the user, those values must be either NaN or null.

I think, we cannot delegate the value of indicator.getUnstablePeriod() from a Rule to Strategy.unstablePeriod(as suggested in https://github.com/ta4j/ta4j/issues/147#issuecomment-366767366) - this is not possible as indicators can be wrapped by other indicators and the Rule only has access to the outermost indicator.getUnstablePeriod() which could be less than any innermost indicator.getUnstablePeriod().

Thus, the only solution would be to return NaN or null for Indicator.calculate() within the Indicator#getUnstablePeriod() to imitate something like Strategy#unstablePeriod.