Java TimeSeries.getEndIndex方法代码示例

import eu.verdelhan.ta4j.TimeSeries; //导入方法依赖的package包/类
/**
 * Returns a new time series which is a view of a subset of the current series.
 * <p>
 * The new series has begin and end indexes which correspond to the bounds of the sub-set into the full series.<br>
 * The tick of the series are shared between the original time series and the returned one (i.e. no copy).
 * @param series the time series to get a sub-series of
 * @param beginIndex the begin index (inclusive) of the time series
 * @param duration the duration of the time series
 * @return a constrained {@link TimeSeries time series} which is a sub-set of the current series
 */
public static TimeSeries subseries(TimeSeries series, int beginIndex, Duration duration) {

    // Calculating the sub-series interval
    ZonedDateTime beginInterval = series.getTick(beginIndex).getEndTime();
    ZonedDateTime endInterval = beginInterval.plus(duration);

    // Checking ticks belonging to the sub-series (starting at the provided index)
    int subseriesNbTicks = 0;
    int endIndex = series.getEndIndex();
    for (int i = beginIndex; i <= endIndex; i++) {
        // For each tick...
        ZonedDateTime tickTime = series.getTick(i).getEndTime();
        if (tickTime.isBefore(beginInterval) || !tickTime.isBefore(endInterval)) {
            // Tick out of the interval
            break;
        }
        // Tick in the interval
        // --> Incrementing the number of ticks in the subseries
        subseriesNbTicks++;
    }

    return new BaseTimeSeries(series, beginIndex, beginIndex + subseriesNbTicks - 1);
}
 

import eu.verdelhan.ta4j.TimeSeries; //导入方法依赖的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.TimeSeries; //导入方法依赖的package包/类
@Override
public T getValue(int index) {
    TimeSeries series = getTimeSeries();
    if (series != null) {
        final int seriesEndIndex = series.getEndIndex();
        if (index <= seriesEndIndex) {
            // We are not after the end of the series
            final int removedTicksCount = series.getRemovedTicksCount();
            int startIndex = Math.max(removedTicksCount, highestResultIndex);
            if (index - startIndex > RECURSION_THRESHOLD) {
                // Too many uncalculated values; the risk for a StackOverflowError becomes high.
                // Calculating the previous values iteratively
                for (int prevIdx = startIndex; prevIdx < index; prevIdx++) {
                    super.getValue(prevIdx);
                }
            }
        }
    }
    
    return super.getValue(index);
}
 

import eu.verdelhan.ta4j.TimeSeries; //导入方法依赖的package包/类
@Override
public boolean getBuySignal(TimeSeries tickers) {

    BuySignalIndicator buySignal = new BuySignalIndicator(tickers, 33, Decimal.valueOf(0.25));

    // Need to go through all index to initialize indicators
    for (int i = tickers.getBeginIndex(); i <= tickers.getEndIndex(); i++) {
        buySignal.getValue(i);
    }

    boolean signal = buySignal.getValue(tickers.getEndIndex());
    LOGGER.debug("buy_trigger: {} (end time={})", signal, tickers.getLastTick().getEndTime());
    return signal;
}
 

import eu.verdelhan.ta4j.TimeSeries; //导入方法依赖的package包/类
/**
 * Builds a list of split indexes from splitDuration.
 * @param series the time series to get split begin indexes of
 * @param splitDuration the duration between 2 splits
 * @return a list of begin indexes after split
 */
public static List<Integer> getSplitBeginIndexes(TimeSeries series, Duration splitDuration) {
    ArrayList<Integer> beginIndexes = new ArrayList<>();

    int beginIndex = series.getBeginIndex();
    int endIndex = series.getEndIndex();
    
    // Adding the first begin index
    beginIndexes.add(beginIndex);

    // Building the first interval before next split
    ZonedDateTime beginInterval = series.getFirstTick().getEndTime();
    ZonedDateTime endInterval = beginInterval.plus(splitDuration);

    for (int i = beginIndex; i <= endIndex; i++) {
        // For each tick...
        ZonedDateTime tickTime = series.getTick(i).getEndTime();
        if (tickTime.isBefore(beginInterval) || !tickTime.isBefore(endInterval)) {
            // Tick out of the interval
            if (!endInterval.isAfter(tickTime)) {
                // Tick after the interval
                // --> Adding a new begin index
                beginIndexes.add(i);
            }

            // Building the new interval before next split
            beginInterval = endInterval.isBefore(tickTime) ? tickTime : endInterval;
            endInterval = beginInterval.plus(splitDuration);
        }
    }
    return beginIndexes;
}