TradingView has several operators that we can use when programming scripts, including arithmetic operators, comparison operators, and the conditional ternary operator. But if one line of code has several operators, in what order are they calculated?

#### In this article:

## TradingView operators and the operators’ priority

TradingView Pine scripts can perform complex operations thanks to operators. An *operator* is a code element that performs a certain action on one or several values (Stephens, 2014). Those values that an operator ‘operates on’ are what we call *operands* (Sharp, 2013). And a piece of code that returns a value is called an *expression* (Albahari & Albahari, 2012), and these often contain operators. Expressions include `close + high`

(returns the sum of the bar’s close and high) and `open > open[1]`

(returns true when the open is above the previous open).

Operators evaluate in a certain order when an expression has several of them. Pine determines that order of calculations with the **operators’ priority** (*Pine Script Language Tutorial*, n.d.). Those rules regulate which operator is evaluated first, which one calculates next, and so on until all operations in an expression have been performed.

Due to the operator’s priority, Pine evaluates expressions in a predictable way. It also clarifies unclear expressions like `2 + 10 * 5`

(does the programmer want to add before multiplying or multiply before adding?). Since multiplication has a higher priority than addition, this calculates to 52 (5 x 10, then plus 2) and not 60 (2 + 10, times 5).

## The priority of calculations in TradingView Pine

The priority of operators in TradingView is displayed below. Operators with a higher priority are calculated before those with a lower priority (*Pine Script Language Tutorial*, n.d.):

Priority | Operator | Name | Example |
---|---|---|---|

10 | `( )` | parentheses; overrides operators’ priority | `((34 - 3) + (8 - close[2])) / 5` |

9 | `[ ]` | history referencing operator | `close[2]` , `myVariable[9]` |

8 | `+` | addition operator (unary); leaves operand unchanged | `+mom(close, 10)` , `+volumeChange` |

`-` | subtraction operator (unary); returns operand’s opposite | `-ema(high, 3)` , `-maxLoss` | |

`not` | logical not operator; returns logical opposite | `not (high > high[1])` , `not enterLong` | |

7 | `*` | multiplication operator | `hl2 * 2` , `10 * volumeDifference` |

`/` | division operator | `low / high` , `9 / 2` | |

`%` | modulus operator; returns remainder of integer division | `9 % 3` , `n % 20 == 0` | |

6 | `+` | addition operator (binary) | `10 + 6` , `(close + close[1]) / 2` |

`-` | subtraction operator (binary) | `high - low` , `ema(close, 10) - ema(close, 3)` | |

5 | `>` | greater than operator | `10 > 9` , `high > high[1]` |

`<` | less than operator | `9 < 1` , `mom(close, 10) < mom(close, 10)[1]` | |

`>=` | greater than or equal to operator | `close <= sma(close, 10)` , `open <= close` | |

`<=` | less than or equal to operator | `high <= high[5]` , `19 <= 20` | |

4 | `==` | equality operator | `high = highest(high, 20)` , `low = low[2]` |

`!=` | unequal to operator | `close != close[4]` , `myVariable != 100` | |

3 | `and` | logical and operator | `newHigh and volumeIncrease` , `10 > 2 and 9 != 8` |

2 | `or` | logical or operator | `enterLong or stopTriggered` , `not (9 < 3) or 500 > 8` |

1 | `?:` | conditional ternary operator | `highestHigh == true ? 200 : 3` , `close < open ? close : close` |

As the table shows, we can use the addition (`+`

) and subtraction (`-`

) operators in unary and binary form. When an operator acts on a single operand, it’s called *unary* (like `-close`

to get the negative of the closing price); when the operator acts on two values, it’s named *binary* (like `high - low`

) (Albahari & Albahari, 2012).

What’s also clear from the table is that several operators have the same priority. When an expression has several operators with the same priority, then they are calculated from left to right (*Pine Script Language Tutorial*, n.d.). For example, addition (`+`

) and subtraction (`-`

) have the same priority and so the expression `9 - 3 + 22 - 3`

returns 25 (9 - 3 is 6, adding 22 gives 28, and subtracting 3 gives 25).

## Changing the priority of operators with parentheses in TradingView

We can change the operators’ priority by grouping parts of the expression with parentheses (*Pine Script Language Tutorial*, n.d.). Because parentheses have the highest priority, TradingView evaluates expressions inside parentheses first.

For example, `10 + 9 * close`

first multiplies `9`

with `close`

and then adds `10`

to the result because multiplication has a higher priority than addition. But `(10 + 9) * close`

first adds `10`

and `9`

together and then multiplies that result with `close`

.

We occasionally need to use parentheses to get the correct calculation, like in this script where we try to calculate the bar’s midpoint:

```
study(title="Bar midpoint", overlay=true)
plot(series=high + low / 2, color=blue, linewidth=2)
```

Here we use `study()`

to set the indicator’s properties, and then plot a series of data on the chart with `plot()`

(TradingView, n.d.). The plotted value is `high + low / 2`

in an attempt to plot the bar’s midpoint. But when added to a chart, this example looks like:

Something is clearly off here. The issue is that we ignored the operators’ priority with the `high + low / 2`

expression. Since division (`/`

) has a higher priority than addition (`+`

), we don’t get the bar’s midpoint. Instead, we divided the bar’s low with 2 and *then* added the high.

To fix this error, we need to change the operators’ priority with parentheses. And so we put `high + low`

inside parentheses like this:

```
study(title="Bar midpoint", overlay=true)
plot(series=(high + low) / 2, color=blue, linewidth=2)
```

When we add this updated example to a chart, it correctly plots the bar’s midpoint:

## Nesting parentheses in TradingView Pine

Sometimes we have complex expressions that require multiple parentheses nested inside each other. In that case, TradingView Pine evaluates the innermost parentheses first (in other words, it works from the inside out).

Let’s say we calculate the `x`

variable as follows:

```
x = (7 % 3) * (4 + (6 / 2))
```

Since the innermost parentheses are evaluated first, Pine first calculates `6 / 2`

. The next step then becomes:

```
x = (7 % 3) * (4 + 3) // 6 / 2 = 3
```

Each set of parentheses is then evaluated in turn like this:

```
x = 1 * 7 // (7 mod 3) = 1, (4 + 3) = 7
```

And so the variable ends with a value of 7:

```
x = 7
```

See arithmetic operators, the modulus operator, and the assignment operator to learn more about the operators used in this article’s examples.

### Summary

How TradingView Pine evaluates multiple operators in an expression depends on two things: the operators’ priority and their order. Operators with a higher priority are evaluated before those with a lower priority. And operators that have the same priority are evaluated from left to right. Parentheses have the highest priority of all, and so we can use them to change the operators’ priority.

**References**

Albahari, J. & Albahari, B. (2012). *C# 5.0 in a Nutshell: The Definitive Reference* (5th edition). Sebastopol, CA: O’Reilly Media.

*Pine Script Language Tutorial* (n.d.). Retrieved on August 13, 2015, from https://docs.google.com/document/d/1sCfC873xJEMV7MGzt1L70JTStTE9kcG2q-LDuWWkBeY/

Sharp, J. (2013). *Microsoft Visual C# 2013 Step by Step*. Microsoft Press.

Stephens, R. (2014). *C# 5.0 Programmer Reference*. Indianapolis, IN: John Wiley & Sons.

TradingView (n.d.). *Script Language Reference Manual*. Retrieved on September 22, 2015, from https://www.tradingview.com/study-script-reference/