Java Decimal.plus方法代码示例

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
@Override
protected Decimal calculate(int index) {
    Decimal sum1 = Decimal.ZERO;
    Decimal sum2 = Decimal.ZERO;
    for (int i = Math.max(0, index - timeFrame + 1); i <= index; i++) {
        Decimal close = indicator.getValue(i);
        Decimal prevClose = previousPriceIndicator.getValue(i);

        Decimal d = close.minus(prevClose);
        if (d.compareTo(Decimal.ZERO) >= 0) {
            sum1 = sum1.plus(d);
        } else {
            sum2 = sum2.plus(d.multipliedBy(NEGATIVE_ONE));
        }
    }
    return sum1.minus(sum2).dividedBy(sum1.plus(sum2)).multipliedBy
            (Decimal.HUNDRED);
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
@Override
protected Decimal calculate(int index) {
    if (index == 0) {
        return indicator.getValue(0);
    }
    Decimal value = Decimal.ZERO;
    if(index - timeFrame < 0) {
        
        for(int i = index + 1; i > 0; i--) {
            value = value.plus(Decimal.valueOf(i).multipliedBy(indicator.getValue(i-1)));
        }
        return value.dividedBy(Decimal.valueOf(((index + 1) * (index + 2)) / 2));
    }
    
    int actualIndex = index;
    for(int i = timeFrame; i > 0; i--) {
        value = value.plus(Decimal.valueOf(i).multipliedBy(indicator.getValue(actualIndex)));
        actualIndex--;
    }
    return value.dividedBy(Decimal.valueOf((timeFrame * (timeFrame + 1)) / 2));
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
@Override
protected Decimal calculate(int index) {
    if (index == 0) {
        return Decimal.THOUSAND;
    }
    
    Tick currentTick = series.getTick(index);
    Tick previousTick = series.getTick(index - 1);
    Decimal previousValue = getValue(index - 1);
    
    if (currentTick.getVolume().isLessThan(previousTick.getVolume())) {
        Decimal currentPrice = currentTick.getClosePrice();
        Decimal previousPrice = previousTick.getClosePrice();
        Decimal priceChangeRatio = currentPrice.minus(previousPrice).dividedBy(previousPrice);
        return previousValue.plus(priceChangeRatio.multipliedBy(previousValue));
    }
    return previousValue;
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
@Override
protected Decimal calculate(int index) {
    if (index == 0) {
        return Decimal.THOUSAND;
    }
    
    Tick currentTick = series.getTick(index);
    Tick previousTick = series.getTick(index - 1);
    Decimal previousValue = getValue(index - 1);
    
    if (currentTick.getVolume().isGreaterThan(previousTick.getVolume())) {
        Decimal currentPrice = currentTick.getClosePrice();
        Decimal previousPrice = previousTick.getClosePrice();
        Decimal priceChangeRatio = currentPrice.minus(previousPrice).dividedBy(previousPrice);
        return previousValue.plus(priceChangeRatio.multipliedBy(previousValue));
    }
    return previousValue;
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
/**
 * Gets the TotalReturn from the calculated results of the method 'calculate'.
 * For a timeFrame = number of trading days within a year (e. g. 251 days in the US) 
 * and "end of day"-ticks you will get the 'Annualized Total Return'.
 * Only complete timeFrames are taken into the calculation.
 * @return the total return from the calculated results of the method 'calculate'
 */
public double getTotalReturn() {

    Decimal totalProduct = Decimal.ONE;
    int completeTimeframes = (getTimeSeries().getTickCount() / timeFrame);

    for (int i = 1; i <= completeTimeframes; i++) {
        int index = i * timeFrame;
        Decimal currentReturn = getValue(index);

        // Skip NaN at the end of a series
        if (currentReturn != Decimal.NaN) {
            currentReturn = currentReturn.plus(Decimal.ONE);
            totalProduct = totalProduct.multipliedBy(currentReturn);
        }
    }

    return (Math.pow(totalProduct.toDouble(), (1.0 / completeTimeframes)));
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
/**
 * Calculates the regression line.
 * @param startIndex the start index (inclusive) in the time series
 * @param endIndex the end index (inclusive) in the time series
 */
private void calculateRegressionLine(int startIndex, int endIndex) {
    // First pass: compute xBar and yBar
    Decimal sumX = Decimal.ZERO;
    Decimal sumY = Decimal.ZERO;
    for (int i = startIndex; i <= endIndex; i++) {
        sumX = sumX.plus(Decimal.valueOf(i));
        sumY = sumY.plus(indicator.getValue(i));
    }
    Decimal nbObservations = Decimal.valueOf(endIndex - startIndex + 1);
    Decimal xBar = sumX.dividedBy(nbObservations);
    Decimal yBar = sumY.dividedBy(nbObservations);
    
    // Second pass: compute slope and intercept
    Decimal xxBar = Decimal.ZERO;
    Decimal xyBar = Decimal.ZERO;
    for (int i = startIndex; i <= endIndex; i++) {
        Decimal dX = Decimal.valueOf(i).minus(xBar);
        Decimal dY = indicator.getValue(i).minus(yBar);
        xxBar = xxBar.plus(dX.multipliedBy(dX));
        xyBar = xyBar.plus(dX.multipliedBy(dY));
    }
    
    slope = xyBar.dividedBy(xxBar);
    intercept = yBar.minus(slope.multipliedBy(xBar));
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
private static void printBackTestResults(String mkt, TimeSeries series,
                                         Strategy strategy) {
    BacktestResult result = new BacktestResult(series, strategy).test();
    StringBuilder builder = new StringBuilder();
    builder.append(mkt + " Backtest: " + series
            .getSeriesPeriodDescription());
    builder.append("\n\tSeries Metrics:");
    int numTicks = series.getTickCount();
    builder.append("\n\t\tNumber of Ticks: " + numTicks);
    builder.append("\n\t\tFirst Tick Open Price: " + series.getTick(0)
            .getOpenPrice());
    builder.append("\n\t\tLast Tick Close Price: " + series.getTick
            (numTicks - 1).getClosePrice());
    Decimal volume = Decimal.ZERO;
    for (int i = 0; i < numTicks; i++) {
        volume = volume.plus(series.getTick(i).getAmount());
    }
    builder.append("\n\t\tVolume (All Ticks): " + volume);
    builder.append("\n\n\tTrade Performance:");
    builder.append("\n\t\tNumber of Trades: " + result.getNumberOfTrades());
    builder.append("\n\t\tTotal Profit: " + result.getProfit());
    builder.append("\n\t\tBuy and Hold Profit: " + result
            .getBuyAndHoldProfit());
    double profitableTradesRatio = result.getProfitableTradesRatio();
    builder.append("\n\t\tProfitable Trades Ratio: " +
            profitableTradesRatio + " (" + profitableTradesRatio * 100D +
            "%)");
    double maximumDrawdown = result.getMaxDrawdown();
    builder.append("\n\t\tMaximum Drawdown: " + maximumDrawdown + " (" +
            maximumDrawdown * 100D + "%)");
    builder.append("\n\t\tReward Risk Ratio: " + result
            .getRewardRiskRatio());
    builder.append("\n\t\tLinear Transaction Cost: " + result
            .getLinearTransactionCost());

    System.out.println(builder.toString());
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
/**
 * Generates a random tick.
 * @return a random tick
 */
private static Tick generateRandomTick() {
    final Decimal maxRange = Decimal.valueOf("0.03"); // 3.0%
    Decimal openPrice = LAST_TICK_CLOSE_PRICE;
    Decimal minPrice = openPrice.minus(openPrice.multipliedBy(maxRange.multipliedBy(Decimal.valueOf(Math.random()))));
    Decimal maxPrice = openPrice.plus(openPrice.multipliedBy(maxRange.multipliedBy(Decimal.valueOf(Math.random()))));
    Decimal closePrice = randDecimal(minPrice, maxPrice);
    LAST_TICK_CLOSE_PRICE = closePrice;
    return new BaseTick(ZonedDateTime.now(), openPrice, maxPrice, minPrice, closePrice, Decimal.ONE);
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
@Override
protected Decimal calculate(int index) {
    Decimal sumOfGains = Decimal.ZERO;
    for (int i = Math.max(1, index - timeFrame + 1); i <= index; i++) {
        if (indicator.getValue(i).isGreaterThan(indicator.getValue(i - 1))) {
            sumOfGains = sumOfGains.plus(indicator.getValue(i).minus(indicator.getValue(i - 1)));
        }
    }
    return sumOfGains;
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
@Override
protected Decimal calculate(int index) {
    int startIndex = Math.max(0, index - timeFrame + 1);
    Decimal sumOfVolume = Decimal.ZERO;
    for (int i = startIndex; i <= index; i++) {
        sumOfVolume = sumOfVolume.plus(series.getTick(i).getVolume());
    }
    return sumOfVolume;
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
@Override
protected Decimal calculate(int index) {
    Decimal sum = Decimal.ZERO;
    for (int i = 0; i < operands.length; i++) {
        sum = sum.plus(operands[i].getValue(index));
    }
    return sum;
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
@Override
protected Decimal calculate(int index) {
    Decimal sumOfLosses = Decimal.ZERO;
    for (int i = Math.max(1, index - timeFrame + 1); i <= index; i++) {
        if (indicator.getValue(i).isLessThan(indicator.getValue(i - 1))) {
            sumOfLosses = sumOfLosses.plus(indicator.getValue(i - 1).minus(indicator.getValue(i)));
        }
    }
    return sumOfLosses;
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
@Override
protected Decimal calculate(int index) {
    Decimal absoluteDeviations = Decimal.ZERO;

    final Decimal average = sma.getValue(index);
    final int startIndex = Math.max(0, index - timeFrame + 1);
    final int nbValues = index - startIndex + 1;

    for (int i = startIndex; i <= index; i++) {
        // For each period...
        absoluteDeviations = absoluteDeviations.plus(indicator.getValue(i).minus(average).abs());
    }
    return absoluteDeviations.dividedBy(Decimal.valueOf(nbValues));
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
@Override
protected Decimal calculate(int index) {
    Decimal currentPrice = price.getValue(index);
    if (index < timeFrameEffectiveRatio) {
        return currentPrice;
    }
    /*
     * Efficiency Ratio (ER)
     * ER = Change/Volatility
     * Change = ABS(Close - Close (10 periods ago))
     * Volatility = Sum10(ABS(Close - Prior Close))
     * Volatility is the sum of the absolute value of the last ten price changes (Close - Prior Close).
     */
    int startChangeIndex = Math.max(0, index - timeFrameEffectiveRatio);
    Decimal change = currentPrice.minus(price.getValue(startChangeIndex)).abs();
    Decimal volatility = Decimal.ZERO;
    for (int i = startChangeIndex; i < index; i++) {
        volatility = volatility.plus(price.getValue(i + 1).minus(price.getValue(i)).abs());
    }
    Decimal er = change.dividedBy(volatility);
    /*
     * Smoothing Constant (SC)
     * SC = [ER x (fastest SC - slowest SC) + slowest SC]2
     * SC = [ER x (2/(2+1) - 2/(30+1)) + 2/(30+1)]2
     */
    Decimal sc = er.multipliedBy(fastest.minus(slowest)).plus(slowest).pow(2);
    /*
     * KAMA
     * Current KAMA = Prior KAMA + SC x (Price - Prior KAMA)
     */
    Decimal priorKAMA = getValue(index - 1);
    return priorKAMA.plus(sc.multipliedBy(currentPrice.minus(priorKAMA)));
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
@Override
protected Decimal calculate(int index) {
    final int startIndex = Math.max(0, index - timeFrame + 1);
    final int numberOfObservations = index - startIndex + 1;
    Decimal squaredAverage = Decimal.ZERO;
    for (int i = startIndex; i <= index; i++) {
        Decimal currentValue = indicator.getValue(i);
        Decimal highestValue = highestValueInd.getValue(i);
        Decimal percentageDrawdown = currentValue.minus(highestValue).dividedBy(highestValue).multipliedBy(Decimal.HUNDRED);
        squaredAverage = squaredAverage.plus(percentageDrawdown.pow(2));
    }
    squaredAverage = squaredAverage.dividedBy(Decimal.valueOf(numberOfObservations));
    return squaredAverage.sqrt();
}