I should cover what RRGs are, the underlying math with JdK RS-Ratio and RS-Momentum, how to build one with Python for data fetching and plotting, and where to find pre-built versions like StockCharts or TradingView. Since the exact JdK formulas are proprietary, I'm working through a reasonable approximation: computing a relative strength ratio between security and benchmark, then normalizing it into a z-score-like oscillator around 100 to get RS-Ratio, and deriving RS-Momentum from its rate of change. Since the exact JdK formula is proprietary, I'll go with a reasonable normalized approximation and be upfront about that limitation. I'm planning out a script that pulls data via yfinance, computes RS-Ratio and RS-Momentum for several indexes against a benchmark, then visualizes the RRG with quadrants and trailing tails using matplotlib, possibly with a Plotly interactive option too. For the default timeframe, weekly data with short tails makes the most sense since that matches how RRGs are typically used. I'm also weighing which indexes to include as examples, considering that raw index tickers are quoted in local currencies, so using ETFs denominated in a common currency would give more meaningful comparisons. Now I'm setting up the code, starting with the imports and defining the ticker universe and benchmark for the RRG analysis. I'm working out the RRG math: computing relative strength as price divided by benchmark, then normalizing into an RS-Ratio and RS-Momentum around 100. I'm second-guessing my momentum calculation since it needs to properly lead the ratio for the rotation to trace out clockwise correctly. I decide instead to normalize via z-score since raw momentum differences would be too tight around 100 to be useful, then start sketching a function that computes the RS-Ratio as a normalized deviation of the smoothed RS line from its longer-term mean. Still writing RRG code... Actually, defining momentum as a z-score of rs_ratio itself seems flawed since it wouldn't capture rate of change, just correlate with rs_ratio directly — a proper ROC-based measure would be more meaningful as a leading indicator. I'm reconsidering the real JdK RS-Ratio formula to get this right, since smoothing rs with an EMA before z-scoring might reduce noise, and momentum should probably be based on the ROC or diff of rs_ratio rather than its raw z-score. Now I'm setting up a full working script with tickers, benchmark, and window parameters to mentally test the approach. Now I'm defining a function that computes the RS-Ratio and RS-Momentum lines for each ticker against the benchmark, building z-scored versions of relative strength and its derivative into dataframes. I'm second-guessing whether momentum should be the z-score of the ratio's diff, since the ratio is already a z-score itself. Since rs_ratio's diff is a proper derivative, z-scoring it over a window centers momentum near 100 too, but it could get noisy—so I'm weighing options like smoothing with a rolling mean, using an EMA, or trying a multi-week rate of change instead, trying to figure out what gives the cleanest rotational visual before circling back to how JdK's actual methodology handles this. I'll settle for a reasonable approximation rather than an exact replica, and note in the code that parameters are tunable. Writing the RRG function... But I catch an edge case: if RS-Ratio stays perfectly constant, its percent change is zero everywhere, which makes the rolling standard deviation zero too and produces a division-by-zero when computing momentum's z-score, so I need to guard against that. I'm also weighing using diff versus pct_change on the RS-Ratio itself—since RS-Ratio hovers near 100, the two are nearly proportional and the z-scoring cancels out any scale difference anyway, so diff is simpler and clearer. I consider whether z-scoring momentum over a rolling window might distort persistent trends, but it seems reasonable enough to proceed with. Actually the RS-Ratio deviation-from-moving-average approach is intentional—it captures the trend in relative strength, not absolute level, matching the real JdK definition where values above 100 signal an uptrend. For momentum, I'm now considering a ratio-based formula instead: something like 100 times rs_ratio divided by its value k periods ago, which centers around 100 similarly. I'm settling on a compromise: keep RS-Ratio as a z-score but compute RS-Momentum as a rate-of-change scaled by a longer rolling standard deviation, which preserves sign and level while giving a consistent unit scale. Now I'm starting to write the function that builds these RRG series. Writing rrg_series function... I'm checking the typical magnitude of week-to-week changes so the RS-Momentum scale roughly matches the RS-Ratio's spread around 100. Trying to recall the standard formula... That version uses full-sample statistics rather than rolling ones, which introduces look-ahead bias and isn't ideal for backtesting, though fine for a static snapshot. I'll settle on my own definition instead: RS as 100 times price over benchmark, RS-Ratio as 100 plus a rolling z-score of RS over some window like 12-14 periods, and I'm reconsidering how to define RS-Momentum properly without the same rolling-window issue. Actually, thinking about the true JdK methodology, RS-Momentum should represent the rate of change of RS-Ratio normalized so that 100 means zero momentum -- so I should scale only by rolling standard deviation without subtracting the mean, keeping 100 as the true zero point. But dividing the diff by its rolling standard deviation could over-amplify small moves during low-volatility periods, which is a concern I need to work through. I'm trying to decide between formulations that keep 100 as the neutral midpoint while preserving clockwise rotation behavior, weighing a ratio-based momentum formula against a z-score based one, since the axes will autoscale anyway and what matters most is that momentum leads the ratio correctly. Comparing M2 against real RRG behavior shows it's less faithful, since a steadily rising RS-Ratio should register momentum above 100, not neutral. I'm now weighing M3, which normalizes by the rolling standard deviation of the diff to keep 100 as the zero-change baseline, though it risks spikes when volatility is low. I'm leaning toward M1 but considering whether to unify the normalization approach across both rs_ratio and rs_mom using the same standard deviation scaling method. I'll settle on M1, reasoning that since axes autoscale visually the exact normalization constant won't matter much, and JdK's precise proprietary scaling isn't publicly known anyway. I'm still uncertain about the right lookback period for momentum—leaning toward keeping it comparable to the ratio period, but unsure whether k=1 gives too jagged a rotation versus a longer window smoothing things out too much. I'll settle on no smoothing, window 14, mom_period 4, and sanity-check the shape with a hypothetical: SPY vs ACWI trending up for 20 weeks then flattening then declining. Working through the math, a linear rise gives a z-score around 1.6 during the trend, which seems like a reasonable check that the approach produces sensible RRG-like values. Tracing the trajectory: it should move from leading (high ratio, momentum near 100) into weakening (ratio still high but momentum dropping below 100), then lagging, then improving, then back to leading — a clean clockwise rotation, which matches expected RRG behavior. Now I'm planning the plotting function: scattering each ticker's latest point with labels, drawing a thin tail line connecting recent points, adding quadrant divider lines at x=100 and y=100, shading the four quadrants (green for leading, yellow for weakening, red for lagging, blue for improving), and keeping the axes symmetric around 100. Writing plotting function... Adding quadrant shading logic... Refining the plotting logic... Adding the remaining quadrant labels... I should also decide whether to include a compact Plotly version for an interactive RRG with hover tooltips, since interactivity would genuinely improve usability here—I'll add a brief snippet rather than skip it entirely to keep the answer from ballooning. Writing Plotly scatter code... Now I'm outlining the quadrant explanations for the "how to use" section—Leading, Weakening, and the other stages of the RRG rotation cycle. Rotation typically flows clockwise from Improving to Leading to Weakening to Lagging, though names can reverse course, hooking back from weakening into leading during strong bull runs. I'm also noting that tail length reflects speed of movement while direction matters more than current quadrant placement—a stock in Lagging but heading northeast can be more promising than one in Leading drifting southwest—and that distance from center signals the strength of the relative trend in either direction. Everything on the RRG is relative to a chosen benchmark that should encompass the constituents, so picking the right one (ACWI, SPY, VTI) and keeping currencies consistent matters. Weekly timeframes with 5-10 week tails are standard, though daily works for tactical calls with shorter tails, and since RRG measures relative not absolute performance, it's worth adding cash or bond proxies like BIL, AGG, or TLT to see how equities stack up against safer havens during broader market declines. Common applications include sector rotation, country allocation, style rotation, and pairs trades—going long names heading toward Leading and short those drifting into Lagging. Practically, I'd rank securities by their heading angle and distance from center, buy on RS-Ratio crossing above 100 with rising momentum, and always confirm signals on actual price charts rather than relying on the RRG alone, watching for curling tails as early warnings of rotation reversals. For pitfalls, I need to flag benchmark selection, small universe sizes limiting signal quality, position versus direction of movement, curve-fitting risk, false reversals, inherent lag, and the fact that JdK's exact formula is proprietary—so any homemade version will approximate but not exactly replicate StockCharts' output. On the tooling side, StockCharts offers a free (if limited) RRG with predefined sector/country groups, making it the most accessible option for non-coders, while Optuma provides the most complete official implementation, and Bloomberg, Refinitiv, and TradingView offer alternative or community-built versions. I should also note relativerotationgraphs.com as JdK's own site, and mention common Yahoo Finance index tickers (^GSPC, ^NDX, ^DJI, ^RUT, and various international indexes) useful for building a global RRG, along with the currency consideration since local-currency indexes need a common benchmark like ACWI for fair comparison. Given the FX mismatch, I'm deciding to keep things simple by comparing US indexes (S&P, Nasdaq, Russell, Dow, MidCap 400) against a USD benchmark like VTI, since everything stays in the same currency. I'll structure the final code around this US-index version with clear configuration options. Writing configuration setup... Adding more ticker groups... Writing RRG calculation functions... Actually I'll skip the dropna alignment concern since NaNs only appear early on with plenty of data past 2022, so I'll just slice the tail instead. Then I'm building a summary table showing the latest RS-Ratio and RS-Momentum values per ticker, classifying each into its quadrant (Leading, Weakening, Lagging, or Improving) based on whether the values are above or below 100. I'm also computing a heading angle from the last move's direction, though I note the angle may be misleading if the ratio and momentum axes use different scales. I want to double-check the standard quadrant interpretation: Leading (RS-Ratio and RS-Momentum both above 100) means outperforming with strengthening momentum, while Weakening (Ratio above 100 but Momentum below 100) means still strong relative trend but momentum fading. Lagging is when both metrics fall below 100, indicating underperformance, while Improving is when Ratio is below 100 but Momentum turns above 100, suggesting an early recovery signal. The clockwise rotation pattern happens because momentum, as a derivative, tends to lead the ratio itself, and I should mention JdK's emphasis on tail length/direction, how strong trends can rotate on the right side without dipping into lagging, and the importance of cross-referencing with the benchmark's own trend. Now I'm thinking through practical application — using RRG for shortlisting candidates then switching to regular charts for actual entry/exit timing, Optuma's heading-angle feature for buy/sell signals, multi-timeframe analysis, and how index-level RRGs (countries vs ACWI, sectors vs S&P) inform allocation decisions, plus starting to consider portfolio construction like overweighting Leading & Improving names. I'm noting practical warnings too: avoid chasing names deep in Leading with extended tails, since Improving-to-Leading transitions often offer the best risk/reward, and I want to flag that a lopsided RRG (nearly everything clustered in Leading/Weakening) can signal a narrow, mega-cap-dominated benchmark rather than genuine rotation. I'm also planning to mention pre-built tools like StockCharts' RRG feature as an alternative to building this from scratch. I'm weighing static matplotlib versus an interactive Plotly approach with a date slider for the RRG visualization—leaning toward a simple Plotly scatter using animation_frame, though tails won't render smoothly since only the current point moves per frame. I'll go with a static hover version and just mention animation as a possible extension, keeping the response focused. Now I'm drafting the final Python script, including the settings block with the ticker universe and imports for yfinance, pandas, and matplotlib. Writing setup and universe config... Writing data download and RRG calculation logic... Building the RRG plot function... Adding trajectory lines with arrow markers... I'm double-checking the quadrant label placement logic, verifying that the horizontal and vertical alignment settings correctly correspond to the right edges and top/bottom coordinates for each of the four RRG quadrants (leading, weakening, lagging, improving). Switching to "goldenrod" for consistent fill and text color to keep it readable, then confirming the marker edge color and arrow annotation kwargs are valid for drawing the trailing tail and endpoint dot on each security's path. I'm also checking that formatting the timestamp with strftime codes works fine on pandas Timestamps, and double-checking that yfinance's column structure (auto-adjusted "Close" vs "Adj Close" in older versions) will correctly return per-ticker price series when downloading multiple symbols at once. The dropna step for missing weekly bars looks safe given all these ETFs have sufficiently long histories relative to my 2021 start date. Now I'm defining a quadrant classification function and building a snapshot summary table with the latest RS-Ratio and RS-Momentum values per ticker. I'm computing a heading angle from the two-step direction of movement in ratio/momentum space, though I note the different scales between the axes mean this geometric angle won't perfectly match the visual plot angle -- something to keep in mind when interpreting it. Now setting up a Plotly version... I could add quadrant shading with shapes, but I'll keep it minimal. Now I want to explain how to read the graph: the X-axis (RS-Ratio) shows whether relative strength versus the benchmark is trending up or down, and the Y-axis (RS-Momentum) shows whether that RS-Ratio itself is accelerating or decelerating, forming four quadrants that stocks typically rotate through clockwise—Improving, Leading, Weakening, Lagging. The tail length reflects how many recent periods are plotted, with longer tails signaling more relative "energy," and the heading direction of the most recent segment is the most actionable signal, more so than the quadrant position itself. Distance from center reflects the strength of the trend, with points far to the right indicating strong outperformance that may be getting stretched. For practical use, I want to note that a northeast heading is bullish regardless of quadrant while a southwest heading is bearish, that classic entries happen when a stock crosses from Improving into Leading, and exits are signaled when a stock rotates from Leading into Weakening with the tail curling downward, confirmed further as it moves into Lagging—while strong leaders sometimes just hook back into Leading without ever reaching Lagging. It's also worth remembering everything is relative, so in a bear market "Leading" might just mean losing less, and benchmarks need to be chosen carefully—sector ETFs against SPY, countries against ACWI, and so on—since changing the benchmark changes the whole picture. Weekly RRGs suit allocation decisions while daily suits timing, and the overall workflow should be to screen with RRG, confirm on price charts, then size and rebalance positions, potentially even pairing long NE-headed names against short SW-headed ones for a market-neutral trade. I should also watch for pitfalls: small or mismatched universes produce misleading rotations, positions already deep in Leading may have already made their move, and names hugging the center shouldn't be acted on. Home-grown RS-Ratio/RS-Momentum formulas won't match JdK's proprietary calculations exactly, so I shouldn't compare raw values across tools, and I shouldn't over-tune the rolling window—10 to 14 weekly periods is roughly standard. For actual implementation, StockCharts.com offers a free basic RRG tool with predefined sector and industry groups. I should also mention the Excel/spreadsheet alternative — same formulas plus a scatter chart with smoothed tails — for those who prefer that route. Given the question has three parts, I'll keep the answer fairly complete but tight, noting that Yahoo weekly bars are Monday-dated with the last bar in-progress, and that a 14-week z-score lookback on weekly data spans roughly three months, matching how a full rotation typically unfolds in the standard JdK weekly RRG. Checking the math on RS-Momentum with a 4-week ROC against the z-scored ratio, the scales line up well — both staying in a comparable 97–103 range with no risk of division issues since the ratio sits near 100. I'm now considering whether to smooth the ratio before z-scoring to get cleaner tails. I could add optional smoothing as a commented line, since weekly z-scores can look a bit jagged otherwise. I should skip trying to match exact StockCharts parameters since I can't verify specifics, and instead just note briefly why momentum leads the level — it's the derivative, so it peaks and troughs earlier, producing the clockwise rotation. Now I'm ready to write the final answer, starting with what's being plotted and the formulas, then covering no-code options like StockCharts. ## What an RRG actually plots A Relative Rotation Graph (Julius de Kempenaer's invention) puts every security on two axes, both measured **against one benchmark** and both centered on 100: - **x-axis – JdK RS-Ratio**: is the relative-strength line (price ÷ benchmark) in an uptrend (>100) or downtrend (<100)? - **y-axis – JdK RS-Momentum**: is the RS-Ratio itself rising (>100) or falling (<100)? It's the rate of change of the x-value, so it *leads* it — which is why points rotate clockwise. The exact JdK formulas are proprietary, but a normalized RS line and its rate of change reproduce the behaviour closely. --- ## Option 1 – No code (fastest) - **StockCharts.com → Free Charts → RRG**: free basic version, predefined groups (world indexes, S&P sectors, US style/size), weekly or daily, adjustable tail length, animation. Best starting point. - **Optuma**: de Kempenaer's development partner; the most complete implementation (RRG-Heading, scanning, RS-Ratio/Momentum as indicators). Paid. - **Bloomberg**: `RRG `. - **TradingView**: several community "RRG" scripts — approximations, but fine for a quick look. --- ## Option 2 – Build it yourself (Python) ```python # pip install yfinance pandas numpy matplotlib import numpy as np, pandas as pd, yfinance as yf import matplotlib.pyplot as plt # ------------------------------------------------ settings UNIVERSE = ["SPY", "QQQ", "DIA", "IWM", # S&P 500, Nasdaq-100, Dow, Russell 2000 "EWJ", "EWG", "EWU", "EWQ", # Japan, Germany, UK, France "FXI", "INDA", "EWZ", "EWA", "EWC"] # China, India, Brazil, Australia, Canada BENCHMARK = "ACWI" # must represent the universe and be in the SAME currency INTERVAL = "1wk" # weekly = classic RRG; "1d" for a tactical view WINDOW = 14 # normalisation lookback (periods) MOM_PER = 4 # rate-of-change period for RS-Momentum TAIL = 8 # periods drawn in each tail # ------------------------------------------------ data px = yf.download(UNIVERSE + [BENCHMARK], start="2021-01-01", interval=INTERVAL, auto_adjust=True, progress=False)["Close"].dropna() # px = px.iloc[:-1] # uncomment to drop the current, unfinished week # ------------------------------------------------ JdK-style indicators (approximation) def zscore(s, w): return (s - s.rolling(w).mean()) / s.rolling(w).std() def rrg_lines(price, bench, window=WINDOW, mom_per=MOM_PER): rs = 100 * price / bench # relative-strength line # rs = rs.ewm(span=3).mean() # optional: smoother tails rs_ratio = 100 + zscore(rs, window) # RS-Ratio: RS trend, 100 = neutral rs_mom = 100 * rs_ratio / rs_ratio.shift(mom_per) # RS-Momentum: ROC of RS-Ratio, 100 = flat return rs_ratio, rs_mom lines = {t: rrg_lines(px[t], px[BENCHMARK]) for t in UNIVERSE} ratio = pd.DataFrame({t: v[0] for t, v in lines.items()}) mom = pd.DataFrame({t: v[1] for t, v in lines.items()}) # ------------------------------------------------ plot def plot_rrg(ratio, mom, tail=TAIL): r, m = ratio.iloc[-tail:], mom.iloc[-tail:] xr = np.nanmax(np.abs(r.values - 100)) * 1.2 # axes symmetric around 100 yr = np.nanmax(np.abs(m.values - 100)) * 1.2 fig, ax = plt.subplots(figsize=(9, 9)) ax.set_xlim(100 - xr, 100 + xr); ax.set_ylim(100 - yr, 100 + yr) ax.axhline(100, color="k", lw=.8); ax.axvline(100, color="k", lw=.8) quads = [(100, 100+xr, 100, 100+yr, "green", "LEADING", "right", "top"), (100, 100+xr, 100-yr, 100, "goldenrod", "WEAKENING", "right", "bottom"), (100-xr, 100, 100-yr, 100, "red", "LAGGING", "left", "bottom"), (100-xr, 100, 100, 100+yr, "blue", "IMPROVING", "left", "top")] for x0, x1, y0, y1, c, name, ha, va in quads: ax.fill_between([x0, x1], y0, y1, color=c, alpha=.07) ax.text(x1 if ha == "right" else x0, y1 if va == "top" else y0, f" {name} ", color=c, ha=ha, va=va, fontsize=11, weight="bold") for t in r.columns: x, y = r[t].values, m[t].values line, = ax.plot(x, y, "-", lw=1.3, alpha=.8); c = line.get_color() ax.plot(x[:-1], y[:-1], "o", ms=3.5, color=c) # tail ax.annotate("", xy=(x[-1], y[-1]), xytext=(x[-2], y[-2]), # arrow head arrowprops=dict(arrowstyle="-|>", color=c, lw=1.5, mutation_scale=15)) ax.plot(x[-1], y[-1], "o", ms=9, color=c, mec="k") # current position ax.annotate(t, (x[-1], y[-1]), xytext=(6, 6), textcoords="offset points", fontsize=9, weight="bold") ax.set_xlabel(f"JdK RS-Ratio (relative trend vs {BENCHMARK})") ax.set_ylabel("JdK RS-Momentum (rate of change of RS-Ratio)") ax.set_title(f"Relative Rotation Graph • {INTERVAL} • {ratio.index[-1]:%d %b %Y}") plt.tight_layout(); plt.show() plot_rrg(ratio, mom) # ------------------------------------------------ snapshot table def quadrant(r, m): return ("Leading" if r >= 100 and m >= 100 else "Weakening" if r >= 100 else "Lagging" if m < 100 else "Improving") snap = pd.DataFrame({"RS-Ratio": ratio.iloc[-1], "RS-Momentum": mom.iloc[-1]}) snap["Quadrant"] = [quadrant(a, b) for a, b in zip(snap["RS-Ratio"], snap["RS-Momentum"])] dx, dy = ratio.iloc[-1] - ratio.iloc[-3], mom.iloc[-1] - mom.iloc[-3] snap["Heading°"] = (np.degrees(np.arctan2(dy, dx)) % 360).round(0) # 0°=E, 90°=N; 0–90° = getting stronger print(snap.sort_values("RS-Ratio", ascending=False).round(2)) ``` **Interactive version** (hover shows the date of each tail point) — swap the plot for Plotly: ```python import plotly.graph_objects as go fig = go.Figure() for t in UNIVERSE: x, y = ratio[t].iloc[-TAIL:], mom[t].iloc[-TAIL:] fig.add_trace(go.Scatter(x=x, y=y, mode="lines+markers+text", name=t, text=[""]*(TAIL-1)+[t], textposition="top right", marker=dict(size=[5]*(TAIL-1)+[13]), hovertext=x.index.strftime("%Y-%m-%d"))) fig.add_hline(y=100, line_width=1); fig.add_vline(x=100, line_width=1) fig.update_layout(width=850, height=850, template="plotly_white", xaxis_title="RS-Ratio", yaxis_title="RS-Momentum") fig.show() ``` Notes: - Yahoo tickers like `^GSPC`, `^N225`, `^GDAXI` work too, but they're in local currency — comparing them to a USD benchmark mixes in FX. For a global index RRG, use USD ETF proxies (as above) or convert everything to one currency. For US-only (S&P 500 vs Nasdaq vs Russell vs Dow), use `VTI` or `^GSPC` as the benchmark. - The same formulas work in Excel with an XY-scatter chart ("smoothed lines" for tails). --- ## How to read it | Quadrant | RS-Ratio | RS-Momentum | Meaning | |---|---|---|---| | **Leading** (top-right, green) | >100 | >100 | Outperforming and still gaining relative momentum | | **Weakening** (bottom-right, yellow) | >100 | <100 | Still ahead of the benchmark, but the relative trend is losing steam | | **Lagging** (bottom-left, red) | <100 | <100 | Underperforming, and getting worse | | **Improving** (top-left, blue) | <100 | >100 | Still behind, but relative momentum has turned up | - **Rotation is clockwise**: Improving → Leading → Weakening → Lagging → Improving, because momentum turns before trend. Not every rotation completes: strong leaders often "hook" Leading → Weakening → back to Leading without visiting Lagging; chronic laggards do the mirror image on the left. - **The tail tells the tale.** Direction (heading) matters more than which quadrant a name sits in. A name in Lagging moving north-east is more interesting than a name in Leading moving south-west. Long tail = fast relative move (strong, possibly extended); short tail = stable relationship. - **Distance from the centre** = strength of the relative trend. Far right = strongly outperforming; far left = strongly underperforming. Names hugging the crosshair are noise — don't trade them. --- ## How to actually use it 1. **Pick the right benchmark.** The universe should roughly "add up" to it: country indexes vs ACWI/URTH, US sectors vs SPY, US size/style vs VTI. Changing the benchmark changes the whole picture — that's a feature, not a bug. 2. **Weekly for allocation, daily for timing.** Weekly with 5–10 week tails is the standard view; daily with 10–15 day tails helps time entries. Look for agreement between the two. 3. **Entries**: the highest-quality signal is the **Improving → Leading crossover** (RS-Ratio crossing 100 while momentum is already above 100) with a tail heading 0–90°. Buying things already deep in Leading with long tails is chasing. 4. **Exits / underweights**: Leading → Weakening with the tail curling down and left; Weakening → Lagging confirms it. A name deep in Leading whose tail flattens and hooks is your early warning. 5. **Everything is relative.** In a bear market, "Leading" just means losing less. Add a cash proxy (BIL/SHV) and bonds (AGG/TLT) to the universe — if cash is heading into Leading, that's your answer — or check the benchmark's own price trend before going long anything. 6. **Workflow**: RRG → shortlist (NE-heading names in Improving/Leading; SW-heading names in Weakening/Lagging) → confirm on price charts (trend, support/resistance, volume) → size → re-check weekly. RRG is a *where-to-look* tool, not a mechanical trigger. 7. **Pairs / relative trades**: long a NE-heading name vs short a SW-heading name gives a market-neutral expression of the rotation. 8. **Breadth read**: if almost all members sit on the right side, the benchmark is being dragged down by a few heavy names (common with cap-weighted indexes) — useful context for how "healthy" the index is. --- ## Pitfalls - Small or mismatched universes produce meaningless rotations. - Home-made RS-Ratio/Momentum ≠ JdK's proprietary values. Behaviour is similar; exact numbers won't match StockCharts/Optuma, so don't compare across tools. - Don't over-tune WINDOW / MOM_PER; 10–14 weekly periods is a sensible range. Shorter = faster but noisier rotations. - Weekly bars from Yahoo include the current partial week — drop it if you rebalance mid-week. - Whipsaws near the centre and false hooks are normal; the RRG shows *relative* trend, which can reverse even when absolute price does nothing.

best way to make and display a Relative Rotation graphh for ...