Java Decimal.isLessThan方法代码示例

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包/类
/**
 * Generates a random decimal number between min and max.
 * @param min the minimum bound
 * @param max the maximum bound
 * @return a random decimal number between min and max
 */
private static Decimal randDecimal(Decimal min, Decimal max) {
    Decimal randomDecimal = null;
    if (min != null && max != null && min.isLessThan(max)) {
        randomDecimal = max.minus(min).multipliedBy(Decimal.valueOf(Math.random())).plus(min);
    }
    return randomDecimal;
}
 

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

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
/**
 * @param index the tick/candle index
 * @return true if the tick/candle has a very short lower shadow, false otherwise
 */
private boolean hasVeryShortLowerShadow(int index) {
    Decimal currentLowerShadow = lowerShadowInd.getValue(index);
    // We use the white candle index to remove to bias of the previous crows
    Decimal averageLowerShadow = averageLowerShadowInd.getValue(whiteCandleIndex);
    
    return currentLowerShadow.isLessThan(averageLowerShadow.multipliedBy(factor));
}
 

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 tick/candle index
 * @return true if the tick/candle has a very short upper shadow, false otherwise
 */
private boolean hasVeryShortUpperShadow(int index) {
    Decimal currentUpperShadow = upperShadowInd.getValue(index);
    // We use the black candle index to remove to bias of the previous soldiers
    Decimal averageUpperShadow = averageUpperShadowInd.getValue(blackCandleIndex);
    
    return currentUpperShadow.isLessThan(averageUpperShadow.multipliedBy(factor));
}
 

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 Boolean calculate(int index) {
    if (index < 1) {
        return bodyHeightInd.getValue(index).isZero();
    }
    
    Decimal averageBodyHeight = averageBodyHeightInd.getValue(index-1);
    Decimal currentBodyHeight = bodyHeightInd.getValue(index);
    
    return currentBodyHeight.isLessThan(averageBodyHeight.multipliedBy(factor));
}
 

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

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

    if (index <= 1) {
        // Warning: should the min or the max price, according to the trend
        // But we don't know the trend yet, so we use the close price.
        extremePoint = series.getTick(index).getClosePrice();
        return extremePoint;
    }

    Decimal n2ClosePrice = series.getTick(index - 2).getClosePrice();
    Decimal n1ClosePrice = series.getTick(index - 1).getClosePrice();
    Decimal nClosePrice = series.getTick(index).getClosePrice();

    Decimal sar;
    if (n2ClosePrice.isGreaterThan(n1ClosePrice) && n1ClosePrice.isLessThan(nClosePrice)) {
        // Trend switch: \_/
        sar = extremePoint == null ? lowestValueIndicator.getValue(index) : extremePoint;
        extremePoint = highestValueIndicator.getValue(index);
        acceleration = DEFAULT_ACCELERATION;
    } else if (n2ClosePrice.isLessThan(n1ClosePrice) && n1ClosePrice.isGreaterThan(nClosePrice)) {
        // Trend switch: /¯\
        sar = extremePoint == null ? highestValueIndicator.getValue(index) : extremePoint;
        extremePoint = lowestValueIndicator.getValue(index);
        acceleration = DEFAULT_ACCELERATION;

    } else if (nClosePrice.isLessThan(n1ClosePrice)) {
         // Downtrend: falling SAR
        Decimal lowestValue = lowestValueIndicator.getValue(index);
        if (extremePoint.isGreaterThan(lowestValue)) {
            incrementAcceleration();
            extremePoint = lowestValue;
        }
        sar = calculateSar(index);

        Decimal n2MaxPrice = series.getTick(index - 2).getMaxPrice();
        Decimal n1MaxPrice = series.getTick(index - 1).getMaxPrice();
        Decimal nMaxPrice = series.getTick(index).getMaxPrice();

        if (n1MaxPrice.isGreaterThan(sar)) {
            sar = n1MaxPrice;
        } else if (n2MaxPrice.isGreaterThan(sar)) {
            sar = n2MaxPrice;
        }
        if (nMaxPrice.isGreaterThan(sar)) {
            sar = series.getTick(index).getMinPrice();
        }

    } else {
         // Uptrend: rising SAR
        Decimal highestValue = highestValueIndicator.getValue(index);
        if (extremePoint.isLessThan(highestValue)) {
            incrementAcceleration();
            extremePoint = highestValue;
        }
        sar = calculateSar(index);

        Decimal n2MinPrice = series.getTick(index - 2).getMinPrice();
        Decimal n1MinPrice = series.getTick(index - 1).getMinPrice();
        Decimal nMinPrice = series.getTick(index).getMinPrice();

        if (n1MinPrice.isLessThan(sar)) {
            sar = n1MinPrice;
        } else if (n2MinPrice.isLessThan(sar)) {
            sar = n2MinPrice;
        }
        if (nMinPrice.isLessThan(sar)) {
            sar = series.getTick(index).getMaxPrice();
        }

    }
    return sar;
}