Java Decimal.ZERO属性代码示例

@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);
}
 

/**
 * Calculates the maximum drawdown from a cash flow over a series.
 * @param series the time series
 * @param cashFlow the cash flow
 * @return the maximum drawdown from a cash flow over a series
 */
private Decimal calculateMaximumDrawdown(TimeSeries series, CashFlow cashFlow) {
    Decimal maximumDrawdown = Decimal.ZERO;
    Decimal maxPeak = Decimal.ZERO;
    if (!series.isEmpty()) {
    	// The series is not empty
     for (int i = series.getBeginIndex(); i <= series.getEndIndex(); i++) {
         Decimal value = cashFlow.getValue(i);
         if (value.isGreaterThan(maxPeak)) {
             maxPeak = value;
         }
	
         Decimal drawdown = maxPeak.minus(value).dividedBy(maxPeak);
         if (drawdown.isGreaterThan(maximumDrawdown)) {
             maximumDrawdown = drawdown;
         }
     }
    }
    return maximumDrawdown;
}
 

@Override
protected Decimal calculate(int index) {
    if (index == 0) {
        return Decimal.ZERO;
    }
    Decimal prevMaxPrice = series.getTick(index - 1).getMaxPrice();
    Decimal maxPrice = series.getTick(index).getMaxPrice();
    Decimal prevMinPrice = series.getTick(index - 1).getMinPrice();
    Decimal minPrice = series.getTick(index).getMinPrice();
    
    if ((prevMaxPrice.isGreaterThanOrEqual(maxPrice) && prevMinPrice.isLessThanOrEqual(minPrice))
            || maxPrice.minus(prevMaxPrice).isGreaterThanOrEqual(prevMinPrice.minus(minPrice))) {
        return Decimal.ZERO;
    }
    return prevMinPrice.minus(minPrice);
}
 

@Override
protected Decimal calculate(int index) {
    if (index == 0) {
        return Decimal.ZERO;
    }
    Decimal prevMaxPrice = series.getTick(index - 1).getMaxPrice();
    Decimal maxPrice = series.getTick(index).getMaxPrice();
    Decimal prevMinPrice = series.getTick(index - 1).getMinPrice();
    Decimal minPrice = series.getTick(index).getMinPrice();

    if ((maxPrice.isLessThan(prevMaxPrice) && minPrice.isGreaterThan(prevMinPrice))
            || prevMinPrice.minus(minPrice).isEqual(maxPrice.minus(prevMaxPrice))) {
        return Decimal.ZERO;
    }
    if (maxPrice.minus(prevMaxPrice).isGreaterThan(prevMinPrice.minus(minPrice))) {
        return maxPrice.minus(prevMaxPrice);
    }
    
    return Decimal.ZERO;
}
 

@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));
}
 

@Test
public void testStrategies() { 
    
    PeriodicalGrowthRateIndicator gri = new PeriodicalGrowthRateIndicator(this.closePrice,5);

    // Rules
    Rule buyingRule = new CrossedUpIndicatorRule(gri, Decimal.ZERO); 
    Rule sellingRule = new CrossedDownIndicatorRule(gri, Decimal.ZERO);     
    
    Strategy strategy = new BaseStrategy(buyingRule, sellingRule);
            
    // Check trades
    int result = seriesManager.run(strategy).getTradeCount();             
    int expResult = 3;
    
    assertEquals(expResult, result);
}
 

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());
}
 

@Override
protected Decimal calculate(int index) {
    Decimal ts = series.getTick(index).getMaxPrice().minus(series.getTick(index).getMinPrice());
    Decimal ys = index == 0 ? Decimal.ZERO : series.getTick(index).getMaxPrice().minus(series.getTick(index - 1).getClosePrice());
    Decimal yst = index == 0 ? Decimal.ZERO : series.getTick(index - 1).getClosePrice().minus(series.getTick(index).getMinPrice());
    
    return ts.abs().max(ys.abs()).max(yst.abs());
}
 

@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;
}
 

@Override
protected Decimal calculate(int index) {
    Decimal sum = Decimal.ZERO;
    for (int i = Math.max(0, index - timeFrame + 1); i <= index; i++) {
        sum = sum.plus(indicator.getValue(i));
    }

    final int realTimeFrame = Math.min(timeFrame, index + 1);
    return sum.dividedBy(Decimal.valueOf(realTimeFrame));
}
 

@Override
protected Decimal calculate(int index) {
    if (index <= 0) {
        return typicalPrice.getValue(index);
    }
    int startIndex = Math.max(0, index - timeFrame + 1);
    Decimal cumulativeTPV = Decimal.ZERO;
    Decimal cumulativeVolume = Decimal.ZERO;
    for (int i = startIndex; i <= index; i++) {
        Decimal currentVolume = volume.getValue(i);
        cumulativeTPV = cumulativeTPV.plus(typicalPrice.getValue(i).multipliedBy(currentVolume));
        cumulativeVolume = cumulativeVolume.plus(currentVolume);
    }
    return cumulativeTPV.dividedBy(cumulativeVolume);
}
 

@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;
}
 

@Test
public void constantIndicators() {
    AbsoluteIndicator positiveInd = new AbsoluteIndicator(new ConstantIndicator<Decimal>(Decimal.valueOf(1337)));
    AbsoluteIndicator zeroInd = new AbsoluteIndicator(new ConstantIndicator<Decimal>(Decimal.ZERO));
    AbsoluteIndicator negativeInd = new AbsoluteIndicator(new ConstantIndicator<Decimal>(Decimal.valueOf(-42.42)));
    for (int i = 0; i < 10; i++) {
        assertDecimalEquals(positiveInd.getValue(i), 1337);
        assertDecimalEquals(zeroInd.getValue(i), 0);
        assertDecimalEquals(negativeInd.getValue(i), 42.42);
    }
}
 

@Override
protected Decimal calculate(int index) {
    final int startIndex = Math.max(0, index - timeFrame + 1);
    Decimal massIndex = Decimal.ZERO;
    for (int i = startIndex; i <= index; i++) {
        Decimal emaRatio = singleEma.getValue(i).dividedBy(doubleEma.getValue(i));
        massIndex = massIndex.plus(emaRatio);
    }
    return massIndex;
}
 

@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)));
}