发明者量化-小小梦
FMZ PINE Script Doc
4
1790
oninput.sourceinput.colorinput”`
input.timeframe
Adds an input to the Inputs tab of your script’s Settings, which allows you to provide configuration options to script users. This function adds a dropdown that allows the user to select a specific timeframe via the timeframe selector and returns it as a string. The selector includes the custom timeframes a user may have added using the chart’s Timeframe dropdown.
input.timeframe(defval, title, options, tooltip, inline, group, confirm)
Example
i_res = input.timeframe('D', "Resolution", options=['D', 'W', 'M'])
s = request.security("syminfo.tickerid", i_res, close)
plot(s)
Returns Value of input variable.
Arguments
- defval (const string) Determines the default value of the input variable proposed in the script’s “Settings/Inputs” tab, from where the user can change it. When a list of values is used with the options argument, the value must be one of them.
- title (const string) Title of the input. If not specified, the variable name is used as the input’s title. If the title is specified, but it is empty, the name will be an empty string.
- options (tuple of const string values: [val1, val2, …]) A list of options to choose from.
- tooltip (const string) The string that will be shown to the user when hovering over the tooltip icon.
- inline (const string) Combines all the input calls using the same argument in one line. The string used as an argument is not displayed. It is only used to identify inputs belonging to the same line.
- group (const string) Creates a header above all inputs using the same group argument string. The string is also used as the header’s text.
- confirm (const bool) If true, then user will be asked to confirm input value before indicator is added to chart. Default value is false.
Remarks Result of input.timeframe function always should be assigned to a variable, see examples above.
See also
### input.integer
Not available.
### input.resolution
Not available.
## ta
### ta.alma
Arnaud Legoux Moving Average. It uses Gaussian distribution as weights for moving average.
ta.alma(series, length, offset, sigma)
ta.alma(series, length, offset, sigma, floor)
**Example**
```pine
plot(ta.alma(close, 9, 0.85, 6))
// same on pine, but much less efficient
pine_alma(series, windowsize, offset, sigma) =>
m = offset * (windowsize - 1)
//m = math.floor(offset * (windowsize - 1)) // Used as m when math.floor=true
s = windowsize / sigma
norm = 0.0
sum = 0.0
for i = 0 to windowsize - 1
weight = math.exp(-1 * math.pow(i - m, 2) / (2 * math.pow(s, 2)))
norm := norm + weight
sum := sum + series[windowsize - i - 1] * weight
sum / norm
plot(pine_alma(close, 9, 0.85, 6))
Returns Arnaud Legoux Moving Average.
Arguments
- series (series int/float) Series of values to process.
- length (series int) Number of bars (length).
- offset (simple int/float) Controls tradeoff between smoothness (closer to 1) and responsiveness (closer to 0).
- sigma (simple int/float) Changes the smoothness of ALMA. The larger sigma the smoother ALMA.
- floor (simple bool) An optional argument. Specifies whether the offset calculation is floored before ALMA is calculated. Default value is false.
See also
### ta.sma
The sma function returns the moving average, that is the sum of last y values of x, divided by y.
ta.sma(source, length)
**Example**
```pine
plot(ta.sma(close, 15))
// same on pine, but much less efficient
pine_sma(x, y) =>
sum = 0.0
for i = 0 to y - 1
sum := sum + x[i] / y
sum
plot(pine_sma(close, 15))
Returns
Simple moving average of source for length bars back.
Arguments
- source (series int/float) Series of values to process.
- length (series int) Number of bars (length).
See also
### ta.cog
The cog (center of gravity) is an indicator based on statistics and the Fibonacci golden ratio.
ta.cog(source, length)
**Example**
```pine
plot(ta.cog(close, 10))
// the same on pine
pine_cog(source, length) =>
sum = math.sum(source, length)
num = 0.0
for i = 0 to length - 1
price = source[i]
num := num + price * (i + 1)
-num / sum
plot(pine_cog(close, 10))
Returns Center of Gravity.
Arguments
- source (series int/float) Series of values to process.
- length (series int) Number of bars (length).
See also
### ta.dev
Measure of difference between the series and it's ta.sma
ta.dev(source, length)
**Example**
```pine
plot(ta.dev(close, 10))
// the same on pine
pine_dev(source, length) =>
mean = ta.sma(source, length)
sum = 0.0
for i = 0 to length - 1
val = source[i]
sum := sum + math.abs(val - mean)
dev = sum/length
plot(pine_dev(close, 10))
Returns
Deviation of source for length bars back.
Arguments
- source (series int/float) Series of values to process.
- length (series int) Number of bars (length).
See also
### ta.stdev
ta.stdev(source, length, biased)
**Example**
```pine
plot(ta.stdev(close, 5))
//the same on pine
isZero(val, eps) => math.abs(val) <= eps
SUM(fst, snd) =>
EPS = 1e-10
res = fst + snd
if isZero(res, EPS)
res := 0
else
if not isZero(res, 1e-4)
res := res
else
15
pine_stdev(src, length) =>
avg = ta.sma(src, length)
sumOfSquareDeviations = 0.0
for i = 0 to length - 1
sum = SUM(src[i], -avg)
sumOfSquareDeviations := sumOfSquareDeviations + sum * sum
stdev = math.sqrt(sumOfSquareDeviations / length)
plot(pine_stdev(close, 5))
Returns Standard deviation.
Arguments
- source (series int/float) Series of values to process.
- length (series int) Number of bars (length).
- biased (series bool) Determines which estimate should be used. Optional. The default is true.
Remarks
If biased is true, function will calculate using a biased estimate of the entire population, if false - unbiased estimate of a sample.
See also
### ta.ema
The ema function returns the exponentially weighted moving average. In ema weighting factors decrease exponentially. It calculates by using a formula: EMA = alpha * source + (1 - alpha) * EMA[1], where alpha = 2 / (length + 1).
ta.ema(source, length)
**Example**
```pine
plot(ta.ema(close, 15))
//the same on pine
pine_ema(src, length) =>
alpha = 2 / (length + 1)
sum = 0.0
sum := na(sum[1]) ? src : alpha * src + (1 - alpha) * nz(sum[1])
plot(pine_ema(close,15))
Returns
Exponential moving average of source with alpha = 2 / (length + 1).
Arguments
- source (series int/float) Series of values to process.
- length (simple int) Number of bars (length).
Remarks Please note that using this variable/function can cause indicator repainting.
See also
### ta.wma
The wma function returns weighted moving average of ```source``` for ```length``` bars back. In wma weighting factors decrease in arithmetical progression.
ta.wma(source, length)
**Example**
```pine
plot(ta.wma(close, 15))
// same on pine, but much less efficient
pine_wma(x, y) =>
norm = 0.0
sum = 0.0
for i = 0 to y - 1
weight = (y - i) * y
norm := norm + weight
sum := sum + x[i] * weight
sum / norm
plot(pine_wma(close, 15))
Returns
Weighted moving average of source for length bars back.
Arguments
- source (series int/float) Series of values to process.
- length (series int) Number of bars (length).
See also
### ta.swma
Symmetrically weighted moving average with fixed length: 4. Weights: [1/6, 2/6, 2/6, 1/6].
ta.swma(source)
**Example**
```pine
plot(ta.swma(close))
// same on pine, but less efficient
pine_swma(x) =>
x[3] * 1 / 6 + x[2] * 2 / 6 + x[1] * 2 / 6 + x[0] * 1 / 6
plot(pine_swma(close))
Returns Symmetrically weighted moving average.
Arguments
- source (series int/float) Source series.
See also
### ta.hma
The hma function returns the Hull Moving Average.
ta.hma(source, length)
**Example**
```pine
src = input(defval=close, title="Source")
length = input(defval=9, title="Length")
hmaBuildIn = ta.hma(src, length)
plot(hmaBuildIn, title="Hull MA", color=#674EA7)
Returns Hull moving average of ‘source’ for ‘length’ bars back.
Arguments
- source (series int/float) Series of values to process.
- length (simple int) Number of bars.
See also
### ta.rma
Moving average used in RSI. It is the exponentially weighted moving average with alpha = 1 / length.
ta.rma(source, length)
**Example**
```pine
plot(ta.rma(close, 15))
//the same on pine
pine_rma(src, length) =>
alpha = 1/length
sum = 0.0
sum := na(sum[1]) ? ta.sma(src, length) : alpha * src + (1 - alpha) * nz(sum[1])
plot(pine_rma(close, 15))
Returns
Exponential moving average of source with alpha = 1 / length.
Arguments
- source (series int/float) Series of values to process.
- length (simple int) Number of bars (length).
See also
### ta.rsi
Relative strength index. It is calculated using the ```ta.rma()``` of upward and downward changes of ```source``` over the last ```length``` bars.
ta.rsi(source, length)
**Example**
```pine
plot(ta.rsi(close, 7))
// same on pine, but less efficient
pine_rsi(x, y) =>
u = math.max(x - x[1], 0) // upward ta.change
d = math.max(x[1] - x, 0) // downward ta.change
rs = ta.rma(u, y) / ta.rma(d, y)
res = 100 - 100 / (1 + rs)
res
plot(pine_rsi(close, 7))
Returns Relative strength index.(RSI)
Arguments
- source (series int/float) Series of values to process.
- length (simple int) Number of bars (length).
See also
### ta.tsi
True strength index. It uses moving averages of the underlying momentum of a financial instrument.
ta.tsi(source, short_length, long_length)
**Returns**
True strength index. A value in range [-1, 1].
**Arguments**
- ```source``` (series int/float) Source series.
- ```short_length``` (simple int) Short length.
- ```long_length``` (simple int) Long length.
### ta.roc
Function roc (rate of change) showing the difference between current value of ```source``` and the value of ```source``` that was ```length``` days ago.
It is calculated by the formula: 100 * change(src, length) / src[length].
ta.roc(source, length)
**Returns**
The rate of change of ```source``` for ```length``` bars back.
**Arguments**
- ```source``` (series int/float) Series of values to process.
- ```length``` (series int) Number of bars (length).
### ta.range
Returns the difference between the min and max values in a series.
ta.range(source, length)
**Returns**
The difference between the min and max values in the series.
**Arguments**
- ```source``` (series int/float) Series of values to process.
- ```length``` (series int) Number of bars (length).
### ta.macd
MACD (moving average convergence/divergence). It is supposed to reveal changes in the strength, direction, momentum, and duration of a trend in a stock's price.
ta.macd(source, fastlen, slowlen, siglen)
**Example**
```pine
[macdLine, signalLine, histLine] = ta.macd(close, 12, 26, 9)
plot(macdLine, color=color.blue)
plot(signalLine, color=color.orange)
plot(histLine, color=color.red, style=plot.style_histogram)
If you need only one value, use placeholders ‘_’ like this:
Example
[_, signalLine, _] = ta.macd(close, 12, 26, 9)
plot(signalLine, color=color.orange)
Returns Tuple of three MACD series: MACD line, signal line and histogram line.
Arguments
- source (series int/float) Series of values to process.
- fastlen (simple int) Fast Length argument.
- slowlen (simple int) Slow Length argument.
- siglen (simple int) Signal Length argument.
See also
### ta.mode
Returns the mode of the series. If there are several values with the same frequency, it returns the smallest value.
ta.mode(source, length)
**Returns**
The mode of the series.
**Arguments**
- ```source``` (series int/float) Series of values to process.
- ```length``` (series int) Number of bars (length).
### ta.median
Returns the median of the series.
ta.median(source, length)
**Returns**
The median of the series.
**Arguments**
- ```source``` (series int/float) Series of values to process.
- ```length``` (series int) Number of bars (length).
### ta.linreg
Linear regression curve. A line that best fits the prices specified over a user-defined time period. It is calculated using the least squares method. The result of this function is calculated using the formula: linreg = intercept + slope * (length - 1 - offset), where intercept and slope are the values calculated with the least squares method on ```source``` series.
ta.linreg(source, length, offset)
**Returns**
Linear regression curve.
**Arguments**
- ```source``` (series int/float) Source series.
- ```length``` (series int)
- ```offset``` (simple int) Offset.
### ta.bb
Bollinger Bands. A Bollinger Band is a technical analysis tool defined by a set of lines plotted two standard deviations (positively and negatively) away from a simple moving average (SMA) of the security's price, but can be adjusted to user preferences.
ta.bb(series, length, mult)
**Example**
```pine
[middle, upper, lower] = ta.bb(close, 5, 4)
plot(middle, color=color.yellow)
plot(upper, color=color.yellow)
plot(lower, color=color.yellow)
// the same on pine
f_bb(src, length, mult) =>
float basis = ta.sma(src, length)
float dev = mult * ta.stdev(src, length)
[basis, basis + dev, basis - dev]
[pineMiddle, pineUpper, pineLower] = f_bb(close, 5, 4)
plot(pineMiddle)
plot(pineUpper)
plot(pineLower)
Returns Bollinger Bands.
Arguments
- series (series int/float) Series of values to process.
- length (series int) Number of bars (length).
- mult (simple int/float) Standard deviation factor.
See also
### ta.bbw
Bollinger Bands Width. The Bollinger Band Width is the difference between the upper and the lower Bollinger Bands divided by the middle band.
ta.bbw(series, length, mult)
**Example**
```pine
plot(ta.bbw(close, 5, 4), color=color.yellow)
// the same on pine
f_bbw(src, length, mult) =>
float basis = ta.sma(src, length)
float dev = mult * ta.stdev(src, length)
((basis + dev) - (basis - dev)) / basis
plot(f_bbw(close, 5, 4))
Returns Bollinger Bands Width.
Arguments
- series (series int/float) Series of values to process.
- length (series int) Number of bars (length).
- mult (simple int/float) Standard deviation factor.
See also
### ta.cci
The CCI (commodity channel index) is calculated as the difference between the typical price of a commodity and its simple moving average, divided by the mean absolute deviation of the typical price. The index is scaled by an inverse factor of 0.015 to provide more readable numbers.
ta.cci(source, length)
**Returns**
Commodity channel index of source for length bars back.
**Arguments**
- ```source``` (series int/float) Series of values to process.
- ```length``` (series int) Number of bars (length).
### ta.change
The difference between the current value and the previous value, source - source [length].
ta.change(source, length)
ta.change(source)
**Returns**
The result of subtraction.
**Arguments**
- ```source``` (series int/float) Source series.
- ```length``` (series int) Offset from the current bar to the previous bar. Optional, if not given, length=1 is used.
**See also**
```ta.mom``` ```ta.cross```
### ta.mom
Momentum of ```source``` price and ```source``` price ```length``` bars ago. This is simply a difference: source - source[length].
ta.mom(source, length)
**Returns**
Momentum of ```source``` price and ```source``` price ```length``` bars ago.
**Arguments**
- ```source``` (series int/float) Series of values to process.
- ```length``` (series int) Offset from the current bar to the previous bar.
**See also**
```ta.change```
### ta.cmo
Chande Momentum Oscillator. Calculates the difference between the sum of recent gains and the sum of recent losses and then divides the result by the sum of all price movement over the same period.
ta.cmo(series, length)
**Example**
```pine
plot(ta.cmo(close, 5), color=color.yellow)
// the same on pine
f_cmo(src, length) =>
float mom = ta.change(src)
float sm1 = math.sum((mom >= 0) ? mom : 0.0, length)
float sm2 = math.sum((mom >= 0) ? 0.0 : -mom, length)
100 * (sm1 - sm2) / (sm1 + sm2)
plot(f_cmo(close, 5))
Returns Chande Momentum Oscillator.
Arguments
- series (series int/float) Series of values to process.
- length (series int) Number of bars (length).
See also
### ta.percentile_linear_interpolation
Calculates percentile using method of linear interpolation between the two nearest ranks.
ta.percentile_linear_interpolation(source, length, percentage)
**Returns**
P-th percentile of ```source``` series for ```length``` bars back.
**Arguments**
- ```source``` (series int/float) Series of values to process (source).
- ```length``` (series int) Number of bars back (length).
- ```percentage``` (simple int/float) Percentage, a number from range 0..100.
**Remarks**
Note that a percentile calculated using this method will NOT always be a member of the input data set.
**See also**
```ta.percentile_nearest_rank```
### ta.percentile_nearest_rank
Calculates percentile using method of Nearest Rank.
ta.percentile_nearest_rank(source, length, percentage)
**Returns**
P-th percentile of ```source``` series for ```length``` bars back.
**Arguments**
- ```source``` (series int/float) Series of values to process (source).
- ```length``` (series int) Number of bars back (length).
- ```percentage``` (simple int/float) Percentage, a number from range 0..100.
**Remarks**
Using the Nearest Rank method on lengths less than 100 bars back can result in the same number being used for more than one percentile.
A percentile calculated using the Nearest Rank method will always be a member of the input data set.
The 100th percentile is defined to be the largest value in the input data set.
**See also**
```ta.percentile_linear_interpolation```
### ta.percentrank
Percent rank is the percents of how many previous values was less than or equal to the current value of given series.
ta.percentrank(source, length)
**Returns**
Percent rank of ```source``` for ```length``` bars back.
**Arguments**
- ```source``` (series int/float) Series of values to process.
- ```length``` (series int) Number of bars (length).
### ta.variance
Variance is the expectation of the squared deviation of a series from its mean (ta.sma), and it informally measures how far a set of numbers are spread out from their mean.
ta.variance(source, length, biased)
**Returns**
Variance of `source` for `length` bars back.
**Arguments**
- ```source``` (series int/float) Series of values to process.
- ```length``` (series int) Number of bars (length).
- ```biased``` (series bool) Determines which estimate should be used. Optional. The default is true.
**Remarks**
If ```biased``` is true, function will calculate using a biased estimate of the entire population, if false - unbiased estimate of a sample.
**See also**
```ta.dev``` ```ta.stdev```
### ta.tr
ta.tr(handle_na)
**Returns**
True range. It is math.max(high - low, math.abs(high - close[1]), math.abs(low - close[1])).
**Arguments**
- ```handle_na``` (simple bool) How NaN values are handled. if true, and previous day's close is NaN then tr would be calculated as current day high-low. Otherwise (if false) tr would return NaN in such cases. Also note, that ta.atr uses ta.tr(true).
**Remarks**
```ta.tr(false)``` is exactly the same as ```ta.tr```.
**See also**
```ta.atr```
### ta.mfi
Money Flow Index. The Money Flow Index (MFI) is a technical oscillator that uses price and volume for identifying overbought or oversold conditions in an asset.
ta.mfi(series, length)
**Example**
```pine
plot(ta.mfi(hlc3, 14), color=color.yellow)
// the same on pine
pine_mfi(src, length) =>
float upper = math.sum(volume * (ta.change(src) <= 0.0 ? 0.0 : src), length)
float lower = math.sum(volume * (ta.change(src) >= 0.0 ? 0.0 : src), length)
mfi = 100.0 - (100.0 / (1.0 + upper / lower))
mfi
plot(pine_mfi(hlc3, 14))
Returns Money Flow Index.
Arguments
- series (series int/float) Series of values to process.
- length (series int) Number of bars (length).
See also
### ta.kc
Keltner Channels. Keltner channel is a technical analysis indicator showing a central moving average line plus channel lines at a distance above and below.
ta.kc(series, length, mult)
ta.kc(series, length, mult, useTrueRange)
**Example**
```pine
[middle, upper, lower] = ta.kc(close, 5, 4)
plot(middle, color=color.yellow)
plot(upper, color=color.yellow)
plot(lower, color=color.yellow)
// the same on pine
f_kc(src, length, mult, useTrueRange) =>
float basis = ta.ema(src, length)
float span = (useTrueRange) ? ta.tr : (high - low)
float rangeEma = ta.ema(span, length)
[basis, basis + rangeEma * mult, basis - rangeEma * mult]
[pineMiddle, pineUpper, pineLower] = f_kc(close, 5, 4, true)
plot(pineMiddle)
plot(pineUpper)
plot(pineLower)
Returns Keltner Channels.
Arguments
- series (series int/float) Series of values to process.
- length (simple int) Number of bars (length).
- mult (simple int/float) Standard deviation factor.
- useTrueRange (simple bool) An optional argument. Specifies if True Range is used; default is true. If the value is false, the range will be calculated with the expression (high - low).
See also
### ta.kcw
Keltner Channels Width. The Keltner Channels Width is the difference between the upper and the lower Keltner Channels divided by the middle channel.
ta.kcw(series, length, mult)
ta.kcw(series, length, mult, useTrueRange)
**Example**
```pine
plot(ta.kcw(close, 5, 4), color=color.yellow)
// the same on pine
f_kcw(src, length, mult, useTrueRange) =>
float basis = ta.ema(src, length)
float span = (useTrueRange) ? ta.tr : (high - low)
float rangeEma = ta.ema(span, length)
((basis + rangeEma * mult) - (basis - rangeEma * mult)) / basis
plot(f_kcw(close, 5, 4, true))
Returns Keltner Channels Width.
Arguments
- series (series int/float) Series of values to process.
- length (simple int) Number of bars (length).
- mult (simple int/float) Standard deviation factor.
- useTrueRange (simple bool) An optional argument. Specifies if True Range is used; default is true. If the value is false, the range will be calculated with the expression (high - low).
See also
### ta.correlation
Correlation coefficient. Describes the degree to which two series tend to deviate from their ta.sma values.
ta.correlation(source1, source2, length)
**Returns**
Correlation coefficient.
**Arguments**
- ```source1``` (series int/float) Source series.
- ```source2``` (series int/float) Target series.
- ```length``` (series int) Length (number of bars back).
**See also**
```request.security```
### ta.cross
ta.cross(source1, source2)
**Returns**
true if two series have crossed each other, otherwise false.
**Arguments**
- ```source1``` (series int/float) First data series.
- ```source2``` (series int/float) Second data series.
**See also**
```ta.change```
### ta.crossover
The ```source1```-series is defined as having crossed over ```source2``` -series if, on the current bar, the value of ```source1``` is greater than the value of ```source2```, and on the previous bar, the value of ```source1``` was less than the value of ```source2```.
ta.crossover(source1, source2)
**Returns**
true if ```source1``` crossed over ```source2``` otherwise false.
**Arguments**
- ```source1``` (series int/float) First data series.
- ```source2``` (series int/float) Second data series.
### ta.crossunder
The ```source1``` -series is defined as having crossed under ```source2``` -series if, on the current bar, the value of ```source1``` is less than the value of ```source2```, and on the previous bar, the value of ```source1``` was greater than the value of ```source2```.
ta.crossunder(source1, source2)
**Returns**
true if ```source1``` crossed under ```source2``` otherwise false.
**Arguments**
- ```source1``` (series int/float) First data series.
- ```source2``` (series int/float) Second data series.
### ta.atr
Function atr (average true range) returns the RMA of true range. True range is max(high - low, abs(high - close[1]), abs(low - close[1])).
ta.atr(length)
**Example**
```pine
plot(ta.atr(14))
//the same on pine
pine_atr(length) =>
trueRange = na(high[1])? high-low : math.max(math.max(high - low, math.abs(high - close[1])), math.abs(low - close[1]))
//true range can be also calculated with ta.tr(true)
ta.rma(trueRange, length)
plot(pine_atr(14))
Returns Average true range. (ATR)
Arguments length (simple int) Length (number of bars back).
See also
### ta.sar
Parabolic SAR (parabolic stop and reverse) is a method devised by J. Welles Wilder, Jr., to find potential reversals in the market price direction of traded goods.
ta.sar(start, inc, max)
**Example**
```pine
plot(ta.sar(0.02, 0.02, 0.2), style=plot.style_cross, linewidth=3)
// The same on Pine
pine_sar(start, inc, max) =>
var float result = na
var float maxMin = na
var float acceleration = na
var bool isBelow = na
bool isFirstTrendBar = false
if bar_index == 1
if close > close[1]
isBelow := true
maxMin := high
result := low[1]
else
isBelow := false
maxMin := low
result := high[1]
isFirstTrendBar := true
acceleration := start
result := result + acceleration * (maxMin - result)
if isBelow
if result > low
isFirstTrendBar := true
isBelow := false
result := math.max(high, maxMin)
maxMin := low
acceleration := start
else
if result < high
isFirstTrendBar := true
isBelow := true
result := math.min(low, maxMin)
maxMin := high
acceleration := start
if not isFirstTrendBar
if isBelow
if high > maxMin
maxMin := high
acceleration := math.min(acceleration + inc, max)
else
if low < maxMin
maxMin := low
acceleration := math.min(acceleration + inc, max)
if isBelow
result := math.min(result, low[1])
if bar_index > 1
result := math.min(result, low[2])
else
result := math.max(result, high[1])
if bar_index > 1
result := math.max(result, high[2])
result
plot(pine_sar(0.02, 0.02, 0.2), style=plot.style_cross, linewidth=3)
Returns Parabolic SAR.
Arguments
- start (simple int/float) Start.
- inc (simple int/float) Increment.
- max (simple int/float) Maximum.
ta.barssince
Counts the number of bars since the last time the condition was true.
ta.barssince(condition)
Example
// get number of bars since last color.green bar
plot(ta.barssince(close >= open))
Returns Number of bars since condition was true.
Remarks If the condition has never been met prior to the current bar, the function returns na. Please note that using this variable/function can cause indicator repainting.
See also
### ta.cum
Cumulative (total) sum of ```source```. In other words it's a sum of all elements of ```source```.
ta.cum(source)
**Returns**
Total sum series.
**Arguments**
- ```source``` (series int/float)
**See also**
```math.sum```
### ta.dmi
The dmi function returns the directional movement index(DMI).
ta.dmi(diLength, adxSmoothing)
**Example**
```pine
len = input.int(17, minval=1, title="DI Length")
lensig = input.int(14, title="ADX Smoothing", minval=1, maxval=50)
[diplus, diminus, adx] = ta.dmi(len, lensig)
plot(adx, color=color.red, title="ADX")
plot(diplus, color=color.blue, title="+DI")
plot(diminus, color=color.orange, title="-DI")
Returns Tuple of three DMI series: Positive Directional Movement (+DI), Negative Directional Movement (-DI) and Average Directional Movement Index (ADX).
Arguments
- diLength (simple int) DI Period.
- adxSmoothing (simple int) ADX Smoothing Period.
See also
### ta.falling
Test if the ```source``` series is now falling for ```length``` bars long.
ta.falling(source, length)
**Returns**
true if current ```source``` value is less than any previous ```source``` value for ```length``` bars back, false otherwise.
**Arguments**
- ```source``` (series int/float) Series of values to process.
- ```length``` (series int) Number of bars (length).
**See also**
```ta.rising```
### ta.rising
Test if the ```source``` series is now rising for ```length``` bars long.
ta.rising(source, length)
**Returns**
true if current ```source``` is greater than any previous ```source``` for ```length``` bars back, false otherwise.
**Arguments**
- ```source``` (series int/float) Series of values to process.
- ```length``` (series int) Number of bars (length).
**See also**
```ta.falling```
### ta.pivothigh
This function returns price of the pivot high point. It returns 'NaN', if there was no pivot high point.
ta.pivothigh(source, leftbars, rightbars)
ta.pivothigh(leftbars, rightbars)
**Example**
```pine
leftBars = input(2)
rightBars=input(2)
ph = ta.pivothigh(leftBars, rightBars)
plot(ph, style=plot.style_cross, linewidth=3, color= color.red, offset=-rightBars)
Returns Price of the point or ‘NaN’.
Arguments
- source (series int/float) An optional argument. Data series to calculate the value. ‘High’ by default.
- leftbars (series int/float) Left strength.
- rightbars (series int/float) Right length.
Remarks If arguments ‘leftbars’ or ‘rightbars’ are series you should use max_bars_back function for the ‘source’ variable.
ta.pivotlow
This function returns price of the pivot low point. It returns ‘NaN’, if there was no pivot low point.
ta.pivotlow(source, leftbars, rightbars)
ta.pivotlow(leftbars, rightbars)
Example
leftBars = input(2)
rightBars=input(2)
pl = ta.pivotlow(close, leftBars, rightBars)
plot(pl, style=plot.style_cross, linewidth=3, color= color.blue, offset=-rightBars)
Returns Price of the point or ‘NaN’.
Arguments
- source (series int/float) An optional argument. Data series to calculate the value. “Low” by default.
- leftbars (series int/float) Left strength.
- rightbars (series int/float) Right length.
Remarks If arguments ‘leftbars’ or ‘rightbars’ are series you should use max_bars_back function for the ‘source’ variable.
ta.highest
Highest value for a given number of bars back.
ta.highest(source, length)
ta.highest(length)
Returns Highest value in the series.
Arguments
- source (series int/float) Series of values to process.
- length (series int) Number of bars (length).
Remarks
Two args version: source is a series and length is the number of bars back.
One arg version: length is the number of bars back. Algorithm uses high as a source series.
See also
### ta.highestbars
Highest value offset for a given number of bars back.
ta.highestbars(source, length)
ta.highestbars(length)
**Returns**
Offset to the highest bar.
**Arguments**
- ```source``` (series int/float) Series of values to process.
- ```length``` (series int) Number of bars (length).
**Remarks**
Two args version: ```source``` is a series and ```length``` is the number of bars back.
One arg version: ```length``` is the number of bars back. Algorithm uses high as a ```source``` series.
**See also**
```ta.lowest``` ```ta.highest``` ```ta.lowestbars``` ```ta.barssince``` ```ta.valuewhen```
### ta.stoch
Stochastic. It is calculated by a formula: 100 * (close - lowest(low, length)) / (highest(high, length) - lowest(low, length)).
ta.stoch(source, high, low, length)
**Returns**
Stochastic.
**Arguments**
- ```source``` (series int/float) Source series.
- ```high``` (series int/float) Series of high.
- ```low``` (series int/float) Series of low.
- ```length``` (series int) Length (number of bars back).
**See also**
```ta.cog```
### ta.supertrend
The Supertrend Indicator. The Supertrend is a trend following indicator.
ta.supertrend(factor, atrPeriod)
**Example**
```pine
//@version=5
indicator("Pine Script™ Supertrend")
[supertrend, direction] = ta.supertrend(3, 10)
plot(direction < 0 ? supertrend : na, "Up direction", color = color.green, style=plot.style_linebr)
plot(direction > 0 ? supertrend : na, "Down direction", color = color.red, style=plot.style_linebr)
// The same on Pine Script™
pine_supertrend(factor, atrPeriod) =>
src = hl2
atr = ta.atr(atrPeriod)
upperBand = src + factor * atr
lowerBand = src - factor * atr
prevLowerBand = nz(lowerBand[1])
prevUpperBand = nz(upperBand[1])
lowerBand := lowerBand > prevLowerBand or close[1] < prevLowerBand ? lowerBand : prevLowerBand
upperBand := upperBand < prevUpperBand or close[1] > prevUpperBand ? upperBand : prevUpperBand
int direction = na
float superTrend = na
prevSuperTrend = superTrend[1]
if na(atr[1])
direction := 1
else if prevSuperTrend == prevUpperBand
direction := close > upperBand ? -1 : 1
else
direction := close < lowerBand ? 1 : -1
superTrend := direction == -1 ? lowerBand : upperBand
[superTrend, direction]
[pineSupertrend, pineDirection] = pine_supertrend(3, 10)
plot(pineDirection < 0 ? pineSupertrend : na, "Up direction", color = color.green, style=plot.style_linebr)
plot(pineDirection > 0 ? pineSupertrend : na, "Down direction", color = color.red, style=plot.style_linebr)
Returns Tuple of two supertrend series: supertrend line and direction of trend. Possible values are 1 (down direction) and -1 (up direction).
Arguments
- factor (series int/float) The multiplier by which the ATR will get multiplied.
- atrPeriod (simple int) Length of ATR
See also
### ta.lowest
Lowest value for a given number of bars back.
ta.lowest(source, length)
ta.lowest(length)
**Returns**
Lowest value in the series.
**Arguments**
- ```source``` (series int/float) Series of values to process.
- ```length``` (series int) Number of bars (length).
**Remarks**
Two args version: ```source``` is a series and ```length``` is the number of bars back.
One arg version: ```length``` is the number of bars back. Algorithm uses low as a ```source``` series.
**See also**
```ta.highest``` ```ta.lowestbars``` ```ta.highestbars``` ```ta.valuewhen``` ```ta.barssince```
### ta.lowestbars
Lowest value offset for a given number of bars back.
ta.lowestbars(source, length)
ta.lowestbars(length)
**Returns**
Offset to the lowest bar.
**Arguments**
- ```source``` (series int/float) Series of values to process.
- ```length``` (series int) Number of bars back.
**Remarks**
Two args version: ```source``` is a series and ```length``` is the number of bars back.
One arg version: ```length``` is the number of bars back. Algorithm uses low as a ```source``` series.
**See also**
```ta.lowest``` ```ta.highest``` ```ta.highestbars``` ```ta.barssince``` ```ta.valuewhen```
### ta.valuewhen
Returns the value of the "source" series on the bar where the "condition" was true on the nth most recent occurrence.
ta.valuewhen(condition, source, occurrence)
**Example**
```pine
slow = ta.sma(close, 7)
fast = ta.sma(close, 14)
// Get value of `close` on second most recent cross
plot(ta.valuewhen(ta.cross(slow, fast), close, 1))
Arguments
- condition (series bool) The condition to search for.
- source (series int/float/bool/color) The value to be returned from the bar where the condition is met.
- occurrence (simple int) The occurrence of the condition. The numbering starts from 0 and goes back in time, so “0” is the most recent occurrence of “condition”, “1” is the second most recent and so forth. Must be an integer >= 0.
Remarks This function requires execution on every bar. It is not recommended to use it inside a for or while loop structure, where its behavior can be unexpected. Please note that using this function can cause indicator repainting.
See also
### ta.vwap
Volume weighted average price.
ta.vwap(source)
**Returns**
Volume weighted average.
**Arguments**
- ```source``` (series int/float) Source series.
**See also**
```ta.vwap```
### ta.vwma
The vwma function returns volume-weighted moving average of ```source``` for ```length``` bars back. It is the same as: sma(source * volume, length) / sma(volume, length).
ta.vwma(source, length)
**Example**
```pine
plot(ta.vwma(close, 15))
// same on pine, but less efficient
pine_vwma(x, y) =>
ta.sma(x * volume, y) / ta.sma(volume, y)
plot(pine_vwma(close, 15))
Returns
Volume-weighted moving average of source for length bars back.
Arguments
- source (series int/float) Series of values to process.
- length (series int) Number of bars (length).
See also
### ta.wpr
Williams %R. The oscillator shows the current closing price in relation to the high and low of the past "period of time" bars.
ta.wpr(length)
**Example**
```pine
plot(ta.wpr(14), title="%R", color=color.new(#ff6d00, 0))
Returns Williams %R.
Arguments
- length (series int) Number of bars.
See also
## plot
### plot
Plots a series of data on the chart.
plot(series, title, color, linewidth, style, trackprice, histbase, offset, join, editable, show_last, display)
**Example**
```pine
plot(high+low, title='Title', color=color.new(#00ffaa, 70), linewidth=2, style=plot.style_area, offset=15, trackprice=true)
// You may fill the background between any two plots with a fill() function:
p1 = plot(open)
p2 = plot(close)
fill(p1, p2, color=color.new(color.green, 90))
Returns A plot object, that can be used in fill.
Arguments
- series (series int/float) Series of data to be plotted. Required argument.
- title (const string) Title of the plot.
- color (series color) Color of the plot. You can use constants like ‘color=color.red’ or ‘color=#ff001a’ as well as complex expressions like ‘color = close >= open ? color.green : color.red’. Optional argument.
- linewidth (input int) Width of the plotted line. Default value is 1. Not applicable to every style.
- style (plot_style) Type of plot. Possible values are: plot.style_line, plot.style_stepline, plot.style_stepline_diamond, plot.style_histogram, plot.style_cross, plot.style_area, plot.style_columns, plot.style_circles, plot.style_linebr, plot.style_areabr. Default value is plot.style_line.
- trackprice (input bool) If true then a horizontal price line will be shown at the level of the last indicator value. Default is false.
- histbase (input int/float) The price value used as the reference level when rendering plot with plot.style_histogram, plot.style_columns or plot.style_area style. Default is 0.0.
- offset (series int) Shifts the plot to the left or to the right on the given number of bars. Default is 0.
- join (input bool) If true then plot points will be joined with line, applicable only to plot.style_cross and plot.style_circles styles. Default is false.
- editable (const bool) If true then plot style will be editable in Format dialog. Default is true.
- show_last (input int) If set, defines the number of bars (from the last bar back to the past) to plot on chart.
- display (plot_display) Controls where the plot is displayed. Possible values are: display.none, display.all. Default is display.all.
- overlay (const bool) is the extension argument of FMZ platform, it is used to set the current function to be displayed on the main image (set to true) or sub-image (set to false), the default value is false. If this argument is not specified, it will be set according to the overlay argument in strategy or indicator, if strategy or indicator does not set the overlay argument, it will be processed according to the default arguments.
See also
### plotshape
Plots visual shapes on the chart.
plotshape(series, title, style, location, color, offset, text, textcolor, editable, size, show_last, display)
**Example**
```pine
data = close >= open
plotshape(data, style=shape.xcross)
Arguments
- series (series bool) Series of data to be plotted as shapes. Series is treated as a series of boolean values for all location values except location.absolute. Required argument.
- title (const string) Title of the plot.
- style (input string) Type of plot. Possible values are: shape.xcross, shape.cross, shape.triangleup, shape.triangledown, shape.flag, shape.circle, shape.arrowup, shape.arrowdown, shape.labelup, shape.labeldown, shape.square, shape.diamond. Default value is shape.xcross.
- location (input string) Location of shapes on the chart. Possible values are: location.abovebar, location.belowbar, location.top, location.bottom, location.absolute. Default value is location.abovebar.
- color (series color) Color of the shapes. You can use constants like ‘color=color.red’ or ‘color=#ff001a’ as well as complex expressions like ‘color = close >= open ? color.green : color.red’. Optional argument.
- offset (series int) Shifts shapes to the left or to the right on the given number of bars. Default is 0.
- text (const string) Text to display with the shape. You can use multiline text, to separate lines use ‘\n’ escape sequence. Example: ‘line one\nline two’.
- textcolor (series color) Color of the text. You can use constants like ‘textcolor=color.red’ or ‘textcolor=#ff001a’ as well as complex expressions like ‘textcolor = close >= open ? color.green : color.red’. Optional argument.
- editable (const bool) If true then plotshape style will be editable in Format dialog. Default is true.
- show_last (input int) If set, defines the number of shapes (from the last bar back to the past) to plot on chart.
- size (const string) Size of shapes on the chart. Possible values are: size.auto, size.tiny, size.small, size.normal, size.large, size.huge. Default is size.auto.
- display (plot_display) Controls where the plot is displayed. Possible values are: display.none, display.all. Default is display.all.
- overlay (const bool) is the extension argument of FMZ platform, it is used to set the current function to be displayed on the main image (set to true) or sub-image (set to false), the default value is false. If this argument is not specified, it will be set according to the overlay argument in strategy or indicator, if strategy or indicator does not set the overlay argument, it will be processed according to the default arguments.
See also
### plotchar
Plots visual shapes using any given one Unicode character on the chart.
plotchar(series, title, char, location, color, offset, text, textcolor, editable, size, show_last, display)
**Example**
```pine
data = close >= open
plotchar(data, char='❄')
Arguments
- series (series bool) Series of data to be plotted as shapes. Series is treated as a series of boolean values for all location values except location.absolute. Required argument.
- title (const string) Title of the plot.
- char (input string) Character to use as a visual shape.
- location (input string) Location of shapes on the chart. Possible values are: location.abovebar, location.belowbar, location.top, location.bottom, location.absolute. Default value is location.abovebar.
- color (series color) Color of the shapes. You can use constants like ‘color=color.red’ or ‘color=#ff001a’ as well as complex expressions like ‘color = close >= open ? color.green : color.red’. Optional argument.
- offset (series int) Shifts shapes to the left or to the right on the given number of bars. Default is 0.
- text (const string) Text to display with the shape. You can use multiline text, to separate lines use ‘\n’ escape sequence. Example: ‘line one\nline two’.
- textcolor (series color) Color of the text. You can use constants like ‘textcolor=color.red’ or ‘textcolor=#ff001a’ as well as complex expressions like ‘textcolor = close >= open ? color.green : color.red’. Optional argument.
- editable (const bool) If true then plotchar style will be editable in Format dialog. Default is true.
- show_last (input int) If set, defines the number of chars (from the last bar back to the past) to plot on chart.
- size (const string) Size of characters on the chart. Possible values are: size.auto, size.tiny, size.small, size.normal, size.large, size.huge. Default is size.auto.
- display (plot_display) Controls where the plot is displayed. Possible values are: display.none, display.all. Default is display.all.
- overlay (const bool) is the extension argument of FMZ platform, it is used to set the current function to be displayed on the main image (set to true) or sub-image (set to false), the default value is false. If this argument is not specified, it will be set according to the overlay argument in strategy or indicator, if strategy or indicator does not set the overlay argument, it will be processed according to the default arguments.
See also
### plotcandle
Plots candles on the chart.
plotcandle(open, high, low, close, title, color, wickcolor, editable, show_last, bordercolor, display)
**Example**
```pine
indicator("plotcandle example", overlay=true)
plotcandle(open, high, low, close, title='Title', color = open < close ? color.green : color.red, wickcolor=color.black)
Arguments
- open (series int/float) Open series of data to be used as open values of candles. Required argument.
- high (series int/float) High series of data to be used as high values of candles. Required argument.
- low (series int/float) Low series of data to be used as low values of candles. Required argument.
- close (series int/float) Close series of data to be used as close values of candles. Required argument.
- title (const string) Title of the plotcandles. Optional argument.
- color (series color) Color of the candles. You can use constants like ‘color=color.red’ or ‘color=#ff001a’ as well as complex expressions like ‘color = close >= open ? color.green : color.red’. Optional argument.
- wickcolor (series color) The color of the wick of candles. An optional argument.
- editable (const bool) If true then plotcandle style will be editable in Format dialog. Default is true.
- show_last (input int) If set, defines the number of candles (from the last bar back to the
- 曝光一个不专业的量化托管人
- 读取的实时records和实际数据为啥对不上呢
- exchange.Buy(Price, Amount) 未返回ID
- FMZ PINE Script 文档
- BTCUP 和BTCDOWN对冲
- 各位，买了一个策略，然后运行就出错，麻烦大神帮忙看下啥原因造成的。
- 交互模式
- 回测系统的参数调优
- 跟单系统
- ta库源码中的问题
- Notes & Explanation of Futures Reverse Doubling Algorithm Strategy
- Solutions to Obtaining Docker Http Request Message
- Extending Custom Template by Visual (Blockly ) Strategy Editing
- Profit Harvester Strategy Analysis (2)
- Profit Harvester Strategy Analysis (1)
- Python的usdt永续合约交易改成能busd永续交易需要改哪个函数，那个函数影响这个的，求大佬教学一下
- Add Stoploss to control risks — What's the Price
- Discussion on High-Frequency Strategy Design —— Magically Modified Profit Harvester
- Binance Perpetual Funding Rate Arbitrage (100% of Annualized Rate in Bull Market)
- Use Cryptocurrency Platform Aggregated Market Interface to Construct Multi-Symbol Strategy
