Indicador Parabolic SAR: fórmula, ajustes y cómo leerlo

Parabolic SAR — Medias y volatilidad, sobre el gráfico de precios.

Qué mide Parabolic SAR

En cada barra el punto avanza desde su posición anterior según el factor de aceleración por la distancia al punto extremo, que es el máximo más alto de la tendencia alcista en curso o el mínimo más bajo de la bajista. Dos reglas dan a la implementación su comportamiento exacto. El punto se acota para que nunca pueda situarse dentro del rango de las dos barras precedentes, lo que evita un giro provocado por la colocación del propio indicador. Y el factor de aceleración sube únicamente cuando se marca un punto extremo nuevo: una barra que no extiende la tendencia deja el factor donde está, un detalle que a menudo se implementa mal. En un giro, el punto extremo antiguo pasa a ser el punto nuevo, el extremo se reinicia al mínimo o al máximo de la barra actual y el factor vuelve a su valor inicial.

La fórmula, tal como está implementada

No es la definición habitual en otros sitios: es lo que calcula el código que se distribuye, documentado junto a su implementación:

Sortie `bands` avec TROU SYNCHRONISÉ : une seule des trois lignes indéfinie ⇒ les trois valent null à cette barre. Une bande à moitié définie (basis sans bord, bord sans basis) n'a aucun sens à l'écran et laisserait le renderer inventer un remplissage. */ function bandsOut( bars: readonly FootprintBar[], upperVals: ReadonlyArray<number | null>, basisVals: ReadonlyArray<number | null>, lowerVals: ReadonlyArray<number | null>, color: string, fillAlpha: number, ): SeriesOutput { const upper: SeriesPoint[] = []; const basis: SeriesPoint[] = []; const lower: SeriesPoint[] = []; for (let i = 0; i < bars.length; i++) { const t = bars[i].bucketTsNs; const u = upperVals[i] ?? null; const m = basisVals[i] ?? null; const l = lowerVals[i] ?? null; const ok = u !== null && m !== null && l !== null; upper.push({ time: t, value: ok ? u : null }); basis.push({ time: t, value: ok ? m : null }); lower.push({ time: t, value: ok ? l : null }); } return { shape: "bands", upper, basis, lower, fillAlpha, style: { color, width: 1 }, }; } /** Milieu (max high + min low)/2 de la fenêtre de N barres se terminant en i — la « ligne médiane » d'Ichimoku (Tenkan/Kijun/Senkou B en dérivent toutes). Warm-up (< N barres) → null. */ function donchianMidSeries( bars: readonly FootprintBar[], period: number, ): Array<number | null> { const n = Math.max(1, Math.floor(period)); const out: Array<number | null> = new Array(bars.length).fill(null); for (let i = n - 1; i < bars.length; i++) { let hi = Number.NEGATIVE_INFINITY; let lo = Number.POSITIVE_INFINITY; for (let j = i - n + 1; j <= i; j++) { if (bars[j].high > hi) hi = bars[j].high; if (bars[j].low < lo) lo = bars[j].low; } out[i] = (hi + lo) / 2; } return out; } /** Moindres carrés y = a + b·t sur la fenêtre de n valeurs se terminant en i (t = 0 pour la plus ancienne, t = n−1 pour la courante). Sommes fermées : Σt = n(n−1)/2, Σt² = n(n−1)(2n−1)/6. Même fit que le LSMA d'averages2.ts — recopié pour que la famille reste autonome (fonction privée là-bas). */ function linFit( values: readonly number[], i: number, n: number, ): { a: number; b: number } { const sumT = (n * (n - 1)) / 2; const sumT2 = (n * (n - 1) * (2 * n - 1)) / 6; let sumY = 0; let sumTY = 0; for (let t = 0; t < n; t++) { const y = values[i - n + 1 + t]; sumY += y; sumTY += t * y; } const denom = n * sumT2 - sumT * sumT; // > 0 dès n ≥ 2 const b = denom > 0 ? (n * sumTY - sumT * sumY) / denom : 0; const a = (sumY - b * sumT) / n; return { a, b }; } /** SMA_P appliquée au SUFFIXE défini d'une série à préfixe null (sortie d'un étage précédent — suffixe contigu par construction). P ≤ 1 → identité. Défensif : un null APRÈS le début du suffixe → tout null (on ne recolle pas deux morceaux séparés par un trou). */ function smoothSuffix( values: ReadonlyArray<number | null>, period: number, ): Array<number | null> { const p = Math.max(1, Math.floor(period)); if (p === 1) return values.slice(); const out: Array<number | null> = new Array(values.length).fill(null); let start = 0; while (start < values.length && values[start] === null) start++; if (start >= values.length) return out; const defined: number[] = []; for (let i = start; i < values.length; i++) { const v = values[i]; if (v === null) return out; defined.push(v); } const s = smaSeries(defined, p); for (let j = 0; j < s.length; j++) out[start + j] = s[j]; return out; } // ── Sessions ──────────────────────────────────────────────────────────────── type SessionOHLC = { o: number; h: number; l: number; c: number }; /** O/H/L/C d'une session complète : open de la PREMIÈRE barre, close de la DERNIÈRE, extrêmes sur toutes les barres. Les tranches de `splitSessions` sont non vides par construction → extrêmes finis. */ function sessionOHLC( bars: readonly FootprintBar[], ses: SessionSlice, ): SessionOHLC { let h = Number.NEGATIVE_INFINITY; let l = Number.POSITIVE_INFINITY; for (let i = ses.start; i <= ses.end; i++) { if (bars[i].high > h) h = bars[i].high; if (bars[i].low < l) l = bars[i].low; } return { o: bars[ses.start].open, h, l, c: bars[ses.end].close }; } /** Projection « session N−1 → session N » commune aux trois familles de pivots : chaque session passée calcule ses niveaux et les trace sur la SUIVANTE (bord droit du chart pour la session courante). La première session chargée n'a pas de précédente → rien n'est inventé. */ function projectedPivots( bars: readonly FootprintBar[], color: string, levelsOf: (prev: SessionOHLC) => Array<[number, string]>, ctx: SeriesContext, ): SeriesOutput[] { const sessions = splitSessions(bars, ctx); const levels: SeriesLevel[] = []; for (let s = 1; s < sessions.length; s++) { const prev = sessionOHLC(bars, sessions[s - 1]); const cur = sessions[s]; const from = bars[cur.start].bucketTsNs; const to = s === sessions.length - 1 ? null : bars[cur.end].bucketTsNs; for (const [price, label] of levelsOf(prev)) { levels.push({ price, from, to, color, label }); } } return [{ shape: "levels", levels }]; } // ── Swing (Fibonacci) ─────────────────────────────────────────────────────── /** Jambe de swing des N dernières barres : plus haut, plus bas, et SENS. Sens = ordre d'apparition des deux extrêmes : le plus haut arrivé APRÈS le plus bas ⇒ jambe HAUSSIÈRE (on retrace vers le bas depuis le sommet) ; sinon jambe BAISSIÈRE. Égalité d'extrêmes (plusieurs barres au même prix) : on garde la DERNIÈRE occurrence (`>=` / `<=`) — c'est le retest le plus récent qui définit la jambe active, pas le premier contact. `null` si moins de N barres (une fenêtre partielle mentirait sur son lookback — règle du catalogue) ou si le range est nul (high = low : il n'y a aucune jambe à retracer, 7 niveaux confondus seraient du bruit). */ type SwingLeg = { hi: number; lo: number; up: boolean; from: number }; function lastSwingLeg( bars: readonly FootprintBar[], lookback: number, ): SwingLeg | null { const n = Math.max(1, Math.floor(lookback)); if (bars.length < n) return null; const start = bars.length - n; let hi = Number.NEGATIVE_INFINITY; let lo = Number.POSITIVE_INFINITY; let hiIdx = start; let loIdx = start; for (let i = start; i < bars.length; i++) { if (bars[i].high >= hi) { hi = bars[i].high; hiIdx = i; } if (bars[i].low <= lo) { lo = bars[i].low; loIdx = i; } } if (!(hi > lo)) return null; return { hi, lo, up: hiIdx >= loIdx, from: bars[start].bucketTsNs }; } // ── Défs ──────────────────────────────────────────────────────────────────── /** Parabolic SAR (Wilder, 1978) — points de stop-and-reverse. AMORÇAGE (barre 1 ; la barre 0 n'émet rien, elle sert de référence) : tendance = HAUSSIÈRE si close[1] ≥ close[0], baissière sinon (l'égalité part haussière — choix arbitraire mais DÉTERMINISTE, documenté) ; SAR[1] = low[0] en hausse / high[0] en baisse ; EP = high[1] en hausse / low[1] en baisse ; AF = afStart. PAS COURANT (i ≥ 2), dans cet ordre EXACT : 1. SAR[i] = SAR[i−1] + AF·(EP − SAR[i−1]) — l'accélération travaille sur la distance au point extrême, pas sur le prix ; 2. BRIDAGE sur les DEUX barres précédentes : en hausse SAR[i] ≤ min(low[i−1], low[i−2]) ; en baisse SAR[i] ≥ max(high[i−1], high[i−2]). Sans cette borne le SAR pourrait se placer à l'intérieur du range récent et déclencher un flip fantôme ; 3. BASCULE : en hausse, low[i] < SAR[i] ⇒ tendance BAISSIÈRE et SAR[i] = EP (l'ancien point extrême devient le stop), EP = low[i], AF remis à afStart. Symétriquement en baisse avec high[i] > SAR[i] ; 4. SANS bascule, MISE À JOUR DE L'AF : uniquement si un NOUVEAU point extrême est fait (high[i] > EP en hausse, low[i] < EP en baisse) → EP = ce nouvel extrême et AF = min(AF + afStep, afMax). Une barre qui n'étend pas la tendance ne fait PAS accélérer l'AF (erreur classique). Défauts de Wilder : afStart 0.02, afStep 0.02, afMax 0.2. Sortie : un dot par barre (à partir de la barre 1) au niveau du SAR, coloré par la tendance COURANTE — la barre de flip porte déjà la couleur de la nouvelle tendance.

Cómo leerlo

• Un punto por debajo de las barras significa que el estado actual es alcista y que el punto es el nivel que lo invertiría; un punto por encima significa lo contrario.
• Puntos que se acercan al precio cada vez más deprisa de barra a barra muestran que el factor de aceleración se ha subido varias veces, lo que solo ocurre mientras la tendencia sigue marcando extremos nuevos.
• Puntos separados de forma regular que dejan de acercarse te dicen que la tendencia ha dejado de extenderse, aunque el estado todavía no haya cambiado.
• La barra en la que el estado cambia ya lleva el color del estado nuevo, así que lee el cambio de color como el giro en sí y no como un aviso previo.

Parámetros y valores por defecto

El AF inicial y el paso del AF son 0,02 por defecto, ambos ajustables de 0,001 a 0,5, y el AF máximo es 0,2 por defecto dentro de un rango de 0,01 a 1; estos valores por defecto son los que publicó Wilder. Subir el inicio o el paso hace que los puntos se acerquen antes al precio y acorta el tiempo medio hasta un giro, mientras que subir el techo deja que la aceleración siga creciendo en una tendencia larga. Con un factor de 1 el punto saltaría directamente sobre el punto extremo en una sola barra, y por eso el techo se deja normalmente muy por debajo. El primer punto se emite en la segunda barra de la serie, partiendo del máximo o el mínimo de la primera.

Lo que no muestra

El Parabolic SAR mantiene siempre un estado, así que nunca es neutral: en un mercado lateral cambia de un lado a otro y produce una secuencia de giros que no corresponden a ninguna tendencia. No tiene término de volatilidad más allá de los máximos y mínimos recientes usados para la acotación, así que no se adapta a un cambio de régimen como sí lo hace un stop basado en ATR. El estado inicial se decide comparando los dos primeros cierres, resolviendo la igualdad como alcista, así que un gráfico cargado desde otra barra de inicio puede empezar en el estado contrario. Y todo el cálculo es geometría de precio: máximos, mínimos y cierres lo deciden todo, sin ningún término de volumen.

Indicadores relacionados

• SMA — Medias y volatilidad
• EMA — Medias y volatilidad
• WMA — Medias y volatilidad
• Hull MA — Medias y volatilidad
• ATR (Wilder) — Medias y volatilidad
• Bollinger — Medias y volatilidad

Ver todos los indicadores

Esta página en otros idiomas

• English
• Français
• Italiano
• Русский
• 中文
• العربية