Java Decimal.isGreaterThan方法代码示例

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
/**
 * 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;
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
@Override
public double calculate(TimeSeries series, Trade trade) {
    int entryIndex = trade.getEntry().getIndex();
    int exitIndex = trade.getExit().getIndex();

    Decimal result;
    if (trade.getEntry().isBuy()) {
        // buy-then-sell trade
        result = series.getTick(exitIndex).getClosePrice().dividedBy(series.getTick(entryIndex).getClosePrice());
    } else {
        // sell-then-buy trade
        result = series.getTick(entryIndex).getClosePrice().dividedBy(series.getTick(exitIndex).getClosePrice());
    }

    return (result.isGreaterThan(Decimal.ONE)) ? 1d : 0d;
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
@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;
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
@Override
protected Boolean calculate(int index) {
    if (index < 1) {
        // Harami is a 2-candle pattern
        return false;
    }
    Tick prevTick = series.getTick(index-1);
    Tick currTick = series.getTick(index);
    if (prevTick.isBearish() && currTick.isBullish()) {
        final Decimal prevOpenPrice = prevTick.getOpenPrice();
        final Decimal prevClosePrice = prevTick.getClosePrice();
        final Decimal currOpenPrice = currTick.getOpenPrice();
        final Decimal currClosePrice = currTick.getClosePrice();
        return currOpenPrice.isLessThan(prevOpenPrice) && currOpenPrice.isGreaterThan(prevClosePrice)
                && currClosePrice.isLessThan(prevOpenPrice) && currClosePrice.isGreaterThan(prevClosePrice);
    }
    return false;
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
@Override
protected Boolean calculate(int index) {
    if (index < 1) {
        // Harami is a 2-candle pattern
        return false;
    }
    Tick prevTick = series.getTick(index-1);
    Tick currTick = series.getTick(index);
    if (prevTick.isBullish() && currTick.isBearish()) {
        final Decimal prevOpenPrice = prevTick.getOpenPrice();
        final Decimal prevClosePrice = prevTick.getClosePrice();
        final Decimal currOpenPrice = currTick.getOpenPrice();
        final Decimal currClosePrice = currTick.getClosePrice();
        return currOpenPrice.isGreaterThan(prevOpenPrice) && currOpenPrice.isLessThan(prevClosePrice)
                && currClosePrice.isGreaterThan(prevOpenPrice) && currClosePrice.isLessThan(prevClosePrice);
    }
    return false;
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
@Override
protected Boolean calculate(int index) {
    if (index < 1) {
        // Engulfing is a 2-candle pattern
        return false;
    }
    Tick prevTick = series.getTick(index-1);
    Tick currTick = series.getTick(index);
    if (prevTick.isBullish() && currTick.isBearish()) {
        final Decimal prevOpenPrice = prevTick.getOpenPrice();
        final Decimal prevClosePrice = prevTick.getClosePrice();
        final Decimal currOpenPrice = currTick.getOpenPrice();
        final Decimal currClosePrice = currTick.getClosePrice();
        return currOpenPrice.isGreaterThan(prevOpenPrice) && currOpenPrice.isGreaterThan(prevClosePrice)
                && currClosePrice.isLessThan(prevOpenPrice) && currClosePrice.isLessThan(prevClosePrice);
    }
    return false;
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
@Override
protected Boolean calculate(int index) {
    if (index < 1) {
        // Engulfing is a 2-candle pattern
        return false;
    }
    Tick prevTick = series.getTick(index-1);
    Tick currTick = series.getTick(index);
    if (prevTick.isBearish() && currTick.isBullish()) {
        final Decimal prevOpenPrice = prevTick.getOpenPrice();
        final Decimal prevClosePrice = prevTick.getClosePrice();
        final Decimal currOpenPrice = currTick.getOpenPrice();
        final Decimal currClosePrice = currTick.getClosePrice();
        return currOpenPrice.isLessThan(prevOpenPrice) && currOpenPrice.isLessThan(prevClosePrice)
                && currClosePrice.isGreaterThan(prevOpenPrice) && currClosePrice.isGreaterThan(prevClosePrice);
    }
    return false;
}
 

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

    Boolean upSwing = upSwingIndicator.getValue(index);
    Boolean swap = swapIndicator.getValue(index);
    Decimal adxValue = adxIndicator.getValue(index);
    Boolean adx = adxValue.isGreaterThan(momentum);

    LOGGER.debug("@index={} upSwing={} swap={} adx={} (value={}, momentum={})", index, upSwing, swap, adx, adxValue,
            momentum);

    return upSwing && swap && adx;
}
 

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

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
/**
 * @param index the current tick/candle index
 * @return true if the current tick/candle is declining, false otherwise
 */
private boolean isDeclining(int index) {
    Tick prevTick = series.getTick(index-1);
    Tick currTick = series.getTick(index);
    final Decimal prevOpenPrice = prevTick.getOpenPrice();
    final Decimal prevClosePrice = prevTick.getClosePrice();
    final Decimal currOpenPrice = currTick.getOpenPrice();
    final Decimal currClosePrice = currTick.getClosePrice();
    
    // Opens within the body of the previous candle
    return currOpenPrice.isLessThan(prevOpenPrice) && currOpenPrice.isGreaterThan(prevClosePrice)
            // Closes below the previous close price
            && currClosePrice.isLessThan(prevClosePrice);
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
/**
 * @param index the current tick/candle index
 * @return true if the current tick/candle is growing, false otherwise
 */
private boolean isGrowing(int index) {
    Tick prevTick = series.getTick(index-1);
    Tick currTick = series.getTick(index);
    final Decimal prevOpenPrice = prevTick.getOpenPrice();
    final Decimal prevClosePrice = prevTick.getClosePrice();
    final Decimal currOpenPrice = currTick.getOpenPrice();
    final Decimal currClosePrice = currTick.getClosePrice();
    
    // Opens within the body of the previous candle
    return currOpenPrice.isGreaterThan(prevOpenPrice) && currOpenPrice.isLessThan(prevClosePrice)
            // Closes above the previous close price
            && currClosePrice.isGreaterThan(prevClosePrice);
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
@Override
protected Decimal calculate(int index) {
    Tick t = series.getTick(index);
    final Decimal openPrice = t.getOpenPrice();
    final Decimal closePrice = t.getClosePrice();
    if (closePrice.isGreaterThan(openPrice)) {
        // Bullish
        return openPrice.minus(t.getMinPrice());
    } else {
        // Bearish
        return closePrice.minus(t.getMinPrice());
    }
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
@Override
protected Decimal calculate(int index) {
    Tick t = series.getTick(index);
    final Decimal openPrice = t.getOpenPrice();
    final Decimal closePrice = t.getClosePrice();
    if (closePrice.isGreaterThan(openPrice)) {
        // Bullish
        return t.getMaxPrice().minus(closePrice);
    } else {
        // Bearish
        return t.getMaxPrice().minus(openPrice);
    }
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
/**
 * Simple implementation of the trailing stop-loss concept.
 * Logic:
 * IF CurrentPrice - StopLossDistance > StopLossLimit THEN StopLossLimit = CurrentPrice - StopLossDistance
 * @param index
 * @return Decimal
 */
@Override
protected Decimal calculate(int index) {
    if (stopLossLimit.isNaN()) {
        // Case without initial stop-loss limit value
        stopLossLimit = indicator.getValue(0).minus(stopLossDistance);
    }
    Decimal currentValue = indicator.getValue(index);
    Decimal referenceValue = stopLossLimit.plus(stopLossDistance);
    
    if (currentValue.isGreaterThan(referenceValue)) {
        stopLossLimit = currentValue.minus(stopLossDistance);
    }
    return stopLossLimit;
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
@Override
protected Decimal calculate(int index) {
    if (index == 0) {
        return Decimal.ZERO;
    }
    Decimal yesterdayClose = series.getTick(index - 1).getClosePrice();
    Decimal todayClose = series.getTick(index).getClosePrice();

    if (yesterdayClose.isGreaterThan(todayClose)) {
        return getValue(index - 1).minus(series.getTick(index).getVolume());
    } else if (yesterdayClose.isLessThan(todayClose)) {
        return getValue(index - 1).plus(series.getTick(index).getVolume());
    }
    return getValue(index - 1);
}