> ## Documentation Index
> Fetch the complete documentation index at: https://docs.innova-trading.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Bar Indexing

> Dos paradigmas de conteo de barras — array vs shift — y por qué importa entenderlos

Toda formula tecnica usa `bar[i]`. Si contas mal, detectas mal. Hay dos paradigmas de numeracion completamente opuestos y si no sabes cual usa tu plataforma, tus indicadores van a dar resultados incorrectos.

## Por Que Importa

Imaginate que escribis un detector de Swing High. La logica es simple: una barra cuyo high es mayor que el de sus vecinas. Pero **"la barra anterior"** significa cosas opuestas segun el paradigma:

* En Python, `bars[i-1]` es una barra **mas vieja** (mas a la izquierda)
* En MQL5, `iHigh(sym, tf, i-1)` es una barra **mas reciente** (mas a la derecha)

Si no sabes cual usa tu plataforma, tus patrones se detectan al reves.

## Paradigma Array (0 = mas antigua)

Es el que usan **Python, JavaScript, APIs REST** y la mayoria de lenguajes de programacion.

* `bars[0]` = la barra mas antigua (primera en el array)
* `bars[N-1]` = la barra mas reciente (ultima en el array)
* Loop: se recorre **forward** (de izquierda a derecha)

<iframe src="https://mrblacksheep91.github.io/innova-trading-docs/charts/diagrams.html?d=bar-indexing-array" style={{width: '100%', height: '220px', border: 'none', borderRadius: '8px'}} />

<Tabs>
  <Tab title="Python">
    ```python theme={null}
    # Python — Array indexing
    bars = get_bars("EURUSD", timeframe=60, limit=100)
    oldest = bars[0]       # Primera barra
    newest = bars[-1]      # Ultima barra (mas reciente)
    previous = bars[-2]    # Penultima

    # Swing High detection (array)
    for i in range(1, len(bars) - 1):
        if bars[i].high > bars[i-1].high and bars[i].high > bars[i+1].high:
            print(f"Swing High en index {i}")
    ```
  </Tab>

  <Tab title="JavaScript">
    ```javascript theme={null}
    // JavaScript — Array indexing
    const bars = await getBars("EURUSD", { timeframe: 60, limit: 100 });
    const oldest = bars[0];              // Primera barra
    const newest = bars[bars.length - 1]; // Ultima barra

    // Swing High detection (array)
    for (let i = 1; i < bars.length - 1; i++) {
      if (bars[i].high > bars[i-1].high && bars[i].high > bars[i+1].high) {
        console.log(`Swing High en index ${i}`);
      }
    }
    ```
  </Tab>
</Tabs>

## Paradigma Shift (0 = barra actual)

Es el que usan **MetaTrader 4/5 (MQL)** y algunas plataformas legacy.

* `iHigh(sym, tf, 0)` = barra actual (mas reciente)
* `iHigh(sym, tf, 1)` = barra anterior
* `iHigh(sym, tf, N)` = N barras atras
* Loop: se recorre **backward** (de derecha a izquierda)

<iframe src="https://mrblacksheep91.github.io/innova-trading-docs/charts/diagrams.html?d=bar-indexing-shift" style={{width: '100%', height: '220px', border: 'none', borderRadius: '8px'}} />

```mql5 theme={null}
// MQL5 — Shift indexing
double currentHigh = iHigh(_Symbol, PERIOD_H1, 0);  // Ahora
double previousHigh = iHigh(_Symbol, PERIOD_H1, 1);  // Hace 1 barra
double oldHigh = iHigh(_Symbol, PERIOD_H1, 99);      // Hace 99 barras

// Swing High detection (shift)
for (int i = 1; i < 100; i++) {
    if (iHigh(_Symbol, tf, i) > iHigh(_Symbol, tf, i+1)
        && iHigh(_Symbol, tf, i) > iHigh(_Symbol, tf, i-1))
        Print("Swing High en shift ", i);
}
```

## Comparacion Side-by-Side

| Concepto | Array (0=oldest) | Shift (0=current) |
| - | - | - |
| **Barra actual** | `bars[N-1]` o `bars[-1]` | `bars[0]` |
| **Barra anterior** | `bars[N-2]` o `bars[-2]` | `bars[1]` |
| **Barra mas vieja** | `bars[0]` | `bars[N-1]` |
| **"La siguiente" (hacia futuro)** | `bars[i+1]` (i+1 es mas reciente) | `bars[i-1]` (i-1 es mas reciente) |
| **"La anterior" (hacia pasado)** | `bars[i-1]` (i-1 es mas vieja) | `bars[i+1]` (i+1 es mas vieja) |
| **Loop natural** | `for i in range(len(bars))` | `for(int i=bars-1; i>=0; i--)` |
| **Plataformas** | Python, JS, Innova API, TradingView | MT4, MT5, cTrader |

<Warning>
  El mayor error al portar codigo entre plataformas es olvidar invertir la direccion del index. Un indicador de Python portado a MQL5 sin ajustar el indexing va a detectar los patrones al reves.
</Warning>

## Formula de Conversion

La conversion entre ambos paradigmas es simetrica:

```
shift = (total_bars - 1) - array_index
array_index = (total_bars - 1) - shift
```

<AccordionGroup>
  <Accordion title="Ejemplo con 100 barras">
    | Array Index | Shift | Descripcion |
    | - | - | - |
    | `0` | `99` | Barra mas antigua |
    | `1` | `98` | Segunda mas antigua |
    | `49` | `50` | Cerca del medio |
    | `98` | `1` | Penultima (anterior) |
    | `99` | `0` | Barra mas reciente / actual |
  </Accordion>

  <Accordion title="Funcion de conversion en Python">
    ```python theme={null}
    def array_to_shift(array_index: int, total_bars: int) -> int:
        return (total_bars - 1) - array_index

    def shift_to_array(shift: int, total_bars: int) -> int:
        return (total_bars - 1) - shift

    # Ejemplo
    total = 100
    print(array_to_shift(0, total))   # 99 — la mas vieja
    print(array_to_shift(99, total))  # 0  — la actual
    print(shift_to_array(0, total))   # 99 — la actual en array
    ```
  </Accordion>
</AccordionGroup>

## Convencion Innova Trading

<Info>
  En Innova Trading usamos **array indexing (0 = mas antigua)** en toda la plataforma. La API `/api/bars/ohlcv` retorna barras ordenadas cronologicamente: `bars[0]` es la mas vieja, `bars[-1]` es la mas reciente. Los indicadores ISS, el backtester y el Trading Bridge MCP siguen esta misma convencion.
</Info>

***

<Card title="Siguiente: Swing Points" icon="arrow-right" href="/learn/fundamentals/swing-points">
  Ahora que sabes como se numeran las barras, aprende a detectar los puntos de giro del precio.
</Card>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.