pivothigh() 和 pivotlow() function 如何在 Tradingview Pinescript 上工作？

Question

I'm trying to rewrite a script to Python, but I can't figure out how pivothigh() and pivotlow() function work, and I can't find source code, I know how to calculate Pivot Points, but what leftbars and rightbars means in this two function? Please help.

Answer 1

Leftbars and rightbars are number of bars that the pivot functions looks when is searching for a pivot. For example: pivothigh(10,10) will search for high price that was not exceeded during 10 bars to the left (past data) and 10 bars to the right (future data). Note that the function won't be able to determine the pivot if there is less than 10 bars to the right.

Answer 2

I've tried to create a simple version of it in pine script, which does not uses pivothigh/pivotlow - instead does the candlestick comparison.

https://www.tradingview.com/script/BYHsrYPG-Broken-Fractal-Someone-s-broken-dream-is-your-profit

I was also able to convert this into Ruby code (Python code should be as easy)

            if (candles[i-1][:h] > candles[i-2][:h]) and (candles[i-1][:h] > candles[i][:h])
                puts "DownFractal"
            end

            if (candles[i-1][:l] < candles[i-2][:l]) and (candles[i-1][:l] < candles[i][:l])
                puts "UpFractal"
            end

Answer 3

I too had a need to better understand how the pivothigh() and pivotlow() functions work internally so I made the effort to code a Pine Script version (using version 5 of Pine Script) for myself and tested it side-by-side with the ta.pivotlow() and ta.pivothigh() functions and it seems to work well. Maybe this will help you as well.

my_pivothigh(float _series = high, int _leftBars, int _rightBars) =>
    float _pivotHigh = na
    int _pivotRange = ( _leftBars + _rightBars )
    float _leftEdgeValue = nz(_series[_pivotRange], na)
    if not na(_series) and _leftBars > 0 and _rightBars > 0 and not na(_leftEdgeValue)
        float _possiblePivotHigh = _series[_rightBars]
        float[] _arrayOfSeriesValues = array.new_float(0)
        for _barIndex = _pivotRange to 0
            array.push(_arrayOfSeriesValues, _series[_barIndex])
        //end for
        int _pivotHighRightBars = array.size(_arrayOfSeriesValues) - array.lastindexof(_arrayOfSeriesValues, array.max(_arrayOfSeriesValues)) - 1
        _pivotHigh := ( _pivotHighRightBars == _rightBars ) ? _possiblePivotHigh : na
    //end if
    _pivotHigh

my_pivotlow(float _series = low, int _leftBars, int _rightBars) =>
    float _pivotLow = na
    int _pivotRange = ( _leftBars + _rightBars )
    float _leftEdgeValue = nz(_series[_pivotRange], na)
    if not na(_series) and _leftBars > 0 and _rightBars > 0 and not na(_leftEdgeValue)
        float _possiblePivotLow = _series[_rightBars]
        float[] _arrayOfSeriesValues = array.new_float(0)
        for _barIndex = _pivotRange to 0
            array.push(_arrayOfSeriesValues, _series[_barIndex])
        //end for
        int _pivotLowRightBars = array.size(_arrayOfSeriesValues) - array.lastindexof(_arrayOfSeriesValues, array.min(_arrayOfSeriesValues)) - 1
        _pivotLow := ( _pivotLowRightBars == _rightBars ) ? _possiblePivotLow : na
    //end if
    _pivotLow

Answer 4

This is my implementation of ta.pivotHigh for javascript, hope this helps.

const pivotHigh = (series, period) => {
  
  let ph = 0;
  let phIndex = 0;

  // left + right bars + 1 pivot bar
  for ( let i = period + period + 1, len = series.length; i--; ) {

    const cur = series[len - i];
    
    // [!] > -1 logic. can also checks: NaN
    if ( cur > -1 ) {} else {
      break;
    }

    if ( cur > ph ) {
      ph = cur;
      phIndex = len - i;
    }
  }
  // found?
  return phIndex === period
    ? ph
    : 0;
};

usage:

const series = [0,1,2,3,4,5,4,3,2,1,0];
const period = 5;

const ph = pivotHigh(series, period);

Answer 5

I had found this thread after I have searched for this kind of implementation. Here is my own implementation for those that have been utilizing the Binance API. (Written in java)

From my own testings, it has the same results as the pine script.

private boolean checkHighOrLow(Candlestick candlestick , int lengthForCheck, int currentCandleIndex, boolean checkForHigh) {
    double currentCandleStickClosePrice = Double.parseDouble(candlestick.getClose());
    for (int i = 0; i < lengthForCheck; i++) {
        double afterCandleStick  = Double.parseDouble(candlestickList.get(currentCandleIndex + i + 1).getClose());
        double beforeCandleStick = Double.parseDouble(candlestickList.get(currentCandleIndex - i - 1).getClose());
        if(checkForHigh) {
            if (afterCandleStick > currentCandleStickClosePrice)
                return false;
            if (beforeCandleStick > currentCandleStickClosePrice)
                return false;
        }else{
            if(afterCandleStick < currentCandleStickClosePrice)
                return false;
            if(beforeCandleStick < currentCandleStickClosePrice)
                return false;
        }
    }
    return true;
}

public void findHighsAndLows(){
    int lengthForCheck = 1;
    int numOfCandles   = candlestickList.size();
    for(int i = lengthForCheck; i < numOfCandles - lengthForCheck; i ++)
    {
         Candlestick currentCandle = candlestickList.get(i);
         if(checkHighOrLow(currentCandle,numOfCandles,lengthForCheck,i,true))
             highs.add(currentCandle);
         if(checkHighOrLow(currentCandle,numOfCandles,lengthForCheck,i,false))
             lows.add(currentCandle);
    }
}

Logic still applies. Enjoy

Result:

FOUND LOW | Wed Aug 25 04:20:00 IDT 2021
FOUND HIGH | Wed Aug 25 05:05:00 IDT 2021
FOUND LOW | Wed Aug 25 05:20:00 IDT 2021
FOUND HIGH | Wed Aug 25 05:30:00 IDT 2021
FOUND LOW | Wed Aug 25 05:35:00 IDT 2021
FOUND HIGH | Wed Aug 25 05:45:00 IDT 2021
FOUND LOW | Wed Aug 25 06:15:00 IDT 2021
FOUND HIGH | Wed Aug 25 06:25:00 IDT 2021
FOUND LOW | Wed Aug 25 06:35:00 IDT 2021
FOUND HIGH | Wed Aug 25 06:40:00 IDT 2021
FOUND LOW | Wed Aug 25 06:55:00 IDT 2021
FOUND HIGH | Wed Aug 25 07:05:00 IDT 2021
FOUND LOW | Wed Aug 25 07:25:00 IDT 2021
FOUND HIGH | Wed Aug 25 07:45:00 IDT 2021
FOUND LOW | Wed Aug 25 07:50:00 IDT 2021
FOUND HIGH | Wed Aug 25 08:20:00 IDT 2021
FOUND LOW | Wed Aug 25 08:25:00 IDT 2021
FOUND HIGH | Wed Aug 25 08:35:00 IDT 2021
FOUND LOW | Wed Aug 25 08:45:00 IDT 2021
FOUND HIGH | Wed Aug 25 08:50:00 IDT 2021
FOUND LOW | Wed Aug 25 09:15:00 IDT 2021
FOUND HIGH | Wed Aug 25 09:30:00 IDT 2021
FOUND LOW | Wed Aug 25 09:35:00 IDT 2021
FOUND HIGH | Wed Aug 25 09:40:00 IDT 2021
FOUND LOW | Wed Aug 25 09:55:00 IDT 2021
FOUND HIGH | Wed Aug 25 10:00:00 IDT 2021
FOUND LOW | Wed Aug 25 10:05:00 IDT 2021
FOUND HIGH | Wed Aug 25 10:15:00 IDT 2021
FOUND LOW | Wed Aug 25 10:45:00 IDT 2021
FOUND HIGH | Wed Aug 25 10:50:00 IDT 2021
FOUND LOW | Wed Aug 25 11:15:00 IDT 2021
FOUND HIGH | Wed Aug 25 11:20:00 IDT 2021
FOUND LOW | Wed Aug 25 11:35:00 IDT 2021
FOUND HIGH | Wed Aug 25 11:45:00 IDT 2021
FOUND LOW | Wed Aug 25 11:55:00 IDT 2021
FOUND HIGH | Wed Aug 25 12:15:00 IDT 2021

Answer 6

I am not sure if it is correct, but you can try:

def IsPivotHigh(array: ArrayData[T], leftPeriods: int, rightPeriods: int):
    """Return True if is Top Pivot Point, Note: It use future price"""

    isPivotPoint = HHVBars(array, leftPeriods) == 0

    barCount = len(isPivotPoint)

    for i in range(0, barCount):
        if isPivotPoint[i]:
            for j in range(i + 1, min(barCount, i + rightPeriods)):
                if j >= barCount:
                    continue
                if isPivotPoint[j]:
                    isPivotPoint[i] = False
                    break

    for i in range(max(0, barCount - rightPeriods), barCount):
        isPivotPoint[i] = False

    return isPivotPoint


def PivotHigh(array: ArrayData[T], leftPeriods: int, rightPeriods: int):
    return ValueWhen(IsPivotHigh(array, leftPeriods, rightPeriods), array)


def PivotHighBars(array: ArrayData[T], leftPeriods: int, rightPeriods: int):
    return BarsSince(IsPivotHigh(array, leftPeriods, rightPeriods))

Answer 7

I know this is an old post but I've made a very simple python implementation that anyone can build on, it does the same thing as Pine Scripts ta.pivot functions.

code:

def pivots_high(data, LBR, LBL):
    pivots = []
    for i in range(len(data)-LBR):
        pivots.append(0)
        pivot = True
        if i > LBL:
            for j in range(LBL + 1):
                if data[i - j] > data[i]: # do if data[i - j] < data[i] for pivot low
                    pivot = False
            for j in range(LBR + 1):
                if data[i + j] > data[i]: # do if data[i + j] < data[i] for pivot low
                    pivot = False
        if pivot is True:
            pivots[len(pivots)-1] = data[i]
    for p in range(LBR):
        pivots.append(0) # This is so the pivots length matches your data 
                       length
    return pivots    # The Pivots will be any value that is not 0 and it 
                       will be where the lowest/highest value is

the lookback variables simply means that if you take one price point and look n(Looback left) candles left and n(lookback right) candles right, and still its the lowest/highest then that's the pivot

Answer 8

You could construct something similar with a one-liner with pandas:

pivots = high_column.shift(-len_right, fill_value=0).rolling(len_left).max()

For 'High' pivots pd.Series 'high_column' and:

pivots = low_column.shift(-len_right, fill_value=0).rolling(len_left).min()

for the 'Lows'. It avoids using loops and is a fast vectorized function.

Answer 9

Here's my Python implementation. Works exactly as ta.pivothigh and ta.pivotlow .

Pivot high:

def get_pivot_high(ohlcvs: List[OHLCV], left_bars: int, right_bars: int, key_name: str = 'high_price') -> Optional[float]:
    if len(ohlcvs) < left_bars + right_bars:
        return None
    highest_value = max(ohlcv.get(key_name) for ohlcv in ohlcvs[-(left_bars + right_bars + 1):])
    return highest_value if highest_value == ohlcvs[-right_bars].get(key_name) else None

Pivot low:

def get_pivot_low(ohlcvs: List[OHLCV], left_bars: int, right_bars: int, key_name: str = 'low_price') -> Optional[float]:
    if len(ohlcvs) < left_bars + right_bars:
        return None
    lowest_value = min(ohlcv.get(key_name) for ohlcv in ohlcvs[-(left_bars + right_bars + 1):])
    return lowest_value if lowest_value == ohlcvs[-right_bars].get(key_name) else None