Java Decimal.dividedBy方法代码示例

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.ZERO;
    }

    // Relative strength
    Decimal averageLoss = averageLossIndicator.getValue(index);
    if (averageLoss.isZero()) {
        return Decimal.HUNDRED;
    }
    Decimal averageGain = averageGainIndicator.getValue(index);
    Decimal relativeStrength = averageGain.dividedBy(averageLoss);

    // Nominal case
    Decimal ratio = Decimal.HUNDRED.dividedBy(Decimal.ONE.plus(relativeStrength));
    return Decimal.HUNDRED.minus(ratio);
}
 

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包/类
/**
 * Calculates the profit of a trade (Buy and sell).
 * @param series a time series
 * @param trade a trade
 * @return the profit of the trade
 */
private double calculateProfit(TimeSeries series, Trade trade) {
    Decimal profit = Decimal.ONE;
    if (trade.isClosed()) {
        Decimal exitClosePrice = series.getTick(trade.getExit().getIndex()).getClosePrice();
        Decimal entryClosePrice = series.getTick(trade.getEntry().getIndex()).getClosePrice();

        if (trade.getEntry().isBuy()) {
            profit = exitClosePrice.dividedBy(entryClosePrice);
        } else {
            profit = entryClosePrice.dividedBy(exitClosePrice);
        }
    }
    return profit.toDouble();
}
 

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

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

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

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 variance = Decimal.ZERO;
    Decimal average = sma.getValue(index);
    for (int i = startIndex; i <= index; i++) {
        Decimal pow = indicator.getValue(i).minus(average).pow(2);
        variance = variance.plus(pow);
    }
    variance = variance.dividedBy(Decimal.valueOf(numberOfObservations));
    return variance;
}
 

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
@Override
protected Decimal calculate(int index) {
    Decimal cov = covariance.getValue(index);
    Decimal var1 = variance1.getValue(index);
    Decimal var2 = variance2.getValue(index);
    
    return cov.dividedBy(var1.multipliedBy(var2).sqrt());
}
 

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 covariance = Decimal.ZERO;
    Decimal average1 = sma1.getValue(index);
    Decimal average2 = sma2.getValue(index);
    for (int i = startIndex; i <= index; i++) {
        Decimal mul = indicator1.getValue(i).minus(average1).multipliedBy(indicator2.getValue(i).minus(average2));
        covariance = covariance.plus(mul);
    }
    covariance = covariance.dividedBy(Decimal.valueOf(numberOfObservations));
    return covariance;
}
 

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

import eu.verdelhan.ta4j.Decimal; //导入方法依赖的package包/类
@Override
protected Decimal calculate(int index) {
    Decimal previousTickClosePrice = series.getTick(Math.max(0, index - 1)).getClosePrice();
    Decimal currentTickClosePrice = series.getTick(index).getClosePrice();
    return currentTickClosePrice.dividedBy(previousTickClosePrice);
}