The Gann Pivot Indicator: A Deep Dive into the Trading Philosophy and Mechanics

LW_Millions · Aug 2, 2025

themickey said:
Just another day of traders gravitating down TA rabbit hole
More...

It is a rabbit hole.

Traders are constantly staring at lines and charts trying to make connections, coincidences and meaning behind it all. When in reality they're not doing anything meaningful with depth and understanding. It's all rather just blind, surface, logic and tracing.

The market truth and way is out there but it has to be discovered and understood. Once you understand how the elements and variables shape things you can reasonably predict the S&P everyday. When to strike and when to close the position. And when to stand down, if no expected opportunity is present.

danielc1 · Aug 4, 2025 at 12:57 AM

If you take Gann square of 9, with Fibonacci between the lines of the square of 9, you will see prices respect all of those lines. If you implement on top of that the pivot indicator described here on the forum, you have a very robust way of picturing price action. Next step is the time action, where time and price square. This gives the major turning points. When you have all this, you can see where it goes and when. Then you can throw it in the carbidge can and just focus on cutting your losers short and letting your winners run, with position sizing to make money.

mason macgregorson · Aug 4, 2025 at 10:57 AM

MarkBrown said:
The Fundamental Trading Concept

This indicator is built on one of the most profound observations in technical analysis: markets don't move in straight lines, but rather in a series of swings or waves. W.D. Gann recognized that these swings create a rhythm in the market, and by understanding this rhythm, traders can anticipate future price movements.

The Core Philosophy

The indicator is looking for what I call "exhaustion patterns" - specific market structures that suggest a trend is running out of steam and may be ready to reverse. Think of it like watching ocean waves: before a big wave crashes and reverses, there are subtle signs in the water's movement that experienced surfers can read. This indicator is trying to read those same subtle signs in price action.

Understanding Market Structure Through Pivots

What is a Pivot?

A pivot is a turning point in the market - a place where price stopped going in one direction and started going in another. Imagine you're hiking up a mountain:

A Pivot High is like reaching a peak where you have to start going down

A Pivot Low is like reaching a valley where you have to start going up

The indicator identifies these using a simple 3-bar pattern:

Pivot High: Yesterday's high is higher than both today's high AND the day before yesterday's high

Pivot Low: Yesterday's low is lower than both today's low AND the day before yesterday's low

The Genius of the Trading Logic

For Buy Signals - The Detailed Process

Let me walk you through exactly what happens when the indicator looks for a buy signal:

New Pivot High Forms: The market makes a pivot high (a local peak)

Historical Context Check: The indicator asks, "Is this pivot high lower than the absolute highest high the market has ever made?" This filters out pivots at all-time highs, where buying might be dangerous.

Looking for the Previous Higher High: The indicator then looks backward in time for a previous pivot high that was HIGHER than the current one. This is crucial - it's looking for evidence that the market is making LOWER HIGHS, a classic sign of a downtrend.

Time Filter: It only considers previous highs that are at least 'GannDays' (default 4) bars ago. This ensures we're looking at meaningful swings, not just minor fluctuations.

Finding the Lowest Point: Between that previous higher high and now, the indicator finds the LOWEST pivot low. This represents the maximum pessimism or selling pressure in that period.

Final Validation: If the time from that lowest low to the current pivot high is at least 'GannDays', it's saying: "The market fell from a higher high, made a significant low, and has now rallied back up for at least 4 days to make this current high. This could be the start of a new uptrend."

Why This Works - The Psychology

What's happening here is profound. The pattern identifies:

Failed Continuation: The market couldn't make a higher high (bearish)

Significant Selling: A meaningful low was established (maximum fear)

Recovery Rally: Price has now rallied for several days off that low

Potential Reversal: This could be early buyers stepping in, sensing value

For Sell Signals - The Mirror Image

The sell signal logic is the exact opposite:

New Pivot Low Forms: But it's not the absolute lowest low ever

Finds Previous Lower Low: Looks for evidence of HIGHER LOWS (uptrend characteristic)

Identifies Highest High: Finds the peak of optimism between the previous low and now

Time Validation: Ensures enough time has passed for this to be meaningful

The psychology here is identifying when an uptrend might be exhausting - higher lows (bullish) but now failing to continue, with a significant high (maximum optimism) followed by several days of decline.

The Brilliant Use of Time

Gann was obsessed with time, and this indicator honors that. The 'GannDays' parameter (default 4) serves multiple purposes:

Filters Noise: Ensures we're looking at meaningful swings, not random fluctuations

Respects Market Rhythm: Many markets have natural 3-5 day rhythms

Allows Patterns to Develop: Gives the market time to "prove" its intention

Signal Management and Discipline

Signal Expiration (SigExpir = 50)
This is brilliant risk management. A signal doesn't last forever - if the market doesn't trigger your entry within 50 bars, the signal expires. This prevents you from acting on stale information.

Entry Mechanism

Buy Signal: Places a stop order 1 tick ABOVE the pivot high

Sell Signal: Places a stop order 1 tick BELOW the pivot low

This ensures you only enter if the market actually breaks through these levels, confirming the reversal.

The Array Storage System

The indicator stores up to 1500 historical pivots. Why?

Pattern Recognition: Needs historical context to identify patterns

Adaptive Analysis: Can look far back for significant levels

Market Memory: Respects that old pivots can still be relevant

Real-World Trading Application

Imagine you're trading the S&P 500:

Market has been falling for weeks

A pivot low forms at 4,200 (the fear point)

Market rallies for 5 days to 4,250

Pivot high forms at 4,250

Indicator looks back, sees previous high was 4,300

Calculates: "We fell from 4,300 to 4,200, now rallied to 4,250"

Signal generated: Buy stop at 4,251

If the market continues up and breaks 4,251, you're in. If it fails and falls back, you're protected.

Why This Approach is Powerful

Objective Rules: No subjective interpretation needed

Risk Definition: You know exactly where to enter and can place stops

Patience: Waits for high-probability setups

Time-Tested: Based on Gann's century-old principles

Adaptable: Works across different markets and timeframes

The Hidden Wisdom

The deepest insight here is that the indicator is NOT trying to catch exact tops and bottoms. Instead, it's waiting for the market to show its hand - to prove that a reversal might be underway - before suggesting action. This is the difference between prediction and reaction, and it's why this approach has survived for decades.

The indicator essentially says: "Don't try to catch a falling knife. Wait for the knife to hit the ground, bounce, and show it might be safe to pick up."

python code
Code:
import numpy as np
import pandas as pd
from typing import Tuple, List, Optional
import matplotlib.pyplot as plt
from dataclasses import dataclass
from datetime import datetime

@dataclass
class PivotPoint:
    """Class to store pivot point information"""
    bar: int
    price: float
    pivot_type: str  # 'high' or 'low'

class GannPivotIndicator:
    """
    GANN PIVOT INDICATOR
    Python implementation of the Gann Pivot Trading System

    This indicator identifies pivot highs and lows, then looks for specific
    patterns based on Gann's principles to generate buy and sell signals.
    """

    def __init__(self, gann_days: int = 4, sig_expir: int = 50, max_array_size: int = 1500):
        """
        Initialize the Gann Pivot Indicator

        Parameters:
        -----------
        gann_days : int
            Minimum number of days required between pivots for a valid signal
        sig_expir : int
            Signal expiration - how many bars a signal remains valid
        max_array_size : int
            Maximum number of pivots to store in memory
        """
        self.gann_days = gann_days
        self.sig_expir = sig_expir
        self.max_array_size = max_array_size

        # Initialize variables
        self.market_high = -np.inf
        self.market_low = np.inf

        # Pivot storage
        self.pivot_highs: List[PivotPoint] = []
        self.pivot_lows: List[PivotPoint] = []

        # Signal tracking
        self.temp_buy_price = 0
        self.temp_buy_bar = 0
        self.temp_buy_on = False

        self.temp_sell_price = 0
        self.temp_sell_bar = 0
        self.temp_sell_on = False

        # Track current bar
        self.current_bar = 0

        # Store signals for plotting
        self.buy_signals = []
        self.sell_signals = []

    def _add_pivot_high(self, bar: int, price: float):
        """Add a pivot high to the list with bounds checking"""
        pivot = PivotPoint(bar=bar, price=price, pivot_type='high')

        if len(self.pivot_highs) >= self.max_array_size:
            # Remove oldest pivot to make room
            self.pivot_highs.pop(0)

        self.pivot_highs.append(pivot)

    def _add_pivot_low(self, bar: int, price: float):
        """Add a pivot low to the list with bounds checking"""
        pivot = PivotPoint(bar=bar, price=price, pivot_type='low')

        if len(self.pivot_lows) >= self.max_array_size:
            # Remove oldest pivot to make room
            self.pivot_lows.pop(0)
    
        self.pivot_lows.append(pivot)

    def _identify_pivots(self, high: pd.Series, low: pd.Series, idx: int):
        """
        Identify pivot highs and lows using 3-bar patterns

        Pivot High: High[1] > High[0] and High[1] > High[2]
        Pivot Low: Low[1] < Low[0] and Low[1] < Low[2]
        """
        if idx >= 2:  # Need at least 3 bars
            # Check for Pivot High
            if high.iloc[idx] < high.iloc[idx-1] and high.iloc[idx-1] > high.iloc[idx-2]:
                self._add_pivot_high(self.current_bar - 1, high.iloc[idx-1])
        
            # Check for Pivot Low
            if low.iloc[idx] > low.iloc[idx-1] and low.iloc[idx-1] < low.iloc[idx-2]:
                self._add_pivot_low(self.current_bar - 1, low.iloc[idx-1])
        
    def _check_buy_setup(self):
        """
        Check for buy setup conditions

        Logic:
        1. Find a new pivot high that's lower than market's all-time high
        2. Look back for a previous higher pivot high (at least gann_days ago)
        3. Find the lowest pivot low between them
        4. If conditions met, set buy signal
        """
        if len(self.pivot_highs) < 2 or len(self.pivot_lows) < 1:
            return
    
        latest_pivot_high = self.pivot_highs[-1]

        # Check if this is a new pivot high and not at market high
        if (latest_pivot_high.bar == self.current_bar - 1 and
            latest_pivot_high.price < self.market_high):
    
            # Find previous higher pivot high
            prev_higher_bar = None
            for i in range(len(self.pivot_highs) - 2, -1, -1):
                if self.pivot_highs.price > latest_pivot_high.price:
                    prev_higher_bar = self.pivot_highs.bar
                    break
                
            if prev_higher_bar is None:
                return
            
            # Check if enough bars between pivots
            bar_count = latest_pivot_high.bar - prev_higher_bar
            if bar_count < self.gann_days:
                return
            
            # Find lowest pivot low between the two pivot highs
            lowest_low = None
            lowest_low_bar = None
        
            for pivot_low in self.pivot_lows:
                if pivot_low.bar > prev_higher_bar and pivot_low.bar < latest_pivot_high.bar:
                    if lowest_low is None or pivot_low.price < lowest_low:
                        lowest_low = pivot_low.price
                        lowest_low_bar = pivot_low.bar
                    
            if lowest_low_bar is None:
                return
            
            # Check if enough days from low to current pivot high
            low_to_high_days = latest_pivot_high.bar - lowest_low_bar
        
            if (low_to_high_days >= self.gann_days and
                latest_pivot_high.bar > self.temp_buy_bar):
            
                self.temp_buy_price = latest_pivot_high.price
                self.temp_buy_bar = latest_pivot_high.bar
                self.temp_buy_on = True
            
    def _check_sell_setup(self):
        """
        Check for sell setup conditions
    
        Logic:
        1. Find a new pivot low that's higher than market's all-time low
        2. Look back for a previous lower pivot low (at least gann_days ago)
        3. Find the highest pivot high between them
        4. If conditions met, set sell signal
        """
        if len(self.pivot_lows) < 2 or len(self.pivot_highs) < 1:
            return
        
        latest_pivot_low = self.pivot_lows[-1]
    
        # Check if this is a new pivot low and not at market low
        if (latest_pivot_low.bar == self.current_bar - 1 and
            latest_pivot_low.price > self.market_low):
        
            # Find previous lower pivot low
            prev_lower_bar = None
            bar_count = 0
        
            for i in range(len(self.pivot_lows) - 2, -1, -1):
                if self.pivot_lows.price < latest_pivot_low.price:
                    prev_lower_bar = self.pivot_lows.bar
                    bar_count = latest_pivot_low.bar - prev_lower_bar
                    break
                
            if prev_lower_bar is None or bar_count < self.gann_days:
                return
            
            # Find highest pivot high between the two pivot lows
            highest_high = None
            highest_high_bar = None
        
            for pivot_high in self.pivot_highs:
                if pivot_high.bar > prev_lower_bar and pivot_high.bar < latest_pivot_low.bar:
                    if highest_high is None or pivot_high.price > highest_high:
                        highest_high = pivot_high.price
                        highest_high_bar = pivot_high.bar
                    
            if highest_high_bar is None:
                return
            
            # Check if enough days from high to current pivot low
            high_to_low_days = latest_pivot_low.bar - highest_high_bar
        
            if (high_to_low_days >= self.gann_days and
                latest_pivot_low.bar > self.temp_sell_bar):
            
                self.temp_sell_price = latest_pivot_low.price
                self.temp_sell_bar = latest_pivot_low.bar
                self.temp_sell_on = True
            
    def process_bar(self, high: float, low: float, high_series: pd.Series,
                   low_series: pd.Series, idx: int) -> Tuple[Optional[float], Optional[float]]:
        """
        Process a single bar of data
    
        Returns:
        --------
        Tuple of (buy_signal_price, sell_signal_price) or (None, None) if no signals
        """
        self.current_bar = idx + 1  # CurrentBar in EasyLanguage is 1-based
    
        # Update market highs and lows
        if high > self.market_high:
            self.market_high = high
        if low < self.market_low:
            self.market_low = low
        
        # Identify pivots
        self._identify_pivots(high_series, low_series, idx)
    
        # Check for new setups
        self._check_buy_setup()
        self._check_sell_setup()
    
        buy_signal = None
        sell_signal = None
    
        # Check if buy signal is active and valid
        if self.temp_buy_on:
            if (high < self.temp_buy_price and
                self.current_bar - self.temp_buy_bar <= self.sig_expir):
                buy_signal = self.temp_buy_price + 0.01  # Adding 1 tick
            else:
                self.temp_buy_on = False
            
        # Check if sell signal is active and valid
        if self.temp_sell_on:
            if (low > self.temp_sell_price and
                self.current_bar - self.temp_sell_bar <= self.sig_expir):
                sell_signal = self.temp_sell_price - 0.01  # Subtracting 1 tick
            else:
                self.temp_sell_on = False
            
        return buy_signal, sell_signal

    def analyze(self, data: pd.DataFrame) -> pd.DataFrame:
        """
        Analyze a DataFrame with OHLC data
    
        Parameters:
        -----------
        data : pd.DataFrame
            DataFrame with columns: 'high', 'low' (and optionally 'open', 'close')
        
        Returns:
        --------
        pd.DataFrame with additional columns: 'buy_signal', 'sell_signal'
        """
        # Reset state
        self.__init__(self.gann_days, self.sig_expir, self.max_array_size)
    
        # Prepare result dataframe
        result = data.copy()
        result['buy_signal'] = np.nan
        result['sell_signal'] = np.nan
    
        # Process each bar
        for i in range(len(data)):
            buy_signal, sell_signal = self.process_bar(
                data['high'].iloc,
                data['low'].iloc,
                data['high'],
                data['low'],
                i
            )
        
            if buy_signal is not None:
                result.loc[result.index, 'buy_signal'] = buy_signal
                self.buy_signals.append((result.index, buy_signal))
            
            if sell_signal is not None:
                result.loc[result.index, 'sell_signal'] = sell_signal
                self.sell_signals.append((result.index, sell_signal))
            
        return result

    def plot_signals(self, data: pd.DataFrame, result: pd.DataFrame,
                    figsize: Tuple[int, int] = (15, 8)):
        """
        Plot the price data with buy and sell signals
        """
        fig, ax = plt.subplots(figsize=figsize)
    
        # Plot candlestick chart (simplified)
        for idx in range(len(data)):
            high = data['high'].iloc[idx]
            low = data['low'].iloc[idx]
        
            # Plot high-low bars
            ax.plot([idx, idx], [low, high], 'k-', linewidth=0.5)
        
            # Add open/close if available
            if 'open' in data.columns and 'close' in data.columns:
                open_price = data['open'].iloc[idx]
                close_price = data['close'].iloc[idx]
                color = 'g' if close_price > open_price else 'r'
                ax.plot([idx-0.3, idx+0.3], [open_price, open_price], color, linewidth=1)
                ax.plot([idx-0.3, idx+0.3], [close_price, close_price], color, linewidth=1)
    
        # Plot buy signals
        buy_x = []
        buy_y = []
        for idx, signal in enumerate(result['buy_signal']):
            if not pd.isna(signal):
                buy_x.append(idx)
                buy_y.append(signal)
            
        ax.scatter(buy_x, buy_y, color='green', marker='^', s=100,
                  label='Buy Signal', zorder=5)
    
        # Plot sell signals
        sell_x = []
        sell_y = []
        for idx, signal in enumerate(result['sell_signal']):
            if not pd.isna(signal):
                sell_x.append(idx)
                sell_y.append(signal)
            
        ax.scatter(sell_x, sell_y, color='red', marker='v', s=100,
                  label='Sell Signal', zorder=5)
    
        # Mark pivot points
        for pivot in self.pivot_highs[-20:]:  # Show last 20 pivot highs
            if pivot.bar < len(data):
                ax.plot(pivot.bar-1, pivot.price, 'b.', markersize=8)
            
        for pivot in self.pivot_lows[-20:]:  # Show last 20 pivot lows
            if pivot.bar < len(data):
                ax.plot(pivot.bar-1, pivot.price, 'r.', markersize=8)
    
        ax.set_xlabel('Bar Number')
        ax.set_ylabel('Price')
        ax.set_title(f'Gann Pivot Indicator (GannDays={self.gann_days}, SigExpir={self.sig_expir})')
        ax.legend()
        ax.grid(True, alpha=0.3)
    
        plt.tight_layout()
        plt.show()
    
    def get_pivot_statistics(self) -> dict:
        """
        Get statistics about the pivots and signals generated
        """
        return {
            'total_pivot_highs': len(self.pivot_highs),
            'total_pivot_lows': len(self.pivot_lows),
            'total_buy_signals': len(self.buy_signals),
            'total_sell_signals': len(self.sell_signals),
            'market_high': self.market_high,
            'market_low': self.market_low
        }


# Example usage
if __name__ == "__main__":
    # Create sample data
    np.random.seed(42)
    dates = pd.date_range('2023-01-01', periods=500, freq='D')

    # Generate synthetic price data
    trend = np.cumsum(np.random.randn(500) * 0.5)
    noise = np.random.randn(500) * 2
    base_price = 100 + trend + noise

    data = pd.DataFrame({
        'date': dates,
        'open': base_price + np.random.randn(500) * 0.5,
        'high': base_price + np.abs(np.random.randn(500)) * 1.5,
        'low': base_price - np.abs(np.random.randn(500)) * 1.5,
        'close': base_price + np.random.randn(500) * 0.3
    })

    # Ensure high is highest and low is lowest
    data['high'] = data[['open', 'high', 'close']].max(axis=1)
    data['low'] = data[['open', 'low', 'close']].min(axis=1)

    # Initialize and run the indicator
    indicator = GannPivotIndicator(gann_days=4, sig_expir=50)
    result = indicator.analyze(data)

    # Plot results
    indicator.plot_signals(data, result)

    # Print statistics
    stats = indicator.get_pivot_statistics()
    print("\nGann Pivot Indicator Statistics:")
    for key, value in stats.items():
        print(f"{key}: {value}")

    # Show signals
    print("\nBuy Signals:")
    for date, price in indicator.buy_signals[:5]:  # Show first 5
        print(f"  {date}: ${price:.2f}")
    
    print("\nSell Signals:")
    for date, price in indicator.sell_signals[:5]:  # Show first 5
        print(f"  {date}: ${price:.2f}")
W.D. Gann's Swing Trading Methods
Historical Background

W.D. Gann originally developed a 3-day swing chart method documented in his June 1933 course "The Mechanical Method And Trend Indicator For Trading Grains." However, in early 1955 prior to his death, Gann made handwritten alterations noting: "Use two-day charts and rules better than three day," with his signature.

Core Principles of Gann Swing Charts

1. Three-Day Swing Chart Rules (Original Method)
The trend line has to move in 3 up days consecutively, to qualify for an uptrend. Gann Rules for Swing Trading - Bramesh's Technical Analysis +2 The basic rules are:

Upswing: A correction in an uptrend, leading to a swing low, needs at least 3 consecutive days of lower lows Gann Swing Trading | Trade2Win

Downswing: Three consecutive days of higher highs are needed to form a swing high in a downtrend

According to W.D. Gann, 3 consecutive down candles must occur before the line "swings" to the bottom of the 3rd down candle

2. Two-Day Swing Chart Rules (Revised Method)

The swing direction can change to up only if the market makes two consecutive higher highs, and the swing direction can change to down only if the market makes two consecutive lower lows. This method is more responsive to market changes.

3. One-Day Swing Charts

While less common, 1-day swing charts follow similar principles but react to every new high or low, making them extremely sensitive to price movements.

Key Swing Trading Rules

Bar Types and Classifications

Up Day: This occurs when the asset's price reaches a higher high and a higher low than the previous day Down Day: A down day is when the asset's price forms a lower high and a lower low compared to the prior day Inside Day: This is when the asset's price shows a lower high and a higher low than the previous day Outside Day: An outside day occurs when the asset's price breaks the range of the previous day by forming both a higher high and a lower low Gann Swing Charts | FXTM

Trading Applications

Trend Identification

Uptrend: Trend Change from Down to Up. Prices must take out the nearest peak, and the trend was previously down

Downtrend: Trend Change from Up to Down. Prices must take out the nearest valley and the trend was previously up

Support and Resistance

Support: Support Is the Valley of the Previous Clearly Defined Swing

Resistance: Resistance Is the Peak of the Previous Clearly Defined Swing

Modified Modern Approach

Some traders have modified the traditional Gann 3 period swing chart by relaxing the requirement for there to be 3 "consecutive" days in order for a Gann swing to be formed, using instead "3 lower lows (without there being a new higher high in-between)."

Practical Trading Rules

According to Gann Rules for Swing Trading Gann Rules for Swing Trading - Bramesh's Technical Analysis:

If a high price of any week is achieved on Friday, then expect higher prices in the next week Gann Rules for Swing Trading - Bramesh's Technical Analysis

If the low price of the week is achieved on Friday, it indicates lower price next week Gann Rules for Swing Trading - Bramesh's Technical Analysis

In a highly up trending market, weekly lows are generally achieved on Tuesday Gann Rules for Swing Trading - Bramesh's Technical Analysis

If a price crosses the high of the last 3 days at least by 0.5% of Stock Value, it is a buy signal on the fourth day Gann Rules for Swing Trading - Bramesh's Technical Analysis

If the low of the last 3 days is broken by 0.5% of Stock Value then it is a sell signal on the fourth day Gann Rules for Swing Trading - Bramesh's Technical Analysis

Key Benefits

The main goal of using Gann's charts is to remove the "noise" from the price charts, which is not only unnecessary but also obscures the interpretation of the price action FXTM Chartalert

The choice between 1, 2, or 3-day swing charts depends on your trading style:

1-day: Most sensitive, suitable for very short-term trading

2-day: Gann's preferred method later in life, good balance

3-day: Original method, filters out more noise, better for position trading
More...
but there is this -
Alexander Elder, in his book Trading for a Living, said Gann could not support his family by trading but earned his living by writing and selling instructional courses. Larry Williams stated that Gann was just a good promoter, not necessarily a good stock trader.

of the 10 rooms of gann in their name + the other 12 that claim trade his style none actually have a track record or actually trade

MarkBrown · Aug 4, 2025 at 3:55 PM

mason macgregorson said:
but there is this -
Alexander Elder, in his book Trading for a Living, said Gann could not support his family by trading but earned his living by writing and selling instructional courses. Larry Williams stated that Gann was just a good promoter, not necessarily a good stock trader.

of the 10 rooms of gann in their name + the other 12 that claim trade his style none actually have a track record or actually trade
More...

1 does and he is the best commodity trader in the world .. so that's why i don't dismiss Gann.

also if we judge brilliance by the amount of money you have then where would Einstein rank ?

larry williams and alex elder should not be a benchmark for traders.

danielc1 · Aug 4, 2025 at 4:20 PM

MarkBrown said:
1 does and he is the best commodity trader in the world .. so that's why i don't dismiss Gann.

also if we judge brilliance by the amount of money you have then where would Einstein rank ?

larry williams and alex elder should not be a benchmark for traders.
More...

I know for a fact that the method of Gann works. But I also know that there is more then a working method necessary for a wealthy life. Basic habits make or brake the end results. Livermore is a perfect example of this. Great trader, great wealth, poor life, tragic death. Doesn't mean his methods of trading where no good... same with other trader examples. Everyone will write their own story.

Log in or Sign up

The Gann Pivot Indicator: A Deep Dive into the Trading Philosophy and Mechanics

LW_Millions

danielc1

mason macgregorson

MarkBrown

danielc1