Here is Indie implementation of this algorithm:

```py theme={null}
# indie:lang_version = 5
from indie import algorithm, SeriesF, MutSeriesF

@algorithm
def Sum(self, price: SeriesF, length: int) -> SeriesF:
    result = 0.0
    for i in range(length):
        result += price[i]
    return MutSeriesF.new(result)

NOTE: If you need a [Sum](/indie/Library-reference/package-indie-algorithms#class_Sum) or [SMA](/indie/Library-reference/package-indie-algorithms#class_Sma) you don't
have to implement them by yourself. Simply import them from the standard library like this:
`from indie.algorithms import Sum, Sma`.

Now, after we have a `Sum` algorithm, it is trivial to write SMA as `Sma` algorithm too:

```py theme={null}
@algorithm
def Sma(self, price: SeriesF, length: int) -> SeriesF:
    s = Sum.new(price, length)
    return MutSeriesF.new(s[0] / length)

## Series behavior during history vs runtime

Suppose we have an indicator that counts green bars of an instrument on a chart:

```py theme={null}
# indie:lang_version = 5
from indie import indicator, MutSeriesF

@indicator('Green bars counter')
def Main(self):
    green_count = MutSeriesF.new(init=0)
    if self.close[0] > self.open[0]:
        green_count[0] += 1
    return green_count[0]

History prices `open` and `close` will be passed to the indicator for calculation one by one from left to right.
Indicator will calculate, at time `t0`, like this '12 is greater than 9, so we add 1 to green\_count'. On the next
calculation, at time `t1`, it will be '7 is not greater than 18, so do nothing. Value of green\_count is still 1'. In the
end, `green_count` series will contain these values:

```txt theme={null}
time:          t0, t1, t2, t3, t4, t5
green_count:    1,  1,  2,  3,  4,  4

Our indicator will behave like this:

```txt theme={null}
time:              t6, t6, t6, t7, t7, t7, t7, t8, t8, t9, ...
green_count:        5,  4,  5,  6,  6,  6,  5,  5,  6, ...
last bar update:            ^               ^       ^

Function `MutSeriesF.new` creates `MutSeriesF` objects which are containers for calculated values in Indie code. The
main feature of `MutSeriesF` container is ability to store (or 'remember') historical values of some variable, those
values could be later accessed with the square brackets operator. At the moment `MutSeriesF` class supports only
`float` type as series element.

Please note that `MutSeriesF` objects give read-write access only to the last value of the series object and read access
to any (well, down to some limit) previous values.

Parameters:

* `reset` — is a value that is written into the most recent element of the `MutSeriesF` every time `MutSeriesF.new()`
  function is executed. The effect of this parameter is the same as:

```py theme={null}
# this:
s = MutSeriesF.new(reset_val)

# is the same as:
s = MutSeriesF.new()
s[0] = reset_val

* `size` — is number of elements that `MutSeriesF` object should persist in memory. The default and minimum possible
  size is 2, which means that a series of size=2 stores in memory one value at the time of the last candle and another
  at the time of the previous candle. The size is automatically expanded during the historical calculation of an
  indicator. For example:

```py theme={null}
# This series allows us to get access to s[0], s[1] and s[2] elements from now
s = MutSeriesF.new(0.0, size=3)

# We can read previous value which is out of size=3, for example s[5]:
s[0] = s[5] + 1

We cannot predict values of `self.close` series. They could be less than `max_size = 100` at first but then during
realtime, they could rise higher. That is why we should always limit the max\_offset with `min` and reserve the `s`'s
size with `size` parameter. Otherwise the indicator would fail, since, again, we cannot expand the size at realtime.

NOTE: `MutSeriesF` objects also have a method `request_size(new_size: int)` which can be used to expand the size
explicitly.

`MutSeriesF.new` function has a 'get or create' semantics. It means that only one `MutSeriesF` object is created per one
`MutSeriesF.new` function call occurrence in the code. All subsequent calls of `MutSeriesF.new` in exactly the same
position in Indie script simply return `MutSeriesF` objects created previously. For example:

```py theme={null}
@indicator('Example')
def Main(self):
    s1 = MutSeriesF.new(0.0)
    s2 = MutSeriesF.new(42.0)
    # ...

* Go to the place in the code where you want to call the algorithm. Algorithms can be called either:

  * from [`Main`](/indie/How-Indies-syntactic-sugar-works#main-entry-point) entry point or
  * from [secondary context](/indie/How-Indies-syntactic-sugar-works#functions-decorated-with-%40sec-context) entry point or
  * from some other [algorithm](/indie/How-Indies-syntactic-sugar-works#functions-decorated-with-%40algorithm).

  In our example we go to the `Main` entry point function:

```py theme={null}
@indicator('Test')
def Main(self):
    # ...
    # >>> somewhere here <<<
    # ...

* From now you may use the `rsi_result` series, for example, return it from `Main` for plotting on chart or pass to some other algorithm for further processing. If you want just access the last `float` RSI value, use square brackets operator `rsi_result[0]`.

Final version of our example looks like this:

```py theme={null}
# indie:lang_version = 5
from indie import indicator
from indie.algorithms import Rsi

@indicator('Example')
def Main(self):
    rsi_result = Rsi.new(self.close, 12)
    return rsi_result[0]

NOTE: That type of `OC2` variable is `float`.

It could be very useful to store such a value like `OC2` (or, to be more accurate, a *series of values* because we
calculate new value on each candle) in a Series-like container (which is `indie.MutSeriesF`). This gives following
benefits:

* it will be possible to access historical values of `OC2` (values which were calculated previously on historical
  candles);
* it will be possible to process series of `OC2` values with algorithms from `indie.algorithms` package (or our own).

Here is how to do it:

* Import class `indie.MutSeriesF` to your indicator:

```py theme={null}
from indie import MutSeriesF

Since this moment, type of `OC2` variable is `indie.MutSeriesF`, which is a container with `float` values inside.
Please note, that `indie.MutSeriesF.new()` method can be called either:

* from [`Main`](/indie/How-Indies-syntactic-sugar-works#main-entry-point) entry point or
* from [secondary context](/indie/How-Indies-syntactic-sugar-works#functions-decorated-with-%40sec-context) entry point or
* from some [algorithm](/indie/How-Indies-syntactic-sugar-works#functions-decorated-with-%40algorithm).

NOTE: that you cannot call `indie.MutSeriesF.new()` function from global scope of indicator or from some 'plain old
python function'.

* Use the `OC2` series in further calculations:
  * access historical values of `OC2` variable with the square brackets operator. For example:

```py theme={null}
# indie:lang_version = 5
from indie import indicator, MutSeriesF

@indicator('Example', overlay_main_pane=True)
def Main(self):
    OC2 = MutSeriesF.new((self.open[0] + self.close[0]) / 2)
    return OC2[0], OC2[1], OC2[2]

# null
Source: https://takeprofit.com/docs/indie/Changelog

Version history and migration guides for Indie programming language. Documents language changes, new features, and deprecations for Indie

All notable changes to the Indie language project.

<Update label="Unreleased">
  #### Added

  * Backtesting functionality.
  * New series-based plotting capability:
    * `@indie.plot.bar_color`: recolors the bars/candles on the chart.
</Update>

<Update label="22 Dec '25" description="v5.9.0">
  #### Added

  * `@param.color` to pass colors to indicators as input params with customization via UI.

  #### Changed

  * The line color setting has been added to the built-in ZigZag indicator.
</Update>

<Update label="26 Sep '25" description="v5.8.0">
  #### Added

  * Algorithms:
    * `indie.algorithms.Percentile`
    * `indie.algorithms.PivotHighLow`
  * New helper color `color.TRANSPARENT`.
  * Package `sortedcontainers` with class `SortedList`.
  * MCP (Model Context Protocol) server support for Claude integration via the Claude web interface.
</Update>

<Update label="22 Jul '25" description="v5.7.0">
  #### Added

  * Practical guide to common drawing patterns in Indie indicators.
  * New colors: `color.PINK`, `color.ORANGE` and `color.BROWN`.
  * Built-in indicator Linear Regression Channel.
</Update>

<Update label="04 Jul '25" description="v5.6.0">
  #### Added

  * New series-based plotting capability:
    * `@indie.plot.background`: recolors the background of the chart pane.
  * Built-in indicator Trading Sessions.
</Update>

<Update label="24 Jun '25" description="v5.5.0">
  #### Added

  * MCP (Model Context Protocol) server support for Claude Desktop integration.
  * Documentation guide for MCP server installation and configuration.
</Update>

<Update label="10 Jun '25" description="v5.4.0">
  #### Added

  * Non-series drawing objects support:
    * `indie.drawings.LabelAbs`, `indie.drawings.LabelRel`: text labels with absolute and relative positioning.
    * `indie.drawings.LineSegment`: customizable line segments with various styles and endpoints.
    * `indie.drawings.Chart`: class for managing drawing objects with `draw()`, `erase()`, and `clean()` methods.
  * Built-in indicators Pivot Points High/Low, Pivot Points Standard and Zig Zag.
</Update>

<Update label="21 Mar '25" description="v5.3.0">
  #### Added

  * `@indie.plot.marker`: plots circles, crosses and labels (with optional text) above/below candles on the chart.
  * Built-in indicators MA Cross and Parabolic Stop And Reverse.
</Update>

<Update label="13 Mar '25" description="v5.2.0">
  #### Added

  * Built-in indicator Least Squares Moving Average.
  * Algorithms:
    * `indie.algorithms.Macd`
    * `indie.algorithms.Mfi`
    * `indie.algorithms.Sar`
    * `indie.algorithms.SinceTrue`
    * `indie.algorithms.Uo`
  * Package `indie.math` with functions:
    * `cross`
    * `cross_over`
    * `cross_under`
    * `divide`
  * Methods of class `datetime.datetime`:
    * `strptime`
    * `timestamp`

  #### Changed

  * Updated return type of algorithms:
    * `indie.algorithms.SinceHighest`
    * `indie.algorithms.SinceLowest`
</Update>

<Update label="03 Mar '25" description="v5.1.0">
  #### Added

  * Underlining of some errors in the Indie IDE.
</Update>

<Update label="14 Feb '25" description="v5.0.0">
  #### Added

  * Indie language v5 support:
    * `indie.plot` is now a package, not a decorator.
    * Decorators renamed:
      ```java theme={null}
      @indie.fill() -> @indie.plot.fill()
      @indie.plot() -> @indie.plot.line()
      @indie.plot(style=plot_style.STEPS) -> @indie.plot.steps()
      @indie.plot(style=plot_style.HISTOGRAM) -> @indie.plot.histogram()
      @indie.plot(style=plot_style.COLUMNS) -> @indie.plot.columns()
      ```
  * Support of Indie v4 -> v5 migrations in Code Migrator.
  * `display_options` parameter for `@plot.*` decorators.

  #### Removed

  * Indie language v4 support.
  * Deprecated decorator `@param.string`, use `@param.str` instead.
  * Deprecated field `SymbolInfo.marketdata_timezone`, use `SymbolInfo.timezone` instead.
  * Deprecated function `tf`, use `TimeFrame.from_str` instead.
  * Deprecated enum `WeekDay`, use `week_day` instead.
</Update>

<Update label="26 Nov '24" description="v4.5.0">
  #### Added

  * Built-in indicator Correlation Coefficient.
  * Algorithms `indie.algorithms.Corr` and `indie.algorithms.LinReg`.
</Update>

<Update label="18 Nov '24" description="v4.4.0">
  #### Added

  * Introducing `indie.TradingSession` and `indie.schedule.Schedule` classes for trading sessions support.
</Update>

<Update label="08 Nov '24" description="v4.3.0">
  #### Added

  * Support of `indie.Var[T]` container which is like a `indie.MutSeries[T]` but with history depth of 1.
</Update>

<Update label="10 Oct '24" description="v4.2.0">
  #### Added

  * Expanded OOP support: it is now possible to create custom classes with fields and methods, or to add methods to the
    descendants of `indie.Algorithm`, `indie.MainContext`, or `indie.SecContext`.
</Update>

<Update label="16 Sep '24" description="v4.1.0">
  #### Added

  * Generic data types `indie.Series[T]` and `indie.MutSeries[T]`. At the moment `T` can be any of `float`, `int`, `bool`, `str` types.
</Update>

<Update label="27 Aug '24" description="v4.0.0">
  #### Added

  * Indie language v4 support:
    * Classes syntax of algorithms and contexts declaration.
    * `Context.calc_on` call is required to be called only from context's `__init__` body.
  * Support of Indie v3 -> v4 migrations in Code Migrator.

  #### Removed

  * Indie language v3 support.
</Update>

<Update label="30 Jul '24" description="v3.0.0">
  #### Added

  * Indie language v3 support:
    * Package renamed `indie.algorithm` -> `indie.algorithms`.
    * Renamed all algorithms in `indie.algorithm` package to CamelCase, e.g. `std_dev` -> `StdDev`
    * `Algorithm.new()` syntactic sugar method was introduced.
    * Added `self` to every `@func`-decorated function as the first parameter.
    * Renamed decorator `@func` -> `@algorithm`. Introduced base class `indie.Algorithm`.
    * Renamed `def main(ctx)` -> `def Main(self)`. Introduced base class `indie.MainContext`.
    * Syntactic sugar function `mut_series` is replaced with `MutSeriesF.new()`.
    * Classes renamed: `MutSeries` -> `MutSeriesF`, `Series` -> `SeriesF`.
    * Renamed decorator `@ctx_func` -> `@sec_context`. Introduced base class `indie.SecContext`.
    * Renamed the first parameter of a secondary context `ctx` -> `self`.
    * Renamed parameter `ctx_func` -> `sec_context` of the function `Context.calc_on`.
    * Changed signatures of algorithms:
      * `indie.algorithm.since_lowest`, `indie.algorithm.since_highest`
      * `indie.algorithm.lowest`, `indie.algorithm.highest`
      * `indie.algorithm.adx`
      * `indie.algorithm.atr`
      * `indie.algorithm.donchian`
      * `indie.algorithm.ma`
      * `indie.algorithm.mfv`
      * `indie.algorithm.net_volume`
      * `indie.algorithm.supertrend`
      * `indie.algorithm.tr`
      * `indie.algorithm.vwap`
      * `indie.algorithm.vwma`
      * plus all algorithms now return `SeriesF` types instead of `MutSeriesF`.
  * Indie Code Migrator microservice for automatic migration of Indie source code from v2 to v3.

  #### Removed

  * Indie language v2 support.
</Update>

<Update label="29 May '24" description="v2.3.0">
  #### Changed

  * Replaced milliseconds with seconds in `Context.time` series.
</Update>

<Update label="08 May '24" description="v2.2.0">
  #### Added

  * Built-in indicator Volume Weighted Average Price.
</Update>

<Update label="24 Apr '24" description="v2.1.0">
  #### Added

  * `Context.is_last` and `Context.is_realtime`.
  * `in` operator support.
  * `lookahead` param to `Context.calc_on`.
</Update>

<Update label="27 Feb '24" description="v2.0.0">
  #### Added

  * Indie language v2 support:
    * Pass `ctx` object explicitly everywhere in Indie code.

  #### Removed

  * Indie language v1 support.
</Update>

<Update label="30 Nov '23" description="v1.14.0">
  #### Added

  * Popup docstrings and autocompleter in the Indie IDE.
</Update>

<Update label="09 Oct '23" description="v1.13.0">
  #### Added

  * `indie.Optional` type.
</Update>

<Update label="15 Sep '23" description="v1.12.0">
  #### Added

  * Built-in indicators: Accumulation/Distribution, Advance/Decline Ratio (Bars), Average Directional Index, Arnaud Legoux Moving Average, Bull Bear Power, Bollinger Bands Width, Commodity Channel Index, Chande Momentum Oscillator, Choppiness Index, Chop Zone, Chande Kroll Stop, Chaikin Money Flow, Coppock Curve, Connors RSI, Donchian Channels, Directional Movement Index, Detrended Price Oscillator, Elders Force Index, Ease of Movement, Fisher Transform, Hull Moving Average, Keltner Channels, Klinger Oscillator, Know Sure Thing, Moving Average Ribbon, Mass Index, McGinley Dynamic, Median, Net Volume, On Balance Volume, Price Oscillator, Price Volume Trend, Rate Of Change, Relative Vigor Index, Relative Volatility Index, SMI Ergodic Indicator, SMI Ergodic Oscillator, Smoothed Moving Average, Triple EMA, TRIX, True Strength Indicator, Ultimate Oscillator, Volume Oscillator, Vortex Indicator, Williams Percent Range, Woodies CCI.
</Update>

<Update label="08 Sep '23" description="v1.11.0">
  #### Changed

  * Better generics support in Indie.
</Update>

<Update label="29 Aug '23" description="v1.10.0">
  #### Added

  * Built-in indicator Volume Moving Average Weighted.
</Update>

<Update label="23 Aug '23" description="v1.9.0">
  #### Changed

  * Renamed package `take_profit` -> `indie`.
</Update>

<Update label="21 Aug '23" description="v1.8.0">
  #### Added

  * Built-in indicator Chaikin Oscillator.
</Update>

<Update label="03 Aug '23" description="v1.7.0">
  #### Added

  * Better type inferring mechanism in the Indie compiler.
</Update>

<Update label="27 Apr '23" description="v1.6.0">
  #### Changed

  * Significant speed-up of indicator calculation.
</Update>

<Update label="11 Apr '23" description="v1.5.0">
  #### Added

  * Built-in indicators: Stochastic Oscillator, Stochastic RSI.
</Update>

<Update label="06 Apr '23" description="v1.4.0">
  #### Added

  * Built-in indicator Bollinger Bands %B.
</Update>

<Update label="14 Mar '23" description="v1.3.0">
  #### Added

  * Built-in indicator Supertrend.
</Update>

<Update label="03 Mar '23" description="v1.2.0">
  #### Added

  * The first chapters of Indie documentation were published on `https://takeprofit.com/docs/indie/`.
</Update>

<Update label="01 Feb '23" description="v1.1.0">
  #### Added

  * Built-in indicators: Average Day Range, Aroon, Average True Range, Awesome Oscillator, Bollinger Bands, Balance of
    Power, Double EMA, Exponential Moving Average, Envelope, Ichimoku Cloud, Moving Average Convergence Divergence,
    Momentum, Money Flow Index, Relative Strength Index, Simple Moving Average, Williams Alligator, Moving
    Average Weighted.
</Update>

<Update label="24 Jan '23" description="v1.0.0">
  #### Added

  * 'Indicators Code Editor' widget was added to the TakeProfit platform. This can be considered as Indie language v1
    release.
</Update>

<Update label="11 Nov '22" description="v0.3.0">
  #### Changed

  * On this day the name 'Indie' for the new language was invented.
</Update>

<Update label="05 Sep '22" description="v0.2.0">
  #### Added

  * Explicit typing in the language.
</Update>

<Update label="09 Feb '22" description="v0.1.0">
  #### Added

  * Approximate development start of a new *technical analysis*-oriented language for the TakeProfit platform.
</Update>


# Built-in indicators
Source: https://takeprofit.com/docs/indie/Code-examples/built-in-indicators

Comprehensive collection of trading indicator implementations in Indie. Includes complete code examples with decorators, parameters, and return types for technical analysis.

## Accumulation/Distribution

```py Accumulation/Distribution theme={null}
# indie:lang_version = 5
from indie import indicator, format, plot, color
from indie.algorithms import CumSum, Mfv


@indicator('Accum/Dist', format=format.VOLUME)  # Accumulation/Distribution
@plot.line(color=color.OLIVE)
def Main(self):
    return CumSum.new(Mfv.new())[0]

is_down_ints = MutSeriesF.new(0 if is_up else 1)
is_up_ints = MutSeriesF.new(1 if is_up else 0)

down_bars = Sum.new(is_down_ints, length)
up_bars = Sum.new(is_up_ints, length)

return divide(up_bars[0], down_bars[0], up_bars[0]) ```

## Aroon

```py Aroon theme={null}
# indie:lang_version = 5
from indie import indicator, format, param, plot, color
from indie.algorithms import SinceLowest, SinceHighest


@indicator('Aroon', format=format.PRICE)  # TODO: format=format.PERCENT
@param.int('length', default=14, min=1)
@plot.line(color=color.BLUE, title='Aroon Down')
@plot.line(color=color.YELLOW, title='Aroon Up')
def Main(self, length):
    lo_offset = SinceLowest.new(self.low, length)
    hi_offset = SinceHighest.new(self.high, length)

    down = 100 * (length - lo_offset[0]) / length
    up = 100 * (length - hi_offset[0]) / length

    return down, up

## Average Directional Index

```py Average Directional Index theme={null}
# indie:lang_version = 5
from indie import indicator, format, param, plot, color
from indie.algorithms import Adx


@indicator('ADX', format=format.PRICE)  # Average Directional Index
@param.int('adx_len', default=14, min=1, title='ADX Smoothing')
@param.int('di_len', default=14, min=1, title='DI Length')
@plot.line(color=color.RED)
def Main(self, adx_len, di_len):
    _, adx, _ = Adx.new(adx_len, di_len)
    return adx[0]

## Awesome Oscillator

```py Awesome Oscillator theme={null}
# indie:lang_version = 5
from indie import indicator, plot, color, MutSeriesF
from indie.algorithms import Sma


# TODO: Support palettes of colors in indicators
@indicator('AO')  # Awesome Oscillator
@plot.columns()
def Main(self):
    ao = MutSeriesF.new(Sma.new(self.hl2, 5)[0] - Sma.new(self.hl2, 34)[0])
    d = ao[0] - ao[1]
    c = color.MAROON if d <= 0 else color.GREEN
    return plot.Columns(ao[0], color=c)

## Bollinger Bands

```py Bollinger Bands theme={null}
# indie:lang_version = 5
from indie import indicator, param, source, plot, color
from indie.algorithms import Bb


@indicator('BB', overlay_main_pane=True)  # Bollinger Bands
@param.int('length', default=20, min=1)
@param.source('src', default=source.CLOSE, title='Source')
@param.float('mult', default=2.0, min=0.001, max=50.0, title='StdDev')
@param.int('offset', default=0, min=-500, max=500)
@plot.line('lower', color=color.BLUE, title='Lower')
@plot.line(color=color.RED, title='Basis')
@plot.line('upper', color=color.BLUE, title='Upper')
@plot.fill('lower', 'upper', color=color.AQUA(0.05), title='Background')
def Main(self, length, src, mult, offset):
    (lower, middle, upper) = Bb.new(src, length, mult)
    return (
        plot.Line(lower[0], offset=offset),
        plot.Line(middle[0], offset=offset),
        plot.Line(upper[0], offset=offset),
        plot.Fill(offset=offset),
    )

## Bollinger Bands Width

```py Bollinger Bands Width theme={null}
# indie:lang_version = 5
from indie import indicator, format, param, source, plot, color
from indie.algorithms import Bb
from indie.math import divide


@indicator('BBW', format=format.PRICE)  # Bollinger Bands Width
@param.int('length', default=20, min=1)
@param.source('src', default=source.CLOSE, title='Source')
@param.float('mult', default=2.0, min=0.001, max=50.0, title='StdDev')
@plot.line(color=color.TEAL)
def Main(self, length, src, mult):
    (lower, middle, upper) = Bb.new(src, length, mult)
    return divide(upper[0] - lower[0], middle[0])

## Chaikin Money Flow

```py Chaikin Money Flow theme={null}
# indie:lang_version = 5
from indie import indicator, format, param, level, color, plot
from indie.algorithms import Sum, Mfv
from indie.math import divide


@indicator('CMF', format=format.PRICE)  # Chaikin Money Flow
@param.int('length', default=20, min=1, title='Length')
@level(0, line_color=color.GRAY, title='Zero')
@plot.line(color=color.GREEN, title='MF')
def Main(self, length):
    mfv_sum = Sum.new(Mfv.new(), length)[0]
    vol_sum = Sum.new(self.volume, length)[0]
    return divide(mfv_sum, vol_sum)

## Chande Kroll Stop

```py Chande Kroll Stop theme={null}
# indie:lang_version = 5
from indie import indicator, param, plot, color, MutSeriesF
from indie.algorithms import Atr, Lowest, Highest


@indicator('Chande KS', overlay_main_pane=True)  # Chande Kroll Stop
@param.int('p', default=10, min=1)
@param.int('x', default=1, min=1)
@param.int('q', default=9, min=1)
@plot.line(color=color.BLUE, title='Stop Long')
@plot.line(color=color.MAROON, title='Stop Short')
def Main(self, p, x, q):
    atr = Atr.new(p)[0]
    first_low_stop = MutSeriesF.new(Lowest.new(self.low, p)[0] + x * atr)
    first_high_stop = MutSeriesF.new(Highest.new(self.high, p)[0] - x * atr)
    stop_long = Lowest.new(first_low_stop, q)
    stop_short = Highest.new(first_high_stop, q)
    return stop_long[0], stop_short[0]

m1 = momm if momm >= 0 else 0
m2 = 0.0 if momm >= 0 else -momm

sm1 = Sum.new(MutSeriesF.new(m1), length)[0]
sm2 = Sum.new(MutSeriesF.new(m2), length)[0]

return 100 * divide(sm1 - sm2, sm1 + sm2) ```

periods = 30
highest_high = Highest.new(self.high, periods)[0]
lowest_low = Lowest.new(self.low, periods)[0]
span = divide(25, highest_high - lowest_low) * lowest_low

ema34 = Ema.new(self.close, 34)
y2_ema34 = divide(ema34[1] - ema34[0], self.hlc3[0]) * span

ema_angle_1 = nan
if not isnan(y2_ema34):
    ema_angle_1 = round(180 * atan(abs(y2_ema34)) / pi)
ema_angle = -ema_angle_1 if y2_ema34 > 0 else ema_angle_1

chop_zone_color = color.BLACK  # default value
if ema_angle >= 5:
    chop_zone_color = color_turquoise
elif ema_angle >= 3.57:
    chop_zone_color = color_dark_green
elif ema_angle >= 2.14:
    chop_zone_color = color_pale_green
elif ema_angle >= 0.71:
    chop_zone_color = color_lime
elif ema_angle <= -5:
    chop_zone_color = color_dark_red
elif ema_angle <= -3.57:
    chop_zone_color = color_red
elif ema_angle <= -2.14:
    chop_zone_color = color_orange
elif ema_angle <= -0.71:
    chop_zone_color = color_light_orange
else:  # ema_angle > -0.71 and ema_angle < 0.71
    chop_zone_color = color_yellow
return plot.Columns(1, color=chop_zone_color) ```

## Commodity Channel Index

```py Commodity Channel Index theme={null}
# indie:lang_version = 5
from indie import indicator, format, param, source, band, color, level, plot
from indie.algorithms import Cci


@indicator('CCI', format=format.PRICE)  # Commodity Channel Index
@param.int('length', default=20, min=1)
@param.source('src', default=source.HLC3, title='Source')
@band(-100, 100, line_color=color.GRAY, fill_color=color.AQUA(0.1), title='Background')
@level(0, line_color=color.GRAY(0.5), title='Middle Band')
@plot.line(color=color.BLUE, title='CCI')
def Main(self, length, src):
    return Cci.new(src, length)[0]
    # TODO: implement smoothing when display.none is supported

rsi = Rsi.new(self.close, len_rsi)[0]
ud_rsi = Rsi.new(ud, len_up_down)[0]
pr = PercentRank.new(Roc.new(self.close, 1), len_roc)[0]
return (rsi + ud_rsi + pr) / 3 ```

## Correlation Coefficient

```py Correlation Coefficient theme={null}
# indie:lang_version = 5
from indie import indicator, MainContext, sec_context, format, param, source, param_ref, level, color, plot
from indie.algorithms import Corr


@sec_context
@param_ref('source')
def SecContext(self, source):
    return source[0]


@indicator('CC', format=format.PRICE)  # Correlation Coefficient
@param.str('exchange', default='NASDAQ')
@param.str('ticker', default='GOOG')
@param.source('source', default=source.CLOSE)
@param.int('length', default=20, min=1)
@level(1, line_color=color.GRAY)
@level(0)
@level(-1, line_color=color.GRAY)
@plot.line(color=color.BLUE, title='Correlation')
class Main(MainContext):
    def __init__(self, exchange, ticker):
        self.ctx_other = self.calc_on(SecContext, exchange=exchange, ticker=ticker)

    def calc(self, source, length):
        corr = Corr.new(source, self.ctx_other, length)
        return corr[0]

## Detrended Price Oscillator

```py Detrended Price Oscillator theme={null}
# indie:lang_version = 5
from indie import indicator, format, param, level, color, plot
from indie.algorithms import Sma


@indicator('DPO', format=format.PRICE)  # Detrended Price Oscillator
@param.int('length', default=21, min=1)
@param.bool('centered', default=False, title='Centered')
@level(0, line_color=color.GRAY, title='Zero')
@plot.line(color=color.GREEN, title='Detrended Price Oscillator')
def Main(self, length, centered):
    bars_back = length // 2 + 1
    ma = Sma.new(self.close, length)
    dpo = self.close[bars_back] - ma[0] if centered else self.close[0] - ma[bars_back]
    return plot.Line(dpo, offset=-bars_back if centered else 0)

## Donchian Channels

```py Donchian Channels theme={null}
# indie:lang_version = 5
from indie import indicator, param, plot, color
from indie.algorithms import Lowest, Highest, Donchian


@indicator('DC', overlay_main_pane=True)  # Donchian Channels
@param.int('length', default=20, min=1)
@plot.line('lower', color=color.BLUE, title='Lower')
@plot.line(color=color.RED, title='Basis')
@plot.line('upper', color=color.BLUE, title='Upper')
@plot.fill('lower', 'upper', color=color.AQUA(0.05), title='Background')
def Main(self, length):
    lower = Lowest.new(self.low, length)
    upper = Highest.new(self.high, length)
    basis = Donchian.new(length)
    return lower[0], basis[0], upper[0], plot.Fill()

## Elders Force Index

```py Elders Force Index theme={null}
# indie:lang_version = 5
from indie import indicator, format, param, level, color, plot, MutSeriesF
from indie.algorithms import Change, Ema


@indicator('EFI', format=format.VOLUME)  # Elders Force Index
@param.int('length', default=13, min=1)
@level(0, line_color=color.GRAY, title='Zero')
@plot.line(color=color.RED, title='Elders Force Index')
def Main(self, length):
    efi = Change.new(self.close)[0] * self.volume[0]
    return Ema.new(MutSeriesF.new(efi), length)[0]

## Envelope

```py Envelope theme={null}
# indie:lang_version = 5
from indie import indicator, param, source, plot, color
from indie.algorithms import Ema, Sma


@indicator('Env', overlay_main_pane=True)  # Envelope
@param.int('length', default=20, min=1)
@param.float('percent', default=10.0)
@param.source('src', default=source.CLOSE, title='Source')
@param.bool('exponential', default=False)
@plot.line('lower', color=color.BLUE, title='Lower')
@plot.line('basis', color=color.RED, title='Basis')
@plot.line('upper', color=color.BLUE, title='Upper')
@plot.fill('lower', 'upper', color=color.AQUA(0.05), title='Background')
def Main(self, length, percent, src, exponential):
    basis = 0.0
    if exponential:
        basis = Ema.new(src, length)[0]
    else:
        basis = Sma.new(src, length)[0]
    k = percent / 100.0
    upper = basis * (1 + k)
    lower = basis * (1 - k)
    return lower, basis, upper, plot.Fill()

value = MutSeriesF.new(init=0)
value[0] = round(0.66 * (divide(self.hl2[0] - low, high - low) - 0.5) + \
                 0.67 * nan_to_zero(value[1]))
fish = MutSeriesF.new(init=nan)
fish[0] = 0.5 * log(divide(1 + value[0], 1 - value[0])) + 0.5 * nan_to_zero(fish[1])
return fish[0], fish[1] ```

## Ichimoku Cloud

```py Ichimoku Cloud theme={null}
# indie:lang_version = 5
from indie import SeriesF, MutSeriesF, indicator, param, plot, color
from indie.algorithms import Donchian


def mean(price1: SeriesF, price2: SeriesF) -> float:
    # TODO: implement @algorithm avg with variable number of arguments in indie.algorithms
    return (price1[0] + price2[0]) / 2


# TODO: Add palette of colors
@indicator('Ichimoku', overlay_main_pane=True)  # Ichimoku Cloud
@param.int('conversion_periods', default=9, min=1, title='Conversion Line Length')
@param.int('base_periods', default=26, min=1, title='Base Line Length')
@param.int('lagging_span_2_periods', default=52, min=1, title='Leading Span B Length')
@param.int('displacement', default=26, min=1, title='Lagging Span')
@plot.line(color=color.BLUE, title='Conversion Line')
@plot.line(color=color.RED, title='Base Line')
@plot.line(color=color.GREEN, title='Lagging Span')
@plot.line('ls_a', color=color.GREEN(0.6), title='Leading Span A')
@plot.line('ls_b', color=color.RED(0.6), title='Leading Span B')
@plot.fill('ls_a', 'ls_b', title='Background')
def Main(self, conversion_periods, base_periods, lagging_span_2_periods, displacement):
    conversion_line = Donchian.new(conversion_periods)
    base_line = Donchian.new(base_periods)
    lead_line1 = mean(conversion_line, base_line)
    lead_line2 = Donchian.new(lagging_span_2_periods)[0]
    fill_color = color.GREEN(0.1) if lead_line1 > lead_line2 else color.RED(0.1)

    return (
        conversion_line[0],
        base_line[0],
        plot.Line(self.close[0], offset=-displacement + 1),
        plot.Line(lead_line1, offset=displacement - 1),
        plot.Line(lead_line2, offset=displacement - 1),
        plot.Fill(offset=displacement - 1, color=fill_color),
    )

## Klinger Oscillator

```py Klinger Oscillator theme={null}
# indie:lang_version = 5
from indie import indicator, format, plot, color, MutSeriesF
from indie.algorithms import Change, Ema


@indicator('Klinger Osc', format=format.VOLUME)  # Klinger Oscillator
@plot.line(color=color.BLUE, title='KO')
@plot.line(color=color.GREEN, title='Signal')
def Main(self):
    sv = MutSeriesF.new(self.volume[0] if Change.new(self.hlc3)[0] >= 0 else -self.volume[0])
    kvo = MutSeriesF.new(Ema.new(sv, 34)[0] - Ema.new(sv, 55)[0])
    sig = Ema.new(kvo, 13)
    return kvo[0], sig[0]

## Linear Regression Channel

```py Linear Regression Channel theme={null}
# indie:lang_version = 5
from math import sqrt, isnan, nan
from indie import indicator, param, source, color, MainContext, SeriesF
from indie.drawings import LineSegment, LabelAbs, AbsolutePosition, extend_type, callout_position
from indie.math import divide


def calc_slope(src: SeriesF, length: int) -> tuple[float, float, float]:
    sum_x = 0.0
    sum_y = 0.0
    sum_x_sqr = 0.0
    sum_xy = 0.0

    for i in range(length):
        val = src[i]
        per = i + 1.0
        sum_x += per
        sum_y += val
        sum_x_sqr += per * per
        sum_xy += val * per

    slope = divide(length * sum_xy - sum_x * sum_y, length * sum_x_sqr - sum_x * sum_x)
    average = sum_y / length
    intercept = average - slope * sum_x / length + slope

    return slope, average, intercept


def calc_dev(slope: float, average: float, intercept: float,
             src: SeriesF, high: SeriesF, low: SeriesF, length: int) -> tuple[float, float, float, float]:
    up_dev = 0.0
    dn_dev = 0.0
    std_dev_acc = 0.0
    dsxx = 0.0
    dsyy = 0.0
    dsxy = 0.0
    periods = length - 1
    day_y = intercept + slope * periods / 2
    val = intercept

    for j in range(length):
        price = high[j] - val
        if price > up_dev:
            up_dev = price

        price = val - low[j]
        if price > dn_dev:
            dn_dev = price

        price = src[j]
        dxt = price - average
        dyt = val - day_y
        price -= val
        std_dev_acc += price * price
        dsxx += dxt * dxt
        dsyy += dyt * dyt
        dsxy += dxt * dyt
        val += slope

    std_dev = sqrt(std_dev_acc / (periods if periods != 0 else 1))
    pearson_r = divide(dsxy, sqrt(dsxx * dsyy), 0.0)

    return std_dev, pearson_r, up_dev, dn_dev


@indicator('Linear Regression Channel', overlay_main_pane=True)
@param.int('length_input', default=100, min=1, max=5000, title='Length')
@param.source('source_input', default=source.CLOSE, title='Source')
@param.bool('use_upper_dev_input', default=True, title='Upper Deviation')
@param.float('upper_mult_input', default=2.0, title='Upper Multiplier')
@param.bool('use_lower_dev_input', default=True, title='Lower Deviation')
@param.float('lower_mult_input', default=2.0, title='Lower Multiplier')
@param.bool('show_pearson_input', default=True, title="Show Pearson's R")
@param.bool('extend_left_input', default=False, title='Extend Lines Left')
@param.bool('extend_right_input', default=True, title='Extend Lines Right')
class Main(MainContext):
    def __init__(self, extend_left_input, extend_right_input):
        # Determine extend type
        extend_style = extend_type.NONE
        if extend_left_input and extend_right_input:
            extend_style = extend_type.BOTH
        elif extend_left_input:
            extend_style = extend_type.LEFT
        elif extend_right_input:
            extend_style = extend_type.RIGHT

        self._base_line = LineSegment(
            AbsolutePosition(0, 0),
            AbsolutePosition(0, 0),
            extend_type=extend_style,
            color=color.RED,
        )
        self._upper_line = LineSegment(
            AbsolutePosition(0, 0),
            AbsolutePosition(0, 0),
            extend_type=extend_style,
            color=color.BLUE,
        )
        self._lower_line = LineSegment(
            AbsolutePosition(0, 0),
            AbsolutePosition(0, 0),
            extend_type=extend_style,
            color=color.BLUE,
        )
        self._pearson_label = LabelAbs(
            '',
            AbsolutePosition(0, 0),
            text_color=color.BLUE,
            callout_position=callout_position.BOTTOM_LEFT,
            bg_color=color.TRANSPARENT,
        )

    def calc(self,
             length_input, source_input,
             use_upper_dev_input, upper_mult_input,
             use_lower_dev_input, lower_mult_input,
             show_pearson_input):
        if not self.is_last_bar:
            return

        # Calculate regression parameters
        slope, average, intercept = calc_slope(source_input, length_input)

        if isnan(slope):
            return

        start_price = intercept + slope * (length_input - 1)
        end_price = intercept

        # Calculate deviations
        std_dev, pearson_r, up_dev, dn_dev = calc_dev(slope, average, intercept, source_input,
                                                      self.high, self.low, length_input)

        upper_start_price = start_price + (upper_mult_input * std_dev if use_upper_dev_input else up_dev)
        upper_end_price = end_price + (upper_mult_input * std_dev if use_upper_dev_input else up_dev)
        lower_start_price = start_price + (-lower_mult_input * std_dev if use_lower_dev_input else -dn_dev)
        lower_end_price = end_price + (-lower_mult_input * std_dev if use_lower_dev_input else -dn_dev)

        # Draw lines
        if not isnan(start_price) and not isnan(upper_start_price) and not isnan(lower_start_price):
            start_x = self.time[length_input - 1]
            end_x = self.time[0]

            # Update base line coordinates
            self._base_line.point_a = AbsolutePosition(start_x, start_price)
            self._base_line.point_b = AbsolutePosition(end_x, end_price)
            self.chart.draw(self._base_line)

            # Update upper line coordinates
            self._upper_line.point_a = AbsolutePosition(start_x, upper_start_price)
            self._upper_line.point_b = AbsolutePosition(end_x, upper_end_price)
            self.chart.draw(self._upper_line)

            # Update lower line coordinates
            self._lower_line.point_a = AbsolutePosition(start_x, lower_start_price)
            self._lower_line.point_b = AbsolutePosition(end_x, lower_end_price)
            self.chart.draw(self._lower_line)

            # Update Pearson's R label text and position
            if show_pearson_input and not isnan(pearson_r):
                self._pearson_label.text = str(round(pearson_r, 8))
                self._pearson_label.position = AbsolutePosition(start_x, lower_start_price)
                self.chart.draw(self._pearson_label)

## MA Cross

```py MA Cross theme={null}
# indie:lang_version = 5
from math import nan
from indie import indicator, param, plot, color
from indie.algorithms import Sma
from indie.math import cross


@indicator('MA Cross', overlay_main_pane=True)  # MA Cross
@param.int('short_len', default=9, min=1, title='Short MA Length')
@param.int('long_len', default=21, min=1, title='Long MA Length')
@plot.line(color=color.MAROON, title='Short')
@plot.line(color=color.GREEN, title='Long')
@plot.marker(color=color.BLUE, style=plot.marker_style.CROSS,
             position=plot.marker_position.CENTER, size=7, title='MA Cross')
def Main(self, short_len, long_len):
    short = Sma.new(self.close, short_len)
    long = Sma.new(self.close, long_len)
    return short[0], long[0], short[0] if cross(short, long) else nan

## Moving Average Convergence Divergence

```py Moving Average Convergence Divergence theme={null}
# indie:lang_version = 5
from indie import indicator, param, source, level, color, plot, Color
from indie.algorithms import Macd


@indicator('MACD')  # Moving Average Convergence Divergence
@param.int('fast_length', default=12, min=1, title='Fast Length')
@param.int('slow_length', default=26, min=1, title='Slow Length')
@param.source('src', default=source.CLOSE, title='Source')
@param.int('signal_length', default=9, min=1, max=50, title='Signal Smoothing')
@param.str('sma_source', default='EMA', title='Oscillator MA Type', options=['SMA', 'EMA'])
@param.str('sma_signal', default='EMA', title='Signal Line MA Type', options=['SMA', 'EMA'])
@level(0, line_color=color.GRAY(0.5))
@plot.columns(title='Histogram')
@plot.line(color=color.BLUE, title='MACD')
@plot.line(color=color.MAROON, title='Signal')
def Main(self, fast_length, slow_length, src, signal_length, sma_source, sma_signal):
    macd, signal, hist = Macd.new(src, fast_length, slow_length, signal_length, sma_source, sma_signal)

    hist_color = color.BLACK  # default value
    if hist[0] >= 0:
        if hist[1] < hist[0]:
            hist_color = color.GREEN
        else:
            hist_color = color.LIME
    else:
        if hist[1] < hist[0]:
            hist_color = color.RED
        else:
            hist_color = color.MAROON

    return (
        plot.Columns(hist[0], color=hist_color),
        macd[0],
        signal[0],
    )

## McGinley Dynamic

```py McGinley Dynamic theme={null}
# indie:lang_version = 5
from math import isnan, pow
from indie import indicator, param, plot, color, MutSeriesF
from indie.algorithms import Ema
from indie.math import divide


@indicator('McGinley', overlay_main_pane=True)  # McGinley Dynamic
@param.int('length', default=14, min=1)
@plot.line(color=color.BLUE)
def Main(self, length):
    mg = MutSeriesF.new(init=0)
    if isnan(mg[1]):
        mg[0] = Ema.new(self.close, length)[0]
    else:
        mg[0] = mg[1] + divide(self.close[0] - mg[1], length * pow(divide(self.close[0], mg[1]), 4))
    return mg[0]

atr = atr_mult * Atr.new(atr_length)[0]

median_ema = Ema.new(MutSeriesF.new(median), length)[0]

fill_color = color.LIME(0.9) if median > median_ema else color.FUCHSIA(0.9)
return (
    median_ema,
    median - atr,
    median,
    median + atr,
    plot.Fill(color=fill_color),
) ```

## Money Flow Index

```py Money Flow Index theme={null}
# indie:lang_version = 5
from indie import indicator, format, param, source, band, color, level, plot
from indie.algorithms import Mfi


@indicator('MFI', format=format.PRICE)  # Money Flow Index
@param.int('length', default=14, min=1)
@param.source('src', default=source.HLC3, title='Source')
@band(20, 80, line_color=color.GRAY, fill_color=color.PURPLE(0.1), title='Background')
@level(50, line_color=color.GRAY, title='Middle Band')
@plot.line(color=color.PURPLE, title='MF')
def Main(self, length, src):
    return Mfi.new(src, length)[0]

## On Balance Volume

```py On Balance Volume theme={null}
# indie:lang_version = 5
from indie import indicator, format, plot, color
from indie.algorithms import CumSum, NanToZero, NetVolume


@indicator('OBV', format=format.VOLUME)  # On Balance Volume
@plot.line(color=color.BLUE)
def Main(self):
    return CumSum.new(NanToZero.new(NetVolume.new(self.close)))[0]
    # TODO: implement smoothing when display.none is supported

## Pivot Points High/Low

```py Pivot Points High/Low theme={null}
# indie:lang_version = 5
from math import isnan
from indie import indicator, param, Optional, MainContext, color
from indie.algorithms import PivotHighLow, SinceHighest, SinceLowest
from indie.drawings import LabelAbs, AbsolutePosition, callout_position


@indicator('Pivots High/Low', overlay_main_pane=True)
@param.int('length_high_left', default=10, min=1, title='High left length')
@param.int('length_low_left', default=10, min=1, title='Low left length')
@param.int('length_high_right', default=10, min=1, title='High right length')
@param.int('length_low_right', default=10, min=1, title='Low right length')
# Display potential pivot points in real-time before right-side confirmation
@param.bool('show_unconfirmed', default=True, title='Show potential pivot points')
class Main(MainContext):
    def __init__(self):
        none_label: Optional[LabelAbs] = None
        self._prev_high_pivot = self.new_var(none_label)
        self._prev_high_pivot_bar_index = self.new_var(0)
        self._prev_low_pivot = self.new_var(none_label)
        self._prev_low_pivot_bar_index = self.new_var(0)

    def calc(self, length_high_left, length_low_left, length_high_right, length_low_right, show_unconfirmed):
        if show_unconfirmed:
            sh = SinceHighest.new(self.high, length_high_left + 1)
            sl = SinceLowest.new(self.low, length_low_left + 1)

            if sh[0] == 0:
                # we have a new high pivot candidate
                new_h_pivot_candidate_y = self.high[0]
                hp_opt: Optional[LabelAbs] = self._prev_high_pivot.get()
                if hp_opt is not None:  # we have a previous high pivot, must decide which one is better
                    if self.bar_index - self._prev_high_pivot_bar_index.get() > length_high_right:
                        self._prev_high_pivot.set(None)  # prev_high_pivot is too far away in history, forget about it
                    elif hp_opt.value().position.price < new_h_pivot_candidate_y:
                        self._update_high_pivot()  # new pivot candidate is better, update previous pivot
                    # else new pivot candidate is worse, keep the previous pivot
                if self._prev_high_pivot.get() is None:
                    self._update_high_pivot()  # create new low pivot
            if sl[0] == 0:
                new_l_pivot_candidate_y = self.low[0]
                lp_opt: Optional[LabelAbs] = self._prev_low_pivot.get()
                if lp_opt is not None:  # we have a previous low pivot, must decide which one is better
                    if self.bar_index - self._prev_low_pivot_bar_index.get() > length_low_right:
                        self._prev_low_pivot.set(None)  # prev_low_pivot is too far away in history, forget about it
                    elif lp_opt.value().position.price > new_l_pivot_candidate_y:
                        self._update_low_pivot()  # new pivot candidate is better, update previous pivot
                    # else new pivot candidate is worse, keep the previous pivot
                if self._prev_low_pivot.get() is None:
                    self._update_low_pivot()  # create new low pivot
        else:
            ph, _ = PivotHighLow.new(self.high, left_bars=length_high_left, right_bars=length_high_right)
            _, pl = PivotHighLow.new(self.low, left_bars=length_low_left, right_bars=length_low_right)

            if not isnan(ph[0]):
                new_pivot_y = self.high[length_high_right]
                new_pivot_x = self.time[length_high_right]
                self.chart.draw(self._create_new_label(new_pivot_x, new_pivot_y, is_high=True))  # create and draw

            if not isnan(pl[0]):
                new_pivot_y = self.low[length_low_right]
                new_pivot_x = self.time[length_low_right]
                self.chart.draw(self._create_new_label(new_pivot_x, new_pivot_y, is_high=False))  # create and draw

    def _update_high_pivot(self) -> None:
        new_pivot_y = self.high[0]
        new_pivot_x = self.time[0]
        new_pivot_bar_index = self.bar_index

        if self._prev_high_pivot.get() is None:  # create and draw
            self._prev_high_pivot.set(self._create_new_label(new_pivot_x, new_pivot_y, is_high=True))
        else:  # update field values and redraw
            hp = self._prev_high_pivot.get().value()
            hp.position = AbsolutePosition(new_pivot_x, new_pivot_y)
            hp.text = str(round(new_pivot_y, self.info.price_precision))

        self._prev_high_pivot_bar_index.set(new_pivot_bar_index)
        self.chart.draw(self._prev_high_pivot.get().value())

    def _update_low_pivot(self) -> None:
        new_pivot_y = self.low[0]
        new_pivot_x = self.time[0]
        new_pivot_bar_index = self.bar_index

        if self._prev_low_pivot.get() is None:  # create and draw
            self._prev_low_pivot.set(self._create_new_label(new_pivot_x, new_pivot_y, is_high=False))
        else:  # update field values and redraw
            lp = self._prev_low_pivot.get().value()
            lp.position = AbsolutePosition(new_pivot_x, new_pivot_y)
            lp.text = str(round(new_pivot_y, self.info.price_precision))

        self._prev_low_pivot_bar_index.set(new_pivot_bar_index)
        self.chart.draw(self._prev_low_pivot.get().value())

    def _create_new_label(self, time: float, price: float, is_high: bool) -> LabelAbs:
        text_color = color.GREEN if is_high else color.RED
        callout_pos = callout_position.TOP_RIGHT if is_high else callout_position.BOTTOM_LEFT
        return LabelAbs(
            str(round(price, self.info.price_precision)),
            AbsolutePosition(time, price),
            callout_position=callout_pos,
            bg_color=color.TRANSPARENT,
            text_color=text_color,
            font_size=11,
        )

def calc(self, show_labels, show_prices):
    pivot_level = MutSeriesF.new((self._prev_high[0] + self._prev_low[0] + self._prev_close[0]) / 3)
    if isnan(pivot_level[0]):
        return
    resistance_levels = [
        pivot_level[0] * 2 - self._prev_low[0],
        pivot_level[0] + (self._prev_high[0] - self._prev_low[0]),
        self._prev_high[0] + 2 * (pivot_level[0] - self._prev_low[0]),
    ]
    support_levels = [
        pivot_level[0] * 2 - self._prev_high[0],
        pivot_level[0] - (self._prev_high[0] - self._prev_low[0]),
        self._prev_low[0] - 2 * (self._prev_high[0] - pivot_level[0]),
    ]

    pivot_line = self._pivot_line.get()
    res_lines = self._resistance_lines
    sup_lines = self._support_lines
    if pivot_level[0] != pivot_level[1]:
        if pivot_line is not None:  # updating the previous lines if exist
            pivot_line.value().point_b.time = self.time[0]
            pivot_line.value().extend_type = extend_type.NONE
            self.chart.draw(pivot_line.value())

            for res_line in res_lines:
                res_line.get().value().point_b.time = self.time[0]
                res_line.get().value().extend_type = extend_type.NONE
                self.chart.draw(res_line.get().value())

            for sup_line in sup_lines:
                sup_line.get().value().point_b.time = self.time[0]
                sup_line.get().value().extend_type = extend_type.NONE
                self.chart.draw(sup_line.get().value())

        # creating new pivot line and label
        new_pivot_line = LineSegment(
            AbsolutePosition(self.time[0], pivot_level[0]),
            AbsolutePosition(self.time[0], pivot_level[0]),
            line_width=1, extend_type=extend_type.RIGHT, color=color.GRAY,
        )
        self._pivot_line.set(new_pivot_line)
        self.chart.draw(self._pivot_line.get().value())
        if show_labels or show_prices:
            text = 'P ' if show_labels else ''
            text += ('(' + str(round(pivot_level[0], self.info.price_precision)) + ')') if show_prices else ''
            new_pivot_label = LabelAbs(
                text,
                AbsolutePosition(self.time[0], pivot_level[0]),
                bg_color=color.TRANSPARENT,
                text_color=color.rgba(187, 187, 187),
                font_size=11,
                callout_position=callout_position.TOP_LEFT,  # TODO: callout_position.LEFT
            )
            self.chart.draw(new_pivot_label)

        for i in range(len(res_lines)):  # creating new support and resistance lines and labels
            res_line = res_lines[i]
            sup_line = sup_lines[i]
            new_resistance_line = LineSegment(
                AbsolutePosition(self.time[0], resistance_levels[i]),
                AbsolutePosition(self.time[0], resistance_levels[i]),
                extend_type=extend_type.RIGHT, color=color.GRAY,
                line_width=1,
            )
            res_line.set(new_resistance_line)
            self.chart.draw(res_line.get().value())
            new_support_line = LineSegment(
                AbsolutePosition(self.time[0], support_levels[i]),
                AbsolutePosition(self.time[0], support_levels[i]),
                extend_type=extend_type.RIGHT, color=color.GRAY,
                line_width=1,
            )
            sup_line.set(new_support_line)
            self.chart.draw(sup_line.get().value())
            if show_labels or show_prices:
                text = 'R' + str(i + 1) if show_labels else ''
                text += ('(' + str(round(resistance_levels[i], self.info.price_precision)) + ')') if show_prices else ''
                new_resistance_label = LabelAbs(
                    text,
                    AbsolutePosition(self.time[0], resistance_levels[i]),
                    bg_color=color.TRANSPARENT,
                    text_color=color.rgba(187, 187, 187),
                    font_size=11,
                    callout_position=callout_position.TOP_LEFT,  # TODO: callout_position.LEFT
                )
                self.chart.draw(new_resistance_label)

                text = 'S' + str(i + 1) if show_labels else ''
                text += ('(' + str(round(support_levels[i], self.info.price_precision)) + ')') if show_prices else ''
                new_support_label = LabelAbs(
                    text,
                    AbsolutePosition(self.time[0], support_levels[i]),
                    bg_color=color.TRANSPARENT,
                    text_color=color.rgba(187, 187, 187),
                    font_size=11,
                    callout_position=callout_position.TOP_LEFT,  # TODO: callout_position.LEFT
                )
                self.chart.draw(new_support_label)
    else:  # the same levels, just updating the right points of previous lines
        if (pivot_line is not None) and (pivot_line.value().point_b.time != self.time[0]):
            pivot_line.value().point_b.time = self.time[0]
            self.chart.draw(pivot_line.value())
            for res_line in res_lines:
                res_line.get().value().point_b.time = self.time[0]
                self.chart.draw(res_line.get().value())
            for sup_line in sup_lines:
                sup_line.get().value().point_b.time = self.time[0]
                self.chart.draw(sup_line.get().value())
    return ```

## Price Volume Trend

```py Price Volume Trend theme={null}
# indie:lang_version = 5
from indie import indicator, format, plot, color, MutSeriesF
from indie.algorithms import CumSum, NanToZero, Change
from indie.math import divide


@indicator('PVT', format=format.VOLUME)  # Price Volume Trend
@plot.line(color=color.BLUE)
def Main(self):
    return CumSum.new(NanToZero.new(MutSeriesF.new(
        divide(Change.new(self.close)[0], self.close[1]) * self.volume[0])))[0]

## Relative Vigor Index

```py Relative Vigor Index theme={null}
# indie:lang_version = 5
from indie import algorithm, SeriesF, MutSeriesF, indicator, format, param, plot, color
from indie.algorithms import Sum
from indie.math import divide


@algorithm  # Symmetrically Weighted Moving Average
def Swma(self, src: SeriesF) -> SeriesF:
    return MutSeriesF.new(src[3] / 6 + src[2] / 3 + src[1] / 3 + src[0] / 6)


@indicator('RVGI', format=format.PRICE, precision=4)  # Relative Vigor Index
@param.int('length', default=10, min=1)
@param.int('offset', default=0, min=-500, max=500)
@plot.line(color=color.GREEN, title='RVGI')
@plot.line(color=color.RED, title='Signal')
def Main(self, length, offset):
    cl_op_sum = Sum.new(Swma.new(MutSeriesF.new(self.close[0] - self.open[0])), length)[0]
    hi_lo_sum = Sum.new(Swma.new(MutSeriesF.new(self.high[0] - self.low[0])), length)[0]
    rvi = divide(cl_op_sum, hi_lo_sum)
    sig = Swma.new(MutSeriesF.new(rvi))[0]
    return plot.Line(rvi, offset=offset), plot.Line(sig, offset=offset)

low_value, rvi_ma, high_value = nan, nan, nan
if ma_type == 'Bollinger Bands':
    (bb_lower, bb_middle, bb_upper) = Bb.new(rvi, ma_length, bb_mult)
    low_value = bb_lower[0]
    rvi_ma = bb_middle[0]
    high_value = bb_upper[0]
else:
    rvi_ma = Ma.new(rvi, ma_length, ma_type)[0]

return (
    plot.Line(rvi_ma, offset=offset),
    plot.Line(rvi[0], offset=offset),
    low_value,
    high_value,
    plot.Fill(),
) ```

is_bb = ma_type == 'Bollinger Bands'

ma_algorithm = 'SMA' if is_bb else ma_type
rsi_ma = Ma.new(rsi, ma_length, ma_algorithm)

std_dev = StdDev.new(rsi, ma_length)
bb_lower = rsi_ma[0] - std_dev[0] * bb_mult if is_bb else nan
bb_upper = rsi_ma[0] + std_dev[0] * bb_mult if is_bb else nan
return rsi_ma[0], rsi[0], bb_lower, bb_upper, plot.Fill() ```

## SMI Ergodic Indicator

```py SMI Ergodic Indicator theme={null}
# indie:lang_version = 5
from indie import indicator, format, param, plot, color
from indie.algorithms import Tsi, Ema


@indicator('SMII', format=format.PRICE, precision=4)  # SMI Ergodic Indicator
@param.int('long_len', default=20, min=1, title='Long Length')
@param.int('short_len', default=5, min=1, title='Short Length')
@param.int('signal_len', default=5, min=1, title='Signal Length')
@plot.line(color=color.BLUE, title='SMI')
@plot.line(color=color.MAROON, title='Signal')
def Main(self, long_len, short_len, signal_len):
    tsi = Tsi.new(self.close, long_len, short_len)
    return tsi[0], Ema.new(tsi, signal_len)[0]

## Smoothed Moving Average

```py Smoothed Moving Average theme={null}
# indie:lang_version = 5
from indie import indicator, param, source, plot, color
from indie.algorithms import Rma


@indicator('SMMA', overlay_main_pane=True)  # Smoothed Moving Average
@param.int('length', default=7, min=1)
@param.source('src', default=source.CLOSE, title='Source')
@plot.line(color=color.PURPLE)
def Main(self, length, src):
    return Rma.new(src, length)[0]

## Stochastic RSI

```py Stochastic RSI theme={null}
# indie:lang_version = 5
from indie import indicator, format, param, source, band, color, level, plot
from indie.algorithms import Rsi, Stoch, Sma


@indicator('Stoch RSI', format=format.PRICE)  # Stochastic RSI
@param.int('k_smoothing', default=3, min=1, title='Fast K stochastic smoothing')
@param.int('d_smoothing', default=3, min=1, title='Slow D stochastic smoothing')
@param.int('rsi_length', default=14, min=1, title='RSI length')
@param.int('k_length', default=14, min=1, title='Stochastic Length')
@param.source('src', default=source.CLOSE, title='Source')
@band(20, 80, fill_color=color.AQUA(0.1), line_color=color.GRAY, title='Background')
@level(50, line_color=color.GRAY(0.5), title='Middle Band')
@plot.line(color=color.BLUE, title='K')
@plot.line(color=color.RED, title='D')
def Main(self, k_smoothing, d_smoothing, rsi_length, k_length, src):
    rsi = Rsi.new(src, rsi_length)
    k = Sma.new(Stoch.new(rsi, rsi, rsi, k_length), k_smoothing)
    d = Sma.new(k, d_smoothing)
    return k[0], d[0]

## Triple EMA

```py Triple EMA theme={null}
# indie:lang_version = 5
from indie import indicator, param, source, plot, color
from indie.algorithms import Ema


@indicator('TEMA', overlay_main_pane=True)  # Triple EMA
@param.int('length', default=9, min=1)
@param.source('src', default=source.CLOSE, title='Source')
@plot.line(color=color.BLUE)
def Main(self, length, src):
    ema1 = Ema.new(src, length)
    ema2 = Ema.new(ema1, length)
    ema3 = Ema.new(ema2, length)
    return 3 * (ema1[0] - ema2[0]) + ema3[0]

pre_market_background = plot.Background()
if self.time[0] not in self.trading_session.pre_market:
    pre_market_background.color = color.TRANSPARENT

after_hours_background = plot.Background()
if self.time[0] not in self.trading_session.after_hours:
    after_hours_background.color = color.TRANSPARENT

after_hours_background.outline_left = (
    not isnan(self.time[1]) and
    not self.trading_session.is_same_period(self.time[0], self.time[1])
)

return pre_market_background, after_hours_background ```

## True Strength Indicator

```py True Strength Indicator theme={null}
# indie:lang_version = 5
from indie import indicator, format, param, level, color, plot
from indie.algorithms import Tsi, Ema


@indicator('TSI', format=format.PRICE, precision=4)  # True Strength Indicator
@param.int('long_len', default=25, min=1, title='Long Length')
@param.int('short_len', default=13, min=1, title='Short Length')
@param.int('signal_len', default=13, min=1, title='Signal Length')
@level(0, line_color=color.GRAY, title='Zero')
@plot.line(color=color.BLUE, title='TSI')
@plot.line(color=color.RED, title='Signal')
def Main(self, long_len, short_len, signal_len):
    tsi = Tsi.new(self.close, long_len, short_len)
    return 100 * tsi[0], 100 * Ema.new(tsi, signal_len)[0]

## Volatility Stop

```py Volatility Stop theme={null}
# indie:lang_version = 5
from math import isnan, nan
from indie import indicator, param, source, plot, color, Var, MutSeries
from indie.algorithms import Atr, Tr


@indicator('VStop', overlay_main_pane=True)  # Volatility Stop
@param.source('src', default=source.CLOSE, title='Source')
@param.int('length', default=20, min=2, title='ATR Length')
@param.float('factor', default=2.0, min=0.25, step=0.25, title='Multiplier')
@plot.marker(title='VStop (Cross)', size=3, style=plot.marker_style.CROSS, position=plot.marker_position.CENTER)
@plot.line(title='VStop (Line)', display_options=plot.LineDisplayOptions())
def Main(self, src, length, factor):
    if isnan(src[0]):
        return plot.Marker(value=nan), plot.Line(value=nan)

    atr_val = Atr.new(length)[0]
    atr_mult = (atr_val * factor) if not isnan(atr_val) else Tr.new()[0]

    uptrend = MutSeries[bool].new(init=True)
    stop = Var[float].new(src[0])
    mn = Var[float].new(src[0])
    mx = Var[float].new(src[0])

    not_first = self.bar_index > 0
    mx.set(max(mx.get(), src[0]))
    mn.set(min(mn.get(), src[0]))
    prev_stop = stop.get()

    prev_trend = uptrend[0]
    vstop = nan
    if prev_trend:
        vstop = max(prev_stop, mx.get() - atr_mult)
    else:
        vstop = min(prev_stop, mn.get() + atr_mult)

    curr_trend = (src[0] >= vstop)
    if not_first and curr_trend != prev_trend:
        mx.set(src[0]); mn.set(src[0])
        vstop = (mx.get() - atr_mult) if curr_trend else (mn.get() + atr_mult)

    stop.set(vstop)
    uptrend[0] = curr_trend

    col = color.TEAL if curr_trend else color.RED
    return (
        plot.Marker(vstop, color=col),
        plot.Line(vstop, color=col)
    )

## Vortex Indicator

```py Vortex Indicator theme={null}
# indie:lang_version = 5
from indie import indicator, format, param, plot, color, MutSeriesF
from indie.algorithms import Sum, Atr
from indie.math import divide


@indicator('VI', format=format.PRICE, precision=4)  # Vortex Indicator
@param.int('length', default=14, min=2)
@plot.line(color=color.RED, title='VI -')
@plot.line(color=color.BLUE, title='VI +')
def Main(self, length):
    vmm = Sum.new(MutSeriesF.new(abs(self.low[0] - self.high[1])), length)[0]
    vmp = Sum.new(MutSeriesF.new(abs(self.high[0] - self.low[1])), length)[0]
    satr = Sum.new(Atr.new(1), length)[0]
    vim = divide(vmm, satr)
    vip = divide(vmp, satr)
    return vim, vip

## Volume Moving Average Weighted

```py Volume Moving Average Weighted theme={null}
# indie:lang_version = 5
from indie import indicator, param, source, plot, color
from indie.algorithms import Vwma


@indicator('VWMA', overlay_main_pane=True)  # Volume Weighted Moving Average
@param.int('length', default=20, min=1)
@param.source('src', default=source.CLOSE, title='Source')
@param.int('offset', default=0, min=-500, max=500, title='Offset')
@plot.line(color=color.BLUE)
def Main(self, length, src, offset):
    result = Vwma.new(src, length)
    return plot.Line(result[0], offset=offset)

return (
    plot.Line(jaw[0], offset=jaw_offset),
    plot.Line(teeth[0], offset=teeth_offset),
    plot.Line(lips[0], offset=lips_offset),
) ```

## Moving Average Weighted

```py Moving Average Weighted theme={null}
# indie:lang_version = 5
from indie import indicator, param, source, plot, color
from indie.algorithms import Wma


@indicator('WMA', overlay_main_pane=True)  # Weighted Moving Average
@param.int('length', default=9, min=1)
@param.source('src', default=source.CLOSE, title='Source')
@param.int('offset', default=0, min=-500, max=500, title='Offset')
@plot.line(color=color.BLUE)
def Main(self, length, src, offset):
    result = Wma.new(src, length)
    return plot.Line(result[0], offset=offset)

hist_color = color.BLACK  # default value
if last_5_up:
    hist_color = color.GREEN
elif last_5_down:
    hist_color = color.RED
elif cci_14[0] < 0:
    hist_color = color.GREEN
else:
    hist_color = color.RED
return plot.Histogram(cci_14[0], color=hist_color), cci_turbo[0], cci_14[0] ```

def update_pivot(self, end: AbsolutePosition,
                 vol: float, settings: Settings) -> None:
    self.end = end
    self.vol = vol
    if self.lb is not None:
        self.lb.value().position = self.end
        self.lb.value().text = price_rotation_aggregate(self.start.price, self.end.price,
                                                        self.vol, settings)
        self.chart.draw(self.lb.value())
    self.ln.value().point_b = self.end
    self.chart.draw(self.ln.value())

def delete(self) -> None:
    if self.ln is not None:
        self.chart.erase(self.ln.value())
    if self.lb is not None:
        self.chart.erase(self.lb.value())

def is_more_price(self, point: AbsolutePosition) -> bool:
    m = 1 if self.is_high else -1
    return point.price * m > self.end.price * m

def update_last_pivot(self, point: AbsolutePosition, chart: Chart) -> None:
    last_pivot = self.last_pivot.value()
    if self.pivots_num == 1:
        last_pivot.start = point
        if self.settings.draw:
            last_pivot.ln.value().point_a = point
            chart.draw(last_pivot.ln.value())
    last_pivot.update_pivot(point, last_pivot.vol + self.sum_vol, self.settings)
    self.sum_vol = 0

def new_pivot_found(self, new_pivot: Pivot) -> None:
    self.last_pivot = new_pivot
    self.pivots_num += 1
    self.sum_vol = 0

def new_pivot_point_found(self, is_high: bool, point: AbsolutePosition, chart: Chart) -> bool:
    result = False
    last_pivot = self.last_pivot
    if last_pivot is not None:
        if last_pivot.value().is_high == is_high:
            if last_pivot.value().is_more_price(point):
                self.update_last_pivot(point, chart)
                result = True
        else:
            dev = calc_dev(last_pivot.value().end.price, point.price)
            if ((not last_pivot.value().is_high and dev >= self.settings.dev_threshold) or
                    (last_pivot.value().is_high and dev <= -1 * self.settings.dev_threshold)):
                self.new_pivot_found(new_pivot(chart, last_pivot.value().end, point,
                                               self.sum_vol, is_high, self.settings))
                result = True
    else:
        self.new_pivot_found(new_pivot(chart, point, point,
                                       self.sum_vol, is_high, self.settings))
        result = True
    return result

def try_find_pivot(self, chart: Chart, bar_index: int, time: SeriesF, src: SeriesF,
                   is_high: bool, depth: int, register_pivot: bool = True) -> bool:
    point = find_pivot_point(bar_index, time, src, depth, is_high)
    return self.new_pivot_point_found(is_high, point.value(), chart) \
        if point is not None and register_pivot else False

def pre_calc(self):
    self._settings.price_precision = self.info.price_precision

def calc(self):
    zig_zag = self._zig_zag_var.get()

    depth = max(2, zig_zag.settings.depth // 2)
    zig_zag.sum_vol += 0 if isnan(self.volume[depth]) else self.volume[depth]
    something_changed = zig_zag.try_find_pivot(self.chart, self.bar_index, self.time,
                                               self.high, True, depth)
    something_changed = zig_zag.try_find_pivot(
        self.chart, self.bar_index, self.time, self.low, False, depth,
        zig_zag.settings.allow_zig_zag_on_one_bar or not something_changed
    ) or something_changed
    last_pivot = zig_zag.last_pivot
    rem_vol = Sum.new(self.volume, depth)[0]
    if zig_zag.settings.extend_last and self.is_last_bar and last_pivot is not None:
        is_high = not last_pivot.value().is_high
        cur_series = self.high if is_high else self.low
        end = AbsolutePosition(self.time[0], cur_series[0])
        if zig_zag.extend is None or something_changed:
            if zig_zag.extend is not None:
                zig_zag.extend.value().delete()
            zig_zag.extend = new_pivot(self.chart, last_pivot.value().end, end,
                                       zig_zag.sum_vol, is_high, zig_zag.settings)
        zig_zag.extend.value().update_pivot(end, zig_zag.sum_vol + rem_vol, zig_zag.settings) ```

# Example 2: Label price breakouts
highest_20 = Highest.new(self.high, 20)
if self.close[0] > highest_20[1]:
    self.chart.draw(LabelAbs(
        "BREAKOUT!",
        AbsolutePosition(self.time[0], self.close[0]),
        bg_color=color.BLUE,
    )) ```

def calc(self):
    self.is_visible = not self.is_visible

    if self.is_visible:
        self.line_segment = LineSegment(
            AbsolutePosition(self.time[1], self.close[1]),
            AbsolutePosition(self.time[0], self.close[0]),
            extend_type=extend_type.RIGHT,
        )
        self.chart.draw(self.line_segment.value())
    elif self.line_segment is not None:
        self.chart.erase(self.line_segment.value())  # Runtime error! ```

def calc(self):
    self.is_visible = not self.is_visible

    if self.is_visible:
        self.line_segment.set(LineSegment(
            AbsolutePosition(self.time[1], self.high[1]),
            AbsolutePosition(self.time[0], self.close[0]),
            extend_type=extend_type.RIGHT,
        ))
        self.chart.draw(self.line_segment.get().value())
    else:
        if self.line_segment.get() is not None:
            self.chart.erase(self.line_segment.get().value())
        self.line_segment.set(None) ```

def calc(self):
    # Always clean up first - handles all rollback scenarios
    if self.line_segment.get() is not None:
        self.chart.erase(self.line_segment.get().value())
        self.line_segment.set(None)

    # Then conditionally draw
    if self.is_visible:
        self.line_segment.set(LineSegment(
            AbsolutePosition(self.time[1], self.close[1]),
            AbsolutePosition(self.time[0], self.close[0]),
            extend_type=extend_type.RIGHT,
        ))
        self.chart.draw(self.line_segment.get().value())

    # Toggle for next execution
    self.is_visible = not self.is_visible ```

length = short_len
if long_sma[0] >= short_sma[0]:
    length = long_len
# So, strictly speaking, `length` is not a series, but just a number.
# But it is kinda series, because it may have different values on different bars.
# NOTE: If you need a truly series length, wrap it with `MutSeriesF.new(length)`.

return (
    MySma.new(self.high, length)[0], # Do not use indie.algorithms.Sma here,
                                        # because `length` is not constant over
                                        # different bars. You may try and see how
                                        # indicator starts giving bad results.
    short_sma[0],
    long_sma[0],
) ```

return green_count[0], red_count[0] ```

## Green/Red Bar Count - usage example of indie.Var\[T]

This update of "Green/Red Bar Counts" indicator showcases the `indie.Var[T]` container usage.

In this implementation:

* State Tracking: The `indie.Var[T]` container counts consecutive green (up) or red (down) bars without retaining any history. `indie.Var[T]` is ideal here since it efficiently holds only the most recent value, unlike indie.MutSeries\[T], which maintains a historical sequence of values.

### Why Use indie.Var Instead of a Simple Float or Integer?

Unlike using a single `float` or `int`, `indie.Var` is fully compatible with Indie’s series-based environment, where values update bar by bar. Plain variables would reset on each new bar calculation, causing them to lose their previous state. Moreover, `indie.Var` ensures that values persist correctly in both historical and real-time data. A simple local number variable would reset or lack the ability to update accurately in real-time, making it unsuitable for cumulative calculations. In contrast, indie.Var provides stable, consistent updates across all bars.

### Key Differences with the Previous Version: General Transformation from `MutSeries` to `Var`

In cases where only the latest value is required without retaining historical data, you can convert code from indie.MutSeries to indie.Var by following these general rules:

1. Replace `MutSeries.new()` with `Var.new()`:

`my_var = Var[float].new(0)  # instead of my_series = MutSeries[float].new(0)`

2. Use `.get()` and `.set()` instead of indexing:

`var_value = my_var.get()  # instead of series_value = my_series[0]`

`my_var.set(new_value)  # instead of my_series[0] = new_value`

```py Green/Red Bar Count - usage example of indie.Var[T] theme={null}
# Copyright (c) 2024 @TakeProfit. All rights reserved.

# This work is licensed under the MIT License.
# For a copy, see <https://opensource.org/licenses/MIT>.

# indie:lang_version = 5
from indie import indicator, Var, Context, plot, color

def is_green_bar(ctx: Context) -> bool:
    return ctx.close[0] >= ctx.open[0]

@indicator('Green/Red Bar Counts')
@plot.steps(color=color.GREEN)
@plot.steps(color=color.RED)
def Main(self):
    # `indie.Var[T]` is a generic class,
    # `T` can be `float`, `int`, `bool`, `str`, etc.
    green_count = Var[int].new(0)
    red_count = Var[int].new(0)
    if is_green_bar(self):
        green_count.set(green_count.get() + 1)
        red_count.set(0)
    else:
        green_count.set(0)
        red_count.set(red_count.get() - 1)

    return green_count.get(), red_count.get()

def calc(self, src: SeriesF, length: int) -> SeriesF:
    # TODO: Need self.ctx.is_new_bar here
    is_new_bar = self._bar_count != len(src)
    self._bar_count = len(src)

    # First we search in our sorted array for an index where
    # the new element will be inserted. We add new element at position
    # of some existing element which is need to leave the array anyway
    insert_index = -1
    if len(self._sorted_vals) == length or not is_new_bar:
        val_to_remove = math.nan
        if not is_new_bar:
            val_to_remove = self._prev_src_val
        else:
            val_to_remove = src[length]
        for i in range(len(self._sorted_vals)):
            val = self._sorted_vals[i]
            if val == val_to_remove:
                insert_index = i
                break
    else:
        self._sorted_vals.append(math.nan)
        insert_index = len(self._sorted_vals) - 1

    # Insert the new element in our sorted array.
    # After this line the sorted order could be broken (most likely it is)
    self._sorted_vals[insert_index] = self._prev_src_val = src[0]

    # Restore sorted order in our array
    while insert_index > 0 and self._sorted_vals[insert_index - 1] > self._sorted_vals[insert_index]:
        swap(self._sorted_vals, insert_index, insert_index - 1)
        insert_index -= 1
    while insert_index < len(self._sorted_vals) - 1 and self._sorted_vals[insert_index] > self._sorted_vals[insert_index + 1]:
        swap(self._sorted_vals, insert_index, insert_index + 1)
        insert_index += 1

    # Find the median value
    res = math.nan
    if len(self._sorted_vals) == length:
        if length % 2 == 1:
            # Odd number of elements, e.g. [1, 3, 5] so the median is 3
            res = self._sorted_vals[(length - 1) // 2]
        else:
            # Even number of elements, e.g. [1, 3, 5, 7]
            # so the median is (3 + 5) / 2 = 8
            mid_index = (length - 1) // 2
            left = self._sorted_vals[mid_index]
            right = self._sorted_vals[mid_index + 1]
            res = (left + right) / 2

    return MutSeriesF.new(res)

## Custom VWAP - usage example of indie.Schedule class

The "Custom VWAP" indicator demonstrates the usage of the `Schedule` class. If we don’t want to reset VWAP at the start of each new default trading day (using the 'Session' option of the anchor parameter), we can create a custom schedule to define the reset time.

For example, by default, the VWAP reset time for 'BTC/USDT' is at 00:00 UTC. However, we may want to change this reset time to 00:00 in our chosen timezone (e.g., 'America/New\_York' for this indicator).

Key Points:

* The custom schedule is defined in the `__init__` function because creating it on each bar in the `Context.calc` function is resource-inefficient. Alternatively, the `Context.pre_calc` function can be used for schedule definition if we need to access data from `self.info` or `self.trading_session`.
* The is\_same\_period method (for both `Schedule` and `Session` options) is used to detect whether two timestamps belong to the same schedule period or fall on different days.

```py Custom VWAP - usage example of indie.Schedule class theme={null}
# Copyright (c) 2024 @TakeProfit. All rights reserved.

# This work is licensed under the MIT License.
# For a copy, see <https://opensource.org/licenses/MIT>.

# indie:lang_version = 5
from math import sqrt
from datetime import datetime, time
from indie import algorithm, SeriesF, MutSeriesF, Var, Optional, IndieError, MainContext, plot
from indie import indicator, param, source, plot, color
from indie.schedule import Schedule, ScheduleRule


@algorithm
def Vwap(self, src: SeriesF, anchor: str, std_dev_mult: float, schedule: Optional[Schedule] = None) -> tuple[SeriesF, SeriesF, SeriesF]:
    '''
    Custom Volume Weighted Average Price
    anchor can be 'Session', 'Day', 'Week', 'Month', 'Year', 'Schedule'
    '''
    cum_weighted_price = Var[float].new(0)
    cum_volume = Var[float].new(0)
    vwap_sum = Var[float].new(0)
    vwap_count = Var[int].new(0)
    vwap_dev_squares = Var[float].new(0)

    current_datetime = datetime.utcfromtimestamp(self.ctx.time[0])
    prev_datetime = datetime.utcfromtimestamp(self.ctx.time.get(1, 0))
    need_reset = False

    if anchor == 'Schedule' and schedule is None:
        raise IndieError("Schedule parameter cannot be None when anchor is set to 'Schedule'")

    if anchor == 'Schedule' and \
            not schedule.value().is_same_period(self.ctx.time[0], self.ctx.time.get(1, 0)):
        need_reset = True
    if anchor == 'Session' and \
            not self.ctx.trading_session.is_same_period(self.ctx.time[0], self.ctx.time.get(1, 0)):
        need_reset = True
    if anchor == 'Day' and (current_datetime.day != prev_datetime.day or
                            (current_datetime-prev_datetime).days >= 1):
        need_reset = True
    elif anchor == 'Week' and ((current_datetime.weekday() == 0 and prev_datetime.weekday() != 0) or
                                (current_datetime-prev_datetime).days >= 7):
        need_reset = True
    elif anchor == 'Month' and (current_datetime.month != prev_datetime.month or
                                (current_datetime-prev_datetime).days >= 31):
        need_reset = True
    elif anchor == 'Year' and current_datetime.year != prev_datetime.year:
        need_reset = True

    if need_reset:
        cum_weighted_price.set(0)
        cum_volume.set(0)
        vwap_sum.set(0)
        vwap_count.set(0)
        vwap_dev_squares.set(0)

    cum_weighted_price.set(cum_weighted_price.get() + src[0] * self.ctx.volume[0])
    cum_volume.set(cum_volume.get() + self.ctx.volume[0])
    vwap_value = cum_weighted_price.get() / cum_volume.get()

    vwap_sum.set(vwap_sum.get() + vwap_value)
    vwap_count.set(vwap_count.get() + 1)
    vwap_avg = vwap_sum.get() / vwap_count.get()
    vwap_dev_squares.set(vwap_dev_squares.get() + (vwap_value - vwap_avg) ** 2)
    vwap_std_dev = sqrt(vwap_dev_squares.get() / vwap_count.get())

    std_dev = std_dev_mult * vwap_std_dev
    lower = MutSeriesF.new(vwap_value - std_dev)
    upper = MutSeriesF.new(vwap_value + std_dev)

    return MutSeriesF.new(vwap_value), upper, lower

@indicator('Custom VWAP', overlay_main_pane=True)  # Volume Weighted Average Price
@param.source('src', default=source.HLC3, title='Source')
@param.str('anchor', default='Schedule', options=['Session', 'Day', 'Week', 'Month', 'Year', 'Schedule'], title='Anchor')
@param.int('offset', default=0, min=-500, max=500, title='Offset')
@plot.line('vwap', title='VWAP', color=color.BLUE)
@plot.line('upper', title='Upper band', color=color.GREEN)
@plot.line('lower', title='Lower band', color=color.GREEN)
@plot.fill('upper', 'lower', color=color.GREEN(0.1), title='Background')
class Main(MainContext):
    def __init__(self, src, anchor, offset):
        rule = ScheduleRule(start=time(hour=0), end=time(hour=0)) # 24-hour rule
        self.schedule = Schedule(rules=[rule], timezone='America/New_York')
        self.src = src
        self.anchor = anchor
        self.offset = offset

    def calc(self):
        std_dev_mult = 1.0
        main_line, upper, lower = Vwap.new(self.src, self.anchor, std_dev_mult, self.schedule)
        return (
            plot.Line(main_line[0], offset=self.offset),
            plot.Line(upper[0], offset=self.offset),
            plot.Line(lower[0], offset=self.offset),
            plot.Fill(),
        )

# CIRCLE/CROSS - just markers, LABEL - text callout, NONE - invisible marker
style=plot.marker_style.LABEL,

# to avoid blocking important parts of the graph, the marker can be shifted relative to the value
position=plot.marker_position.ABOVE,

# the size in some relative units is from 1 to 7
size=3,

# a title to display in the UI, like any plot
title='High volume') ```

# text of marker on current bar
text='Vol: ' + str(self.volume[0]),

# if you want to color the markers in runtime, each one has its own color
# color=...,

# time shifting, like any plot
# offset=..., ) ```

## Different types of markers - yet another example of Markers usage

Let's look at another indicator that draws several series of markers of different shapes and colors.

Full code:

```py Different types of markers - yet another example of Markers usage theme={null}
# Copyright (c) 2024 @TakeProfit. All rights reserved.

# This work is licensed under the MIT License.
# For a copy, see <https://opensource.org/licenses/MIT>.

# indie:lang_version = 5
from math import sin, pi, nan
from indie import indicator, plot, color
from indie.plot import MarkerDisplayOptions
from indie.algorithms import Highest, Lowest, Sma

@indicator('Markers', overlay_main_pane=True)
@plot.marker(style=plot.marker_style.CROSS)
@plot.marker(style=plot.marker_style.CIRCLE, color=color.AQUA)
@plot.marker(style=plot.marker_style.LABEL, size=7)
def Main(self):
    highest = Highest.new(self.high, 100)
    lowest = Lowest.new(self.low, 100)
    magnitude = highest[0] - lowest[0]
    sma = Sma.new(self.close, 100)

    r = int(255 * abs(sin(self.bar_index / 10 + 0)))
    g = int(255 * abs(sin(self.bar_index / 10 + 0.5)))
    b = int(255 * abs(sin(self.bar_index / 10 + 2)))
    return (
        plot.Marker(self.close[0] + magnitude * 1.5, color=color.rgba(r, g, b)),
        sin(self.bar_index / 5) * magnitude + sma[0] if self.bar_index % 3 == 0 else nan,
        plot.Marker(self.close[0] + magnitude / 2.0 if self.bar_index % 20 == 0 else nan, text='WOW' + str(self.bar_index % 3 + 1)),
    )

And return their values.

Please note that if you do not need to configure the marker in runtime, you can set all the settings in the decorator and return `float`, the type will be implicitly converted to `plot.Marker`:

```py theme={null}
    return (
        ...,
        sin(self.bar_index / 5) * magnitude + sma[0] if self.bar_index % 3 == 0 else nan,
        ...,
    )

## Plot display options - hide the unnecessary parts from the chart

When the indicator draws many different lines, the chart may become "too noisy". It often happens that you don't need to display all the chart elements on the chart, for example, you need to leave only the line without its numeric value, or vice versa, leave only the number but hide the line. And then the plot display options come to the rescue.

You can configure this via the UI in the indicator settings:

<img alt="Plot display options, UI settings" />

Or you can configure it in the indicator code:

```py Plot display options - hide the unnecessary parts from the chart theme={null}
# Copyright (c) 2024 @TakeProfit. All rights reserved.

# This work is licensed under the MIT License.
# For a copy, see <https://opensource.org/licenses/MIT>.

# indie:lang_version = 5
from indie import indicator, plot, color

@indicator('My Indie 1', overlay_main_pane=True)
@plot.line(color=color.BLUE, display_options=plot.LineDisplayOptions(
    pane=False,
    status_line=False,
    price_label=True,
))
@plot.marker(color=color.GREEN, display_options=plot.MarkerDisplayOptions(
    pane=True,
    status_line=False,
    price_label=False,
))
@plot.steps(color=color.RED, display_options=plot.StepsDisplayOptions(
    pane=False,
    status_line=True,
    price_label=False,
))
def Main(self):
    return self.close[0], self.close[0] + 300.0, self.close[0] + 500.0

Indie compiler cannot infer `T` type for `a` in this example. Yes, it may guess that `a` is of `indie.Optional` type,
but it is unclear how to guess that `T` will be an `int` for it.

This will not work too:

```py theme={null}
a: int = None  # compilation error
# ...
a = 42

Once variable `a` was declared as optional of `int` value, it cannot at some point start to store `str` values.

By the way if you do not assign any value to an optional variable it will be `None` too:

```py theme={null}
a: indie.Optional[int] = None
b: indie.Optional[int]

To access value stored in optional variable `a`, the `value()` method should be explicitly called:

```py theme={null}
if a is not None:
    b = a.value()

But this works fine:

```py theme={null}
s: indie.Optional[str] = 'foobar'
t = s.value()

This form is very compact therefore it is recommended for simple indicators.

When Indie compiler sees a combination of a function definition with name `Main` decorated with `@indicator` it transforms it into a `Main` class definition (i.e. to the second form) according to a few simple rules:

* function definition is replaced with a `Main` class definition which is inherited from `indie.MainContext` base class;
* the body of `Main` function becomes `Main.calc()` method;
* `Main` class may optionally have `__init__` constructor (only if it is needed).

This transformation is automatic and hidden from user, that is why the first form of `Main` entry point is considered to
be a syntactic sugar. In some cases when indicator needs greater control over what is happening in the code the second form of writing the indicator's `Main` entry point with classes syntax can be used explicitly.

### `Main` written as a class definition

Indicator could be written using the second form of a `Main` entry point which uses class definition syntax:

```py theme={null}
# indie:lang_version = 5
from indie import indicator, MainContext

@indicator('Example')
class Main(MainContext):
    def __init__(self):
        pass

    def calc(self):
        return self.close[0]

Will be transformed into a class form:

```py theme={null}
# indie:lang_version = 5
from indie import Algorithm, SeriesF, Context
from indie.algorithms import Ema

class DoubleEma(Algorithm):
    def __init__(self, ctx: Context):
        super().__init__(ctx)

    def calc(self, src: SeriesF, length: int) -> SeriesF:
        ema1 = Ema.new(src, length)
        ema2 = Ema.new(ema1, length)
        return ema2

def calc(self, src: SeriesF, length: int) -> SeriesF:
    ema1 = Ema.new(src, length)
    ema2 = Ema.new(ema1, length)
    return ema2 ```

def calc(self, src: SeriesF, length: int) -> SeriesF:
    ema1 = self._ema1.calc(src, length)
    ema2 = self._ema2.calc(ema1, length)
    return ema2 ```

transforms into:

```py theme={null}
# indie:lang_version = 5
from indie import Algorithm, SeriesF, MutSeriesF, Context

class Hl2(Algorithm):
    def __init__(self, ctx: Context):
        super().__init__(ctx)
        self._ms1 = self.ctx.new_mut_series_f()

    def calc(self) -> SeriesF:
        h = self.ctx.high
        l = self.ctx.low
        return self._ms1.calc((h[0] + l[0]) / 2)

transforms into this:

```py theme={null}
# indie:lang_version = 5
from indie import SecContext

class SecHighLow(SecContext):
    def calc(self):
        return self.high[0], self.low[0]

def calc(self):
    return self._h[0], self._l[0] ```

<Info>`HELPER_FUNCTION_DEFINITIONS`, `DECORATED_HELPER_FUNCTION_DEFINITIONS`, `CLASS_DEFINITIONS` and `MAIN_FUNCTION_OR_CLASS_DEFINITION` can go in any order.</Info>

Syntactically, Indie code is a Python code. But, there are some
[differences](/indie/Language-differences-with-Python) that you may want to be aware about.

## Comment directives

Comment directives are special comments that have some effect on how Indie's compiler and/or runtime works.
At the moment there is only one comment directive which is:

```py theme={null}
# indie:lang_version = 5

Like in Python, there are several different forms of imports:

```py theme={null}
import indie.algorithms  # Then you can use any symbols from this package
                         # with their full name, e.g. `indie.algorithms.Sma`

import indie.algorithms as alg  # Then you can use any symbols from this package
                                # with a short package alias, e.g. `alg.Sma`

from indie.algorithms import Sma  # Then you can use only `Sma` symbol from
                                  # this package (without the package prefix)

from indie.algorithms import Sma as my_sma  # Then you can use the symbol
                                            # with an alias `my_sma`

One note about the aliases. Do not use them if you do not really need them. And you most certainly will need them in two
cases:

* You have a name clash of two symbols from different libraries. Add an alias to one or both of the symbols to
  resolve the clash. For example:

```py theme={null}
from some.library import foobar_func
from another.library import foobar_func

* You import a symbol with a long name, and it is very uncomfortable to use that long name in the code:

```py theme={null}
from some.library import some_useful_function_with_a_very_long_name
# Call the function later as `some_useful_function_with_a_very_long_name()`

## Helper function definitions

Indicator algorithms could be quite complex, so it is a good coding style to extract blocks of code into
helper functions with some meaningful names. The minimal function that accepts no arguments, does nothing
(Python keyword `pass` is about that) and returns nothing (`None`) looks like this:

```py theme={null}
def minimal_helper_func() -> None:
    pass

At the moment, it is mandatory to declare type hints for every argument as well as for the return value of all the
functions (except for the `Main` function and `@sec_context`-decorated functions). Read more about typing in the
[Data types in Indie](/indie/Data-types-in-Indie) chapter.

## Decorated helper function definitions

There are two decorators that can be applied to helper functions: `@algorithm` and `@sec_context`. Both of them are
syntactic sugar decorators which help a lot in making indicator code compact and readable.

The `@algorithm` decorator is a syntactic sugar for making your own
[series processing algorithm](/indie/Algorithms-for-series-processing) like `indie.algorithms.Sma`.

```py theme={null}
@algorithm
def SomeFunc(self) -> SeriesF:
    # Some code...

def calc(self):
    # Some code that uses self._sec_context_res ```

Constructor (the `__init__` method) could be optionally added too. It is very useful because it is a good place for some
initialization code that must be executed only once. For example:

```py theme={null}
# indie:lang_version = 5
from indie import indicator, MainContext, IndieError

@indicator('Example')
class Main(MainContext):
    def __init__(self):
        # This code is executed only once at the creation
        # of the indicator before calculations on candle data
        c: str
        if 'EUR' in self.info.ticker:
            c = 'EUR'
        elif 'JPY' in self.info.ticker:
            c = 'JPY'
        elif 'USD' in self.info.ticker:
            c = 'USD'
        else:
            raise IndieError('This indie cannot be added on ' + self.info.ticker + ' chart')
        self._currency = c

    def calc(self):
        # Calculations on candle data are here
        # TODO: Use `self._currency` somehow here...
        return self.close[0]

Finally, algorithms (instead of using `@algorithm` decorator on a func) can be declared as classes too, for example:

```py theme={null}
# indie:lang_version = 5
from indie import Algorithm, Context, SeriesF, MutSeriesF

class MyAlgorithm(Algorithm):
    def __init__(self, ctx: Context):
        super().__init__(ctx)

    def calc(self, src1: SeriesF, src2: SeriesF) -> SeriesF:
        return MutSeriesF.new(src1[0] + src2[0])

The `Main` entry point of the whole indicator is mandatory. It is called every time the indicator receives a candle data
update and it should return an indicator result for that piece of data. It must have at least one parameter `self` which
is a reference to object of `Main` class (inherited from [`MainContext`](/indie/Library-reference/package-indie#class_MainContext) type).
Function or class `Main` must also be decorated with a [`@indicator`](/indie/Library-reference/package-indie#decor_indicator) decorator. But
also other decorators could be added here, for example:

* Decorator [`@plot.line`](/indie/Library-reference/package-indie-plot#decor_line)
* Decorators [`@plot.fill`, `@level` and `@band`](/indie/Plotting-and-drawing/Fills-levels-and-bands)
* Decorators [`@param.*`](/indie/Input-parameters) for declaring input parameters of an indicator


# null
Source: https://takeprofit.com/docs/indie/Input-parameters

Reference guide for input parameters in Indie indicators. Covers @param decorators, parameter types, and configuration with practical examples.

*Input parameters* provide a convenient way to change indicator's algorithm parameters without the need of changing it's
source code. For example, here is a simple indicator that calculates SMA with two parameters `src` and `length`:

```py theme={null}
# indie:lang_version = 5
from indie import indicator, param, source
from indie.algorithms import Sma

@indicator('Example')
@param.source('src', default=source.CLOSE, title='Source')
@param.int('length', default=12, min=1, title='Length')
def Main(self, src, length):
    sma = Sma.new(src, length)
    return sma[0]

If you need to work with numbers that don't fit into the `int32` range, you can sometimes use `float` instead, which provides 64-bit double precision and can handle much larger values (though with potential precision loss for very large integers).

```py theme={null}
# Indie - using float for large numbers
big_number: float = 10000000000000000.0  # works, but may lose precision for very large integers

Another example:

```py theme={null}
hist_color: Optional[Color] = None  # We have to declare type of `hist_color` here explicitly
                                    # otherwise `hist_color = None` tells compiler nothing about
                                    # the type of `hist_color` variable
if hist[1] < hist[0]:
    hist_color = color.NAVY
else:
    hist_color = color.BLUE

## Scopes of variables

In Python, variables declared in `if`-statements, `for`-loop blocks, and `while`-loop blocks are not local variables,
and stay in scope outside of the block. Indie, on the other hand, has 'block-level' scoping which is very similar to
such languages like C/C++, Java, Go. For example, in Python it's normal to write (but will fail to compile in Indie):

```py theme={null}
def some_func(cond: bool) -> int:
    if cond:
        res = 42
    else:
        res = 0
    return res

## Assignments of `None` values

In Indie it is not allowed to assign `None` value to a variable of any arbitrary type (e.g. basic data types). But it is
allowed to do so with the help of `indie.Optional[T]` class. Read more about this
[here](/indie/Data-types-in-Indie#indie-optional%5Bt%5D-class).

## Syntactic sugar constructs

There are a few language constructs in Indie, which behave weird from the point of view of a standard Python. They are
nothing more but a syntactic sugar for somewhat complicated things thus they make writing technical analysis indicators
simpler. They are:

* `Main` function which transforms into a `Main` class inherited from `indie.MainContext`.
* Functions decorated with `@algorithm` (more info [here](/indie/Algorithms-for-series-processing)) which transform into classes inherited from `indie.Algorithm`.
* `Algorithm.new()` static method (e.g. `indie.algorithms.Sma.new()`).
* `MutSeries[T].new()` static method.
* Functions decorated with `@sec_context` decorator which transform into classes (similar to `Main`) inherited from `indie.SecContext`.

More information about this in [How Indie's syntactic sugar works](/indie/How-Indies-syntactic-sugar-works) section

## Libraries to import from

You may think, 'Indie is a Python-like language... so... I will import numpy, pandas, yfinance, matplotlib,
talib and a lot more cool and very helpful stuff into my TakeProfit indicators right now and have some fun!'
but... unfortunately you cannot do this. Well, at least right now.

There are number of reasons why. Here are some of them:

* Those libraries are not compatible with Indie's runtime design and internal data types.
* Many of those libraries run on CPython, we in TakeProfit cannot use it effectively as our backend runtime.
  We are looking forward to WebAssembly/machine code to reach higher performance. We simply cannot run these
  libraries' code on those.
* There are a lot of stuff in those libraries which is not allowed to run on our servers due to our
  'sandbox'-related policies.
* We in TakeProfit are too busy to work on integration of our runtime engine with those libraries at the moment,
  because there are a lot of stuff yet to do to make Indie a great tool for technical analysis.

So, in other words, the fact that Indie is a Python-like language gives it an additional point of growth here. But
this is a very complicated task, and it is hard to give any promises/estimates right now about it.

Now, what you can import into Indie right now, is:

* Core stuff from the [standard library](/indie/Library-reference/package-indie) package `indie`,
  like `indicator`, `algorithm`, `sec_context`, `Series[T]`, etc.
* Classic tech analysis algorithms from the [standard library](/indie/Library-reference/package-indie-algorithms) package `indie.algorithms`,
  like `Sma`, `Ema`, `Highest`, `Lowest`, etc.
* Some bits and pieces of the Python standard core libraries:
  * `math.pow`
  * `math.sqrt`
  * `math.nan`
  * `math.isnan`
  * `statistics.mean`
  * `statistics.fmean`
  * `statistics.median`

The list of items to be imported will definitely be expanded... Please, be patient.

## Python built-ins

Standard Python has many built-ins. Indie has only these:
`None`, `NoneType`, `False`, `True`, `abs()`, `bool()`, `dict()`, `float()`, `int()`, `len()`, `list()`,
`min()`, `max()`, `range()`, `round()`, `str()`, `sum()`, `tuple()`.

## Indie code runs in a sandbox

We run Indie code on our servers, that is why for the obvious reasons Indie's runtime is sandboxed.
It means that it is very restricted in terms of what is allowed to do with the host system where code is being executed.
For example file and socket I/O is not allowed, execution time and memory are limited too.


# Overview
Source: https://takeprofit.com/docs/indie/Library-reference-overview



Indie includes several core packages that provide functions for data processing, scheduling, and plotting.
Most of Indie's functionality is located in the `indie` and `indie.*` packages, while others, like `math`,
contain features adapted from Python's standard libraries.

<CardGroup>
  <Card title="indie" icon="hand-horns" href="/indie/Library-reference/package-indie">
    The main package of Indie, containing essential components.
  </Card>

  <Card title="indie.algorithms" icon="waveform" href="/indie/Library-reference/package-indie-algorithms">
    A collection of built-in algorithms for technical analysis.
  </Card>

  <Card title="indie.plot" icon="chart-line" href="/indie/Library-reference/package-indie-plot">
    Tools for plotting series-based data on charts.
  </Card>

  <Card title="indie.drawings" icon="comment-text" href="/indie/Library-reference/package-indie-drawings">
    Classes for creating manual or coordinate-based visual elements on charts.
  </Card>

  <Card title="indie.color" icon="palette" href="/indie/Library-reference/package-indie-color">
    Built-in colors and the `rgba` function.
  </Card>

  <Card title="indie.math" icon="calculator-simple" href="/indie/Library-reference/package-indie-math">
    Utility functions for simple calculations.
  </Card>

  <Card title="indie.schedule" icon="clock" href="/indie/Library-reference/package-indie-schedule">
    Classes for defining and handling trading schedules.
  </Card>

  <Card title="datetime" icon="calendar" href="/indie/Library-reference/package-datetime">
    Tools for working with dates and times.
  </Card>

  <Card title="statistics" icon="magnifying-glass-chart" href="/indie/Library-reference/package-statistics">
    Statistical functions and calculations.
  </Card>

  <Card title="sortedcontainers" icon="arrow-down-a-z" href="/indie/Library-reference/package-sortedcontainers">
    Fast and efficient sorted collections.
  </Card>

  <Card title="math" icon="square-root-variable" href="/indie/Library-reference/package-math">
    Standard mathematical functions.
  </Card>

  <Card title="<builtins>" icon="cube" href="/indie/Library-reference/builtins">
    Built-in types, constants, and functions of Indie.
  </Card>
</CardGroup>


# Builtins
Source: https://takeprofit.com/docs/indie/Library-reference/builtins

Language reference for Indie built-in functions and types. Comprehensive documentation of supported operations, type system, and standard methods.

Built-in symbols of Indie language.

***

## Variables

<Steps>
  <Step title="Constants" icon="pi">
    <Field name="False" type="bool">
      Built-in Indie object (similar to Python's).
    </Field>

    <Field name="None" type="NoneType">
      Built-in Indie object (similar to Python's).
    </Field>

    <Field name="True" type="bool">
      Built-in Indie object (similar to Python's).
    </Field>
  </Step>
</Steps>

***

## Functions

<Anchor />

### `abs()`

*function*

<Steps>
  <Step title="Overloads" icon="pencil">
    <Field name="abs" type="(x) -> int">
      Returns the absolute value of a number. It is a built-in Indie function (similar to Python's).

      <Expandable title="parameters info">
        <Field name="x" type="int">
          Number on which the function will be calculated.
        </Field>
      </Expandable>
    </Field>

    <Field name="abs" type="(x) -> float">
      Returns the absolute value of a number. It is a built-in Indie function (similar to Python's).

      <Expandable title="parameters info">
        <Field name="x" type="float">
          Number on which the function will be calculated.
        </Field>
      </Expandable>
    </Field>
  </Step>
</Steps>

***

<Anchor />

### `enumerate()`

*function*

<Steps>
  <Step title="Overloads" icon="pencil">
    <Field name="enumerate" type="(iterable, start) -> enumerate_t[T]">
      Returns an enumerate object. Can be used with any iterable object (like lists or ranges).

      <Expandable title="parameters info">
        <Field name="iterable" type="iterable[T]">
          An iterable to enumerate.
        </Field>

        <Field name="start" type="int">
          The start index.
        </Field>
      </Expandable>
    </Field>
  </Step>
</Steps>

***

<Anchor />

### `len()`

*function*

<Steps>
  <Step title="Overloads" icon="pencil">
    <Field name="len" type="(x) -> int">
      Returns the length (the number of items) of an object. It is a built-in Indie function (similar to Python's).

      <Expandable title="parameters info">
        <Field name="x" type="typing.Any">
          Value on which the function will be calculated.
        </Field>
      </Expandable>
    </Field>
  </Step>
</Steps>

***

<Anchor />

### `max()`

*function*

<Steps>
  <Step title="Overloads" icon="pencil">
    <Field name="max" type="(x, y) -> int">
      Returns the largest of two or more arguments. It is a built-in Indie function (similar to Python's).

      <Expandable title="parameters info">
        <Field name="x" type="int">
          First number to calculate the function.
        </Field>

        <Field name="y" type="int">
          Second number to calculate the function.
        </Field>
      </Expandable>
    </Field>

    <Field name="max" type="(x, y, z) -> int">
      Returns the largest of two or more arguments. It is a built-in Indie function (similar to Python's).

      <Expandable title="parameters info">
        <Field name="x" type="int">
          First number to calculate the function.
        </Field>

        <Field name="y" type="int">
          Second number to calculate the function.
        </Field>

        <Field name="z" type="int">
          Third number to calculate the function.
        </Field>
      </Expandable>
    </Field>

    <Field name="max" type="(x, y) -> float">
      Returns the largest of two or more arguments. It is a built-in Indie function (similar to Python's).

      <Expandable title="parameters info">
        <Field name="x" type="float">
          First number to calculate the function.
        </Field>

        <Field name="y" type="float">
          Second number to calculate the function.
        </Field>
      </Expandable>
    </Field>

    <Field name="max" type="(x, y, z) -> float">
      Returns the largest of two or more arguments. It is a built-in Indie function (similar to Python's).

      <Expandable title="parameters info">
        <Field name="x" type="float">
          First number to calculate the function.
        </Field>

        <Field name="y" type="float">
          Second number to calculate the function.
        </Field>

        <Field name="z" type="float">
          Third number to calculate the function.
        </Field>
      </Expandable>
    </Field>

    <Field name="max" type="(l) -> int">
      Returns the largest of two or more arguments. It is a built-in Indie function (similar to Python's).

      <Expandable title="parameters info">
        <Field name="l" type="list[int]">
          List on which the function will be calculated.
        </Field>
      </Expandable>
    </Field>

    <Field name="max" type="(l) -> float">
      Returns the largest of two or more arguments. It is a built-in Indie function (similar to Python's).

      <Expandable title="parameters info">
        <Field name="l" type="list[float]">
          List on which the function will be calculated.
        </Field>
      </Expandable>
    </Field>
  </Step>
</Steps>

***

<Anchor />

### `min()`

*function*

<Steps>
  <Step title="Overloads" icon="pencil">
    <Field name="min" type="(x, y) -> int">
      Returns the smallest of two or more arguments. It is a built-in Indie function (similar to Python's).

      <Expandable title="parameters info">
        <Field name="x" type="int">
          First number to calculate the function.
        </Field>

        <Field name="y" type="int">
          Second number to calculate the function.
        </Field>
      </Expandable>
    </Field>

    <Field name="min" type="(x, y, z) -> int">
      Returns the smallest of two or more arguments. It is a built-in Indie function (similar to Python's).

      <Expandable title="parameters info">
        <Field name="x" type="int">
          First number to calculate the function.
        </Field>

        <Field name="y" type="int">
          Second number to calculate the function.
        </Field>

        <Field name="z" type="int">
          Third number to calculate the function.
        </Field>
      </Expandable>
    </Field>

    <Field name="min" type="(x, y) -> float">
      Returns the smallest of two or more arguments. It is a built-in Indie function (similar to Python's).

      <Expandable title="parameters info">
        <Field name="x" type="float">
          First number to calculate the function.
        </Field>

        <Field name="y" type="float">
          Second number to calculate the function.
        </Field>
      </Expandable>
    </Field>

    <Field name="min" type="(x, y, z) -> float">
      Returns the smallest of two or more arguments. It is a built-in Indie function (similar to Python's).

      <Expandable title="parameters info">
        <Field name="x" type="float">
          First number to calculate the function.
        </Field>

        <Field name="y" type="float">
          Second number to calculate the function.
        </Field>

        <Field name="z" type="float">
          Third number to calculate the function.
        </Field>
      </Expandable>
    </Field>

    <Field name="min" type="(l) -> int">
      Returns the smallest of two or more arguments. It is a built-in Indie function (similar to Python's).

      <Expandable title="parameters info">
        <Field name="l" type="list[int]">
          List on which the function will be calculated.
        </Field>
      </Expandable>
    </Field>

    <Field name="min" type="(l) -> float">
      Returns the smallest of two or more arguments. It is a built-in Indie function (similar to Python's).

      <Expandable title="parameters info">
        <Field name="l" type="list[float]">
          List on which the function will be calculated.
        </Field>
      </Expandable>
    </Field>
  </Step>
</Steps>

***

<Anchor />

### `round()`

*function*

<Steps>
  <Step title="Overloads" icon="pencil">
    <Field name="round" type="(number) -> int">
      Returns number rounded to ndigits precision after the decimal point. If ndigits is omitted or is None, it returns the nearest integer to its input. It is a built-in Indie function (similar to Python's).

      <Expandable title="parameters info">
        <Field name="number" type="float">
          Number on which the function will be calculated.
        </Field>
      </Expandable>
    </Field>

    <Field name="round" type="(number, ndigits) -> float">
      Returns number rounded to ndigits precision after the decimal point. If ndigits is omitted or is None, it returns the nearest integer to its input. It is a built-in Indie function (similar to Python's).

      <Expandable title="parameters info">
        <Field name="number" type="float">
          Number on which the function will be calculated.
        </Field>

        <Field name="ndigits" type="indie.Optional[int]">
          Rounding precision.
        </Field>
      </Expandable>
    </Field>
  </Step>
</Steps>

***

<Anchor />

### `sum()`

*function*

<Steps>
  <Step title="Overloads" icon="pencil">
    <Field name="sum" type="(l, start) -> int">
      Sums start and the items of a list from left to right and returns the total. It is a built-in Indie function (similar to Python's).

      <Expandable title="parameters info">
        <Field name="l" type="list[int]">
          List on which the function will be calculated.
        </Field>

        <Field name="start" type="int">
          Initial value to calculate sum of the list.
        </Field>
      </Expandable>
    </Field>

    <Field name="sum" type="(l, start) -> float">
      Sums start and the items of a list from left to right and returns the total. It is a built-in Indie function (similar to Python's).

      <Expandable title="parameters info">
        <Field name="l" type="list[float]">
          List on which the function will be calculated.
        </Field>

        <Field name="start" type="float">
          Initial value to calculate sum of the list.
        </Field>
      </Expandable>
    </Field>
  </Step>
</Steps>

***

## Types

<Anchor />

### `bool`

*type*

Built-in Indie type (similar to Python's).

<Steps>
  <Step title="Methods" icon="function">
    <Field name="__init__" type="(x) -> None">
      Cast constructor for built-in Indie type. Returns a `bool` value, i.e. one of `True` or `False`. The argument is converted using the standard [Python's truth testing procedure](https://docs.python.org/3/library/stdtypes.html#truth).

      <Expandable title="parameters info">
        <Field name="x" type="bool">
          Value to cast from.
        </Field>
      </Expandable>
    </Field>

    <Field name="__init__" type="(x) -> None">
      Cast constructor for built-in Indie type. Returns a `bool` value, i.e. one of `True` or `False`. The argument is converted using the standard [Python's truth testing procedure](https://docs.python.org/3/library/stdtypes.html#truth).

      <Expandable title="parameters info">
        <Field name="x" type="int">
          Value to cast from.
        </Field>
      </Expandable>
    </Field>

    <Field name="__init__" type="(x) -> None">
      Cast constructor for built-in Indie type. Returns a `bool` value, i.e. one of `True` or `False`. The argument is converted using the standard [Python's truth testing procedure](https://docs.python.org/3/library/stdtypes.html#truth).

      <Expandable title="parameters info">
        <Field name="x" type="float">
          Value to cast from.
        </Field>
      </Expandable>
    </Field>

    <Field name="__init__" type="(x) -> None">
      Cast constructor for built-in Indie type. Returns a `bool` value, i.e. one of `True` or `False`. The argument is converted using the standard [Python's truth testing procedure](https://docs.python.org/3/library/stdtypes.html#truth).

      <Expandable title="parameters info">
        <Field name="x" type="str">
          Value to cast from.
        </Field>
      </Expandable>
    </Field>

    <Field name="__init__" type="(x) -> None">
      Cast constructor for built-in Indie type. Returns a `bool` value, i.e. one of `True` or `False`. The argument is converted using the standard [Python's truth testing procedure](https://docs.python.org/3/library/stdtypes.html#truth).

      <Expandable title="parameters info">
        <Field name="x" type="NoneType">
          Value to cast from.
        </Field>
      </Expandable>
    </Field>
  </Step>
</Steps>

***

<Anchor />

### `dict[K, V]`

*type*

Built-in Indie type (similar to Python's).

***

<Anchor />

### `float`

*type*

Built-in Indie type (similar to Python's).

<Steps>
  <Step title="Methods" icon="function">
    <Field name="__init__" type="(x) -> None">
      Cast constructor for built-in Indie type. Returns a `float` number constructed from a number or a string.

      <Expandable title="parameters info">
        <Field name="x" type="float">
          Value to cast from.
        </Field>
      </Expandable>
    </Field>

    <Field name="__init__" type="(x) -> None">
      Cast constructor for built-in Indie type. Returns a `float` number constructed from a number or a string.

      <Expandable title="parameters info">
        <Field name="x" type="int">
          Value to cast from.
        </Field>
      </Expandable>
    </Field>

    <Field name="__init__" type="(x) -> None">
      Cast constructor for built-in Indie type. Returns a `float` number constructed from a number or a string.

      <Expandable title="parameters info">
        <Field name="x" type="str">
          Value to cast from.
        </Field>
      </Expandable>
    </Field>

    <Field name="__init__" type="(x) -> None">
      Cast constructor for built-in Indie type. Returns a `float` number constructed from a number or a string.

      <Expandable title="parameters info">
        <Field name="x" type="bool">
          Value to cast from.
        </Field>
      </Expandable>
    </Field>
  </Step>
</Steps>

***

<Anchor />

### `int`

*type*

Built-in Indie type (similar to Python's).

<Steps>
  <Step title="Methods" icon="function">
    <Field name="__init__" type="(x) -> None">
      Cast constructor for built-in Indie type. Returns an `int` object constructed from a number or a string, or return 0 if no arguments are given.

      <Expandable title="parameters info">
        <Field name="x" type="int">
          Value to cast from.
        </Field>
      </Expandable>
    </Field>

    <Field name="__init__" type="(x) -> None">
      Cast constructor for built-in Indie type. Returns an `int` object constructed from a number or a string, or return 0 if no arguments are given.

      <Expandable title="parameters info">
        <Field name="x" type="float">
          Value to cast from.
        </Field>
      </Expandable>
    </Field>

    <Field name="__init__" type="(x) -> None">
      Cast constructor for built-in Indie type. Returns an `int` object constructed from a number or a string, or return 0 if no arguments are given.

      <Expandable title="parameters info">
        <Field name="x" type="str">
          Value to cast from.
        </Field>
      </Expandable>
    </Field>

    <Field name="__init__" type="(x) -> None">
      Cast constructor for built-in Indie type. Returns an `int` object constructed from a number or a string, or return 0 if no arguments are given.

      <Expandable title="parameters info">
        <Field name="x" type="bool">
          Value to cast from.
        </Field>
      </Expandable>
    </Field>
  </Step>
</Steps>

***

<Anchor />

### `list[T]`

*type*

Built-in Indie type (similar to Python's).

<Steps>
  <Step title="Methods" icon="function">
    <Field name="append" type="(x) -> None">
      Appends given param to the end of the list.

      <Expandable title="parameters info">
        <Field name="x" type="T">
          New value that will be put to the list.
        </Field>
      </Expandable>
    </Field>

    <Field name="__getitem__" type="(i) -> T">
      Returns list element at given index.

      <Expandable title="parameters info">
        <Field name="i" type="int">
          Index of an element in the list.
        </Field>
      </Expandable>

      ```py Example theme={null}
      nums = [40, 41, 42, 43]
      meaning_of_life = nums[2]  # returns 42 (this implicitly calls `nums.__getitem__(2)`)
      ```

      <Note>Method `__getitem__` should never be called directly, instead `list_obj[key]` syntax should be used.</Note>
    </Field>

    <Field name="__setitem__" type="(i, x) -> None">
      Assigns value to some\_list\[key].

      <Expandable title="parameters info">
        <Field name="i" type="int">
          Index of an element in the list.
        </Field>

        <Field name="x" type="T">
          New value that will be put to the list.
        </Field>
      </Expandable>

      ```py Example theme={null}
      nums = [40, 41, 42, 43]
      nums[2] = 100500  # this implicitly calls `nums.__setitem__(2, 100500)`
                        # and now `nums` are [40, 41, 100500, 43]
      ```

      <Note>Method `__setitem__` should never be called directly, instead `list_obj[key] = value` syntax should be used.</Note>
    </Field>

    <Field name="__delitem__" type="(i) -> None">
      Delete an item from the list at the given index.

      <Expandable title="parameters info">
        <Field name="i" type="int">
          Index of an element in the list.
        </Field>
      </Expandable>

      ```py Example theme={null}
      nums = [40, 41, 42, 43]
      del nums[2]  # this implicitly calls `nums.__delitem__(2)`
      ```

      <Note>Method `__delitem__` should never be called directly, instead `del list_obj[key]` syntax should be used.</Note>
    </Field>

    <Field name="__delslice__" type="(start, stop, step) -> None">
      Delete a slice from the list.

      <Expandable title="parameters info">
        <Field name="start" type="indie.Optional[int]">
          Starting index for slice. Can be omitted. See more examples below.
        </Field>

        <Field name="stop" type="indie.Optional[int]">
          Ending index for slice (not included). Can be omitted. See more examples below.
        </Field>

        <Field name="step" type="int">
          Step between indexes of slice. Can be omitted. See more examples below.
        </Field>
      </Expandable>

      ```py Example theme={null}
      nums = [40, 41, 42, 43]
      del nums[0:2]  # this implicitly calls `nums.__delslice__(0, 2, 1)`
      ```

      <Note>Method `__delslice__` should never be called directly, instead `del list_obj[slice]` syntax should be used.</Note>
    </Field>

    <Field name="__len__" type="() -> int">
      Returns the length (the number of items) of a list\[T].

      ```py Example theme={null}
      nums = [40, 41, 42, 43]
      len(nums)  # returns 4 (this implicitly calls `nums.__len__()`)
      ```

      <Note>Method `__len__` should never be called directly, instead `len(list_obj)` syntax should be used.</Note>
    </Field>

    <Field name="__bool__" type="() -> bool">
      Returns `True` if the list is not empty.
    </Field>

    <Field name="__contains__" type="(x) -> bool">
      Returns `True` if the list contains the given value, otherwise `False`.

      <Expandable title="parameters info">
        <Field name="x" type="T">
          Element to find in the list.
        </Field>
      </Expandable>

      ```py Example theme={null}
      nums = [40, 41, 42, 43]
      my_bool = 41 in nums  # this implicitly calls `nums.__contains__(41)`
      ```

      <Note>Method `__contains__` should never be called directly, instead `val in lst` syntax should be used.</Note>
    </Field>

    <Field name="remove" type="(x) -> None">
      Removes the first item from list `s` where `s[i]` is equal to given param.

      <Expandable title="parameters info">
        <Field name="x" type="T">
          Value that will be removed from the list
        </Field>
      </Expandable>

      ```py Example theme={null}
      nums = [40, 41, 42, 40, 41, 42]
      nums.remove(42)  # now `nums` are [40, 41, 40, 41, 42]
      ```
    </Field>

    <Field name="pop" type="(i) -> T">
      Retrieves the item at given index and also removes it from the list.

      <Expandable title="parameters info">
        <Field name="i" type="int">
          Index of an element in the list.
        </Field>
      </Expandable>

      ```py Example theme={null}
      nums = [40, 41, 42, 43]
      meaning_of_life = nums.pop(2)  # now `nums` are [40, 41, 43], `meaning_of_life` is 42
      ```
    </Field>

    <Field name="insert" type="(i, x) -> None">
      Insert a value at the specified index.

      <Expandable title="parameters info">
        <Field name="i" type="int">
          Index of an element in the list.
        </Field>

        <Field name="x" type="T">
          New value that will be put to the list.
        </Field>
      </Expandable>

      ```py Example theme={null}
      nums = [40, 41, 42, 43]
      nums.insert(2, 50)  # now `nums` are [40, 41, 50, 42, 43]
      ```
    </Field>

    <Field name="clear" type="() -> None">
      Remove all items from the list.

      ```py Example theme={null}
      nums = [40, 41, 42, 43]
      nums.clear()  # now `nums` is []
      ```
    </Field>

    <Field name="reverse" type="() -> None">
      Reverses the elements of the list in place.
    </Field>

    <Field name="index" type="(x) -> int">
      Returns index of the first occurrence of the item in the list. If not found returns `-1`.

      <Expandable title="parameters info">
        <Field name="x" type="T">
          Element to find in the list.
        </Field>
      </Expandable>
    </Field>

    <Field name="__getslice__" type="(start, stop, step) -> list[T]">
      Returns a slice of the list elements.

      <Expandable title="parameters info">
        <Field name="start" type="indie.Optional[int]">
          Starting index for slice. Can be omitted. See more examples below.
        </Field>

        <Field name="stop" type="indie.Optional[int]">
          Ending index for slice (not included). Can be omitted. See more examples below.
        </Field>

        <Field name="step" type="int">
          Step between indexes of slice. Can be omitted. See more examples below.
        </Field>
      </Expandable>

      ```py Example theme={null}
      nums = [40, 41, 42, 43]
      meaning_of_life = nums[1:3]  # returns [41, 42] (this implicitly calls `nums.__getslice__(1, 3, 1)`)
      ```

      <Note>Method `__getslice__` should never be called directly, instead `list_obj[slice]` syntax should be used.</Note>
    </Field>

    <Field name="__setslice__" type="(start, stop, step, new_list) -> None">
      Assigns given list to some\_list\[slice].

      <Expandable title="parameters info">
        <Field name="start" type="indie.Optional[int]">
          Starting index for slice. Can be omitted. See more examples below.
        </Field>

        <Field name="stop" type="indie.Optional[int]">
          Ending index for slice (not included). Can be omitted. See more examples below.
        </Field>

        <Field name="step" type="int">
          Step between indexes of slice. Can be omitted. See more examples below.
        </Field>

        <Field name="new_list" type="list[T]">
          List to get values from.
        </Field>
      </Expandable>

      ```py Example theme={null}
      nums = [40, 41, 42, 43]
      nums[1:3] = [50, 51, 52]  # this implicitly calls `nums.__setslice__(1, 3, 1, [50, 51, 52])`
                                # and now `nums` are [40, 50, 51, 52, 43]
      ```

      <Note>Method `__setslice__` should never be called directly, instead `list_obj[slice] = other_list` syntax should be used.</Note>
    </Field>

    <Field name="copy" type="() -> list[T]">
      Returns a copy of the list.
    </Field>

    <Field name="extend" type="(l) -> None">
      Extends the list by appending elements from the given list.

      <Expandable title="parameters info">
        <Field name="l" type="list[T]">
          List to concatenate with the current.
        </Field>
      </Expandable>
    </Field>

    <Field name="__add__" type="(l) -> list[T]">
      Returns a concatenation of two lists.

      <Expandable title="parameters info">
        <Field name="l" type="list[T]">
          List to concatenate with the current.
        </Field>
      </Expandable>

      ```py Example theme={null}
      nums1 = [40, 41]
      nums2 = [42, 43]
      nums3 = nums1 + nums2  # this implicitly calls `nums1.__add__(nums2)`
      ```

      <Note>Method `__add__` should never be called directly, instead `list1 + list2` syntax should be used.</Note>
    </Field>

    <Field name="__mul__" type="(n) -> list[T]">
      Returns a concatenation of the list with `n` its copies.

      <Expandable title="parameters info">
        <Field name="n" type="int">
          How many copies of the list to concatenate.
        </Field>
      </Expandable>

      ```py Example theme={null}
      nums1 = [40, 41]
      nums2 = nums1 * 3  # this implicitly calls `nums1.__mul__(3)`
                         # and now `nums2` is [40, 41, 40, 41, 40, 41]
      ```

      <Note>Method `__mul__` should never be called directly, instead `lst * n` syntax should be used.</Note>
    </Field>
  </Step>
</Steps>

```py Example theme={null}
# examples of list creation:
a = [1, 2, 3]  # `a` has type `list[int]`
b = [1, 2, 3, 4.2]  # `b` has type `list[float]`
c = ["a", "b", "c"]  # `c` has type `list[str]`
d = [(1, "a"), (2, "b"), (3, "c")]  # `d` has type `list[tuple[int, str]]`

e = [0, 1, 2, 3, 4, 5, 6, 7]
f = e[2:5]  # `f` is `[2, 3, 4]`
g = e[:5]  # `g` is `[0, 1, 2, 3, 4]`
h = e[2:]  # `h` is `[2, 3, 4, 5, 6, 7]`
i = e[:]  # `i` is a copy of `e`
j = e[1:7:2]  # `j` is `[1, 3, 5]`
k = e[5:2:-1]  # `k` is `[5, 4, 3]`
l = e[5::-1]  # `l` is `[5, 4, 3, 2, 1, 0]`
m = e[::-1]  # `m` is `[7, 6, 5, 4, 3, 2, 1, 0]`