9 posts tagged with "technical-analysis"

import pandas as pd
import numpy as np

def calculate_sma(data, period):
    return data['Close'].rolling(window=period).mean()

# Ví dụ sử dụng
# df['SMA20'] = calculate_sma(df, 20)
# df['SMA50'] = calculate_sma(df, 50)

def calculate_ema(data, period):
    return data['Close'].ewm(span=period, adjust=False).mean()

# Ví dụ sử dụng
# df['EMA20'] = calculate_ema(df, 20)
# df['EMA50'] = calculate_ema(df, 50)

def moving_average_crossover_strategy(data, short_period=20, long_period=50):
    # Tính đường trung bình
    data['SMA_short'] = calculate_sma(data, short_period)
    data['SMA_long'] = calculate_sma(data, long_period)
    
    # Tạo tín hiệu
    data['Signal'] = 0
    data['Signal'][data['SMA_short'] > data['SMA_long']] = 1  # Tín hiệu mua
    data['Signal'][data['SMA_short'] < data['SMA_long']] = -1  # Tín hiệu bán
    
    return data

def breakout_strategy(data, period=20, threshold=0.02):
    # Tính giá trị cao nhất và thấp nhất trong kỳ
    data['High_period'] = data['High'].rolling(window=period).max()
    data['Low_period'] = data['Low'].rolling(window=period).min()
    
    # Tạo tín hiệu
    data['Signal'] = 0
    
    # Tín hiệu mua khi giá đóng cửa vượt qua đỉnh cũ
    data.loc[data['Close'] > data['High_period'].shift(1) * (1 + threshold), 'Signal'] = 1
    
    # Tín hiệu bán khi giá đóng cửa dưới đáy cũ
    data.loc[data['Close'] < data['Low_period'].shift(1) * (1 - threshold), 'Signal'] = -1
    
    return data

def adx_ema_strategy(data, adx_period=14, ema_period=20, adx_threshold=25):
    # Tính ADX và EMA
    data['ADX'], data['Plus_DI'], data['Minus_DI'] = calculate_adx(
        data['High'], data['Low'], data['Close'], adx_period
    )
    data['EMA'] = calculate_ema(data, ema_period)
    
    # Tạo tín hiệu
    data['Signal'] = 0
    
    # Tín hiệu mua khi ADX > ngưỡng và +DI > -DI (hoặc giá > EMA)
    data.loc[
        (data['ADX'] > adx_threshold) & 
        (data['Plus_DI'] > data['Minus_DI']), 
        'Signal'
    ] = 1
    # Có thể thay thế bằng (data['ADX'] > adx_threshold) & (data['Close'] > data['EMA'])
    
    # Tín hiệu bán khi ADX > ngưỡng và -DI > +DI (hoặc giá < EMA)
    data.loc[
        (data['ADX'] > adx_threshold) & 
        (data['Minus_DI'] > data['Plus_DI']), 
        'Signal'
    ] = -1
    # Có thể thay thế bằng (data['ADX'] > adx_threshold) & (data['Close'] < data['EMA'])
    
    return data

def calculate_stop_loss(data, atr_period=14, multiplier=2):
    # Tính ATR (Average True Range)
    tr1 = data['High'] - data['Low']
    tr2 = abs(data['High'] - data['Close'].shift(1))
    tr3 = abs(data['Low'] - data['Close'].shift(1))
    tr = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
    atr = tr.rolling(window=atr_period).mean()
    
    # Tính điểm dừng lỗ
    data['Stop_Loss_Long'] = data['Close'] - (atr * multiplier)
    data['Stop_Loss_Short'] = data['Close'] + (atr * multiplier)
    
    return data

def position_sizing(account_size, risk_per_trade, stop_loss_distance):
    """
    Tính kích thước vị thế dựa trên rủi ro
    
    Parameters:
    account_size: Tổng vốn tài khoản
    risk_per_trade: Tỷ lệ rủi ro cho mỗi giao dịch (ví dụ: 0.02 = 2%)
    stop_loss_distance: Khoảng cách đến điểm dừng lỗ
    
    Returns:
    position_size: Kích thước vị thế
    """
    risk_amount = account_size * risk_per_trade
    position_size = risk_amount / stop_loss_distance
    
    return position_size

def backtest_strategy(data, initial_capital=100000):
    # Tạo DataFrame kết quả
    portfolio = pd.DataFrame(index=data.index)
    portfolio['Position'] = data['Signal']
    portfolio['Close'] = data['Close']
    
    # Tính lợi nhuận
    portfolio['Returns'] = portfolio['Close'].pct_change()
    portfolio['Strategy_Returns'] = portfolio['Position'].shift(1) * portfolio['Returns']
    
    # Tính giá trị danh mục
    portfolio['Cumulative_Returns'] = (1 + portfolio['Strategy_Returns']).cumprod()
    portfolio['Portfolio_Value'] = portfolio['Cumulative_Returns'] * initial_capital
    
    # Tính các chỉ số hiệu suất
    total_return = portfolio['Cumulative_Returns'].iloc[-1] - 1
    annual_return = (1 + total_return) ** (252 / len(portfolio)) - 1 # Giả sử 252 ngày giao dịch trong năm
    annual_volatility = portfolio['Strategy_Returns'].std() * np.sqrt(252)
    sharpe_ratio = annual_return / annual_volatility if annual_volatility != 0 else 0
    
    # Tính drawdown
    portfolio['Drawdown'] = 1 - portfolio['Cumulative_Returns'] / portfolio['Cumulative_Returns'].cummax()
    max_drawdown = portfolio['Drawdown'].max()
    
    performance = {
        'Total Return': total_return,
        'Annual Return': annual_return,
        'Annual Volatility': annual_volatility,
        'Sharpe Ratio': sharpe_ratio,
        'Max Drawdown': max_drawdown
    }
    
    return portfolio, performance

def optimize_parameters(data, param_grid):
    """
    Tối ưu hóa tham số chiến lược
    
    Parameters:
    data: DataFrame chứa dữ liệu giá
    param_grid: Dictionary chứa các tham số cần tối ưu (ví dụ: {'short_period': [10, 20], 'long_period': [50, 100]})
    
    Returns:
    best_params: Tham số tốt nhất
    best_performance: Hiệu suất tốt nhất
    """
    best_sharpe = -np.inf
    best_params = None
    best_performance = None
    
    # Sử dụng itertools.product để tạo tất cả các kết hợp tham số
    import itertools
    param_combinations = list(itertools.product(*param_grid.values()))
    
    for combo in param_combinations:
        params = dict(zip(param_grid.keys(), combo))
        
        # Chạy chiến lược với tham số hiện tại (ví dụ cho moving average crossover)
        # Bạn cần điều chỉnh phần này tùy thuộc vào chiến lược cụ thể
        try:
            strategy_data = moving_average_crossover_strategy(
                data.copy(), # Sử dụng copy để tránh sửa đổi DataFrame gốc
                short_period=params.get('short_period', 20), # Default values if not in param_grid
                long_period=params.get('long_period', 50)
            )
            
            # Backtest
            portfolio, performance = backtest_strategy(strategy_data)
            
            # Cập nhật tham số tốt nhất
            if performance['Sharpe Ratio'] > best_sharpe:
                best_sharpe = performance['Sharpe Ratio']
                best_params = params
                best_performance = performance
        except Exception as e:
            print(f"Error with params {params}: {e}")
            continue
        
    return best_params, best_performance

import pandas as pd
import numpy as np
import yfinance as yf
import matplotlib.pyplot as plt

def calculate_ichimoku(df, tenkan_period=9, kijun_period=26, senkou_span_b_period=52, displacement=26):
    # Tenkan-sen (Conversion Line)
    tenkan_sen_high = df['High'].rolling(window=tenkan_period).max()
    tenkan_sen_low = df['Low'].rolling(window=tenkan_period).min()
    df['tenkan_sen'] = (tenkan_sen_high + tenkan_sen_low) / 2

    # Kijun-sen (Base Line)
    kijun_sen_high = df['High'].rolling(window=kijun_period).max()
    kijun_sen_low = df['Low'].rolling(window=kijun_period).min()
    df['kijun_sen'] = (kijun_sen_high + kijun_sen_low) / 2

    # Senkou Span A (Leading Span A)
    df['senkou_span_a'] = ((df['tenkan_sen'] + df['kijun_sen']) / 2).shift(displacement)

    # Senkou Span B (Leading Span B)
    senkou_span_b_high = df['High'].rolling(window=senkou_span_b_period).max()
    senkou_span_b_low = df['Low'].rolling(window=senkou_span_b_period).min()
    df['senkou_span_b'] = ((senkou_span_b_high + senkou_span_b_low) / 2).shift(displacement)

    # Chikou Span (Lagging Span)
    df['chikou_span'] = df['Close'].shift(-displacement)

    return df

def generate_signals(df):
    signals = pd.DataFrame(index=df.index)
    signals['signal'] = 0

    # Kumo Breakout Strategy
    signals['kumo_breakout'] = 0
    signals.loc[df['Close'] > df[['senkou_span_a', 'senkou_span_b']].max(axis=1), 'kumo_breakout'] = 1
    signals.loc[df['Close'] < df[['senkou_span_a', 'senkou_span_b']].min(axis=1), 'kumo_breakout'] = -1

    # TK Cross Strategy
    signals['tk_cross'] = 0
    signals.loc[df['tenkan_sen'] > df['kijun_sen'], 'tk_cross'] = 1
    signals.loc[df['tenkan_sen'] < df['kijun_sen'], 'tk_cross'] = -1

    # Combined Strategy
    signals['signal'] = signals['kumo_breakout'] + signals['tk_cross']
    signals['signal'] = signals['signal'].apply(lambda x: 1 if x > 0 else (-1 if x < 0 else 0))

    return signals

def backtest_strategy(df, signals):
    # Calculate returns
    df['returns'] = df['Close'].pct_change()
    df['strategy_returns'] = df['returns'] * signals['signal'].shift(1)
    
    # Calculate cumulative returns
    df['cumulative_returns'] = (1 + df['returns']).cumprod()
    df['strategy_cumulative_returns'] = (1 + df['strategy_returns']).cumprod()
    
    return df

# Download data
symbol = 'AAPL'
df = yf.download(symbol, start='2020-01-01', end='2023-12-31')

# Calculate Ichimoku
df = calculate_ichimoku(df)

# Generate signals
signals = generate_signals(df)

# Backtest
results = backtest_strategy(df, signals)

# Plot results
plt.figure(figsize=(15, 10))
plt.plot(results.index, results['cumulative_returns'], label='Buy and Hold')
plt.plot(results.index, results['strategy_cumulative_returns'], label='Ichimoku Strategy')
plt.title(f'Ichimoku Cloud Strategy - {symbol}')
plt.legend()
plt.show()

class DoubleTopBottom:
    def __init__(self, window=20, threshold=0.02):
        self.window = window
        self.threshold = threshold
    
    def identify(self, df):
        # Tìm các đỉnh và đáy
        peaks = df['high'].rolling(window=self.window, center=True).max()
        troughs = df['low'].rolling(window=self.window, center=True).min()
        
        # Xác định Double Top
        double_top = (
            (abs(peaks.shift(1) - peaks) / peaks.shift(1) < self.threshold) &  # Hai đỉnh gần bằng nhau
            (df['close'] < peaks.shift(1)) &  # Giá đóng cửa dưới đỉnh
            (df['volume'] > df['volume'].rolling(window=20).mean())  # Khối lượng tăng
        )
        
        # Xác định Double Bottom
        double_bottom = (
            (abs(troughs.shift(1) - troughs) / troughs.shift(1) < self.threshold) &  # Hai đáy gần bằng nhau
            (df['close'] > troughs.shift(1)) &  # Giá đóng cửa trên đáy
            (df['volume'] > df['volume'].rolling(window=20).mean())  # Khối lượng tăng
        )
        
        return pd.DataFrame({
            'Double_Top': double_top,
            'Double_Bottom': double_bottom
        })

class HeadAndShoulders:
    def __init__(self, window=20, threshold=0.02):
        self.window = window
        self.threshold = threshold
    
    def identify(self, df):
        # Tìm các đỉnh
        peaks = df['high'].rolling(window=self.window, center=True).max()
        
        # Xác định mô hình Head and Shoulders
        left_shoulder = peaks.shift(2)
        head = peaks.shift(1)
        right_shoulder = peaks
        
        # Kiểm tra điều kiện
        pattern = (
            (abs(left_shoulder - right_shoulder) / left_shoulder < self.threshold) &  # Hai vai cân đối
            (head > left_shoulder) &  # Đỉnh đầu cao hơn vai
            (head > right_shoulder) &  # Đỉnh đầu cao hơn vai
            (df['close'] < right_shoulder) &  # Giá đóng cửa dưới vai phải
            (df['volume'] > df['volume'].rolling(window=20).mean())  # Khối lượng tăng
        )
        
        return pattern

class RSIDivergence:
    def __init__(self, period=14, lookback=10):
        self.period = period
        self.lookback = lookback
    
    def identify(self, df):
        # Tính toán RSI
        rsi = self.calculate_rsi(df)
        
        # Tìm các đỉnh và đáy của giá và RSI
        price_peaks = df['high'].rolling(window=self.lookback, center=True).max()
        price_troughs = df['low'].rolling(window=self.lookback, center=True).min()
        rsi_peaks = rsi.rolling(window=self.lookback, center=True).max()
        rsi_troughs = rsi.rolling(window=self.lookback, center=True).min()
        
        # Xác định phân kỳ
        bearish_divergence = (
            (price_peaks > price_peaks.shift(1)) &  # Giá tạo đỉnh cao hơn
            (rsi_peaks < rsi_peaks.shift(1))  # RSI tạo đỉnh thấp hơn
        )
        
        bullish_divergence = (
            (price_troughs < price_troughs.shift(1)) &  # Giá tạo đáy thấp hơn
            (rsi_troughs > rsi_troughs.shift(1))  # RSI tạo đáy cao hơn
        )
        
        return pd.DataFrame({
            'Bearish_Divergence': bearish_divergence,
            'Bullish_Divergence': bullish_divergence
        })
    
    def calculate_rsi(self, df):
        delta = df['close'].diff()
        gain = (delta.where(delta > 0, 0)).rolling(window=self.period).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(window=self.period).mean()
        rs = gain / loss
        return 100 - (100 / (1 + rs))

class MACDDivergence:
    def __init__(self, fast_period=12, slow_period=26, signal_period=9, lookback=10):
        self.fast_period = fast_period
        self.slow_period = slow_period
        self.signal_period = signal_period
        self.lookback = lookback
    
    def identify(self, df):
        # Tính toán MACD
        macd = self.calculate_macd(df)
        
        # Tìm các đỉnh và đáy của giá và MACD
        price_peaks = df['high'].rolling(window=self.lookback, center=True).max()
        price_troughs = df['low'].rolling(window=self.lookback, center=True).min()
        macd_peaks = macd['MACD'].rolling(window=self.lookback, center=True).max()
        macd_troughs = macd['MACD'].rolling(window=self.lookback, center=True).min()
        
        # Xác định phân kỳ
        bearish_divergence = (
            (price_peaks > price_peaks.shift(1)) &  # Giá tạo đỉnh cao hơn
            (macd_peaks < macd_peaks.shift(1))  # MACD tạo đỉnh thấp hơn
        )
        
        bullish_divergence = (
            (price_troughs < price_troughs.shift(1)) &  # Giá tạo đáy thấp hơn
            (macd_troughs > macd_troughs.shift(1))  # MACD tạo đáy cao hơn
        )
        
        return pd.DataFrame({
            'Bearish_Divergence': bearish_divergence,
            'Bullish_Divergence': bullish_divergence
        })
    
    def calculate_macd(self, df):
        exp1 = df['close'].ewm(span=self.fast_period, adjust=False).mean()
        exp2 = df['close'].ewm(span=self.slow_period, adjust=False).mean()
        macd = exp1 - exp2
        signal = macd.ewm(span=self.signal_period, adjust=False).mean()
        histogram = macd - signal
        
        return pd.DataFrame({
            'MACD': macd,
            'Signal': signal,
            'Histogram': histogram
        })

class RSIStrategy:
    def __init__(self, period=14, overbought=70, oversold=30):
        self.period = period
        self.overbought = overbought
        self.oversold = oversold
    
    def identify_signals(self, df):
        # Tính toán RSI
        rsi = self.calculate_rsi(df)
        
        # Xác định tín hiệu
        sell_signal = (
            (rsi > self.overbought) &  # RSI quá mua
            (rsi.shift(1) <= self.overbought)  # RSI vừa vượt ngưỡng quá mua
        )
        
        buy_signal = (
            (rsi < self.oversold) &  # RSI quá bán
            (rsi.shift(1) >= self.oversold)  # RSI vừa vượt ngưỡng quá bán
        )
        
        return pd.DataFrame({
            'Sell_Signal': sell_signal,
            'Buy_Signal': buy_signal
        })
    
    def calculate_rsi(self, df):
        delta = df['close'].diff()
        gain = (delta.where(delta > 0, 0)).rolling(window=self.period).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(window=self.period).mean()
        rs = gain / loss
        return 100 - (100 / (1 + rs))

class StochasticStrategy:
    def __init__(self, k_period=14, d_period=3, overbought=80, oversold=20):
        self.k_period = k_period
        self.d_period = d_period
        self.overbought = overbought
        self.oversold = oversold
    
    def identify_signals(self, df):
        # Tính toán Stochastic
        k, d = self.calculate_stochastic(df)
        
        # Xác định tín hiệu
        sell_signal = (
            (k > self.overbought) &  # %K quá mua
            (d > self.overbought) &  # %D quá mua
            (k < d) &  # %K cắt xuống %D
            (k.shift(1) >= d.shift(1))  # Xác nhận cắt
        )
        
        buy_signal = (
            (k < self.oversold) &  # %K quá bán
            (d < self.oversold) &  # %D quá bán
            (k > d) &  # %K cắt lên %D
            (k.shift(1) <= d.shift(1))  # Xác nhận cắt
        )
        
        return pd.DataFrame({
            'Sell_Signal': sell_signal,
            'Buy_Signal': buy_signal
        })
    
    def calculate_stochastic(self, df):
        low_min = df['low'].rolling(window=self.k_period).min()
        high_max = df['high'].rolling(window=self.k_period).max()
        
        k = 100 * ((df['close'] - low_min) / (high_max - low_min))
        d = k.rolling(window=self.d_period).mean()
        
        return k, d

class VolumeConfirmation:
    def __init__(self, volume_ma_period=20, volume_threshold=1.5):
        self.volume_ma_period = volume_ma_period
        self.volume_threshold = volume_threshold
    
    def confirm(self, df, signal):
        # Tính toán trung bình khối lượng
        volume_ma = df['volume'].rolling(window=self.volume_ma_period).mean()
        
        # Xác nhận tín hiệu với khối lượng
        confirmed_signal = (
            signal &  # Có tín hiệu
            (df['volume'] > volume_ma * self.volume_threshold)  # Khối lượng tăng mạnh
        )
        
        return confirmed_signal

class MultiTimeframeConfirmation:
    def __init__(self, higher_tf_period=4):
        self.higher_tf_period = higher_tf_period
    
    def confirm(self, df, signal):
        # Tính toán giá trung bình cho khung thời gian cao hơn
        higher_tf_close = df['close'].rolling(window=self.higher_tf_period).mean()
        
        # Xác nhận tín hiệu với khung thời gian cao hơn
        confirmed_signal = (
            signal &  # Có tín hiệu
            (df['close'] > higher_tf_close)  # Giá trên trung bình khung cao hơn
        )
        
        return confirmed_signal

class DojiPattern:
    def __init__(self, body_threshold=0.1):
        self.body_threshold = body_threshold
    
    def identify(self, df):
        # Tính toán thân nến
        body = abs(df['close'] - df['open'])
        total_range = df['high'] - df['low']
        
        # Xác định Doji
        doji = (body / total_range) < self.body_threshold
        
        return doji

class HammerPattern:
    def __init__(self, body_threshold=0.3, shadow_threshold=2.0):
        self.body_threshold = body_threshold
        self.shadow_threshold = shadow_threshold
    
    def identify(self, df):
        # Tính toán các thành phần
        body = abs(df['close'] - df['open'])
        upper_shadow = df['high'] - df[['open', 'close']].max(axis=1)
        lower_shadow = df[['open', 'close']].min(axis=1) - df['low']
        total_range = df['high'] - df['low']
        
        # Xác định Hammer
        hammer = (
            (body / total_range) < self.body_threshold &
            (lower_shadow / body) > self.shadow_threshold &
            (upper_shadow / body) < 0.1
        )
        
        return hammer

class EngulfingPattern:
    def identify(self, df):
        # Xác định mô hình Engulfing
        bullish_engulfing = (
            (df['close'].shift(1) < df['open'].shift(1)) &  # Nến trước là nến giảm
            (df['close'] > df['open']) &  # Nến hiện tại là nến tăng
            (df['open'] < df['close'].shift(1)) &  # Mở cửa thấp hơn đóng cửa nến trước
            (df['close'] > df['open'].shift(1))  # Đóng cửa cao hơn mở cửa nến trước
        )
        
        bearish_engulfing = (
            (df['close'].shift(1) > df['open'].shift(1)) &  # Nến trước là nến tăng
            (df['close'] < df['open']) &  # Nến hiện tại là nến giảm
            (df['open'] > df['close'].shift(1)) &  # Mở cửa cao hơn đóng cửa nến trước
            (df['close'] < df['open'].shift(1))  # Đóng cửa thấp hơn mở cửa nến trước
        )
        
        return pd.DataFrame({
            'Bullish_Engulfing': bullish_engulfing,
            'Bearish_Engulfing': bearish_engulfing
        })

class HaramiPattern:
    def identify(self, df):
        # Xác định mô hình Harami
        bullish_harami = (
            (df['close'].shift(1) < df['open'].shift(1)) &  # Nến trước là nến giảm
            (df['close'] > df['open']) &  # Nến hiện tại là nến tăng
            (df['open'] > df['close'].shift(1)) &  # Mở cửa cao hơn đóng cửa nến trước
            (df['close'] < df['open'].shift(1))  # Đóng cửa thấp hơn mở cửa nến trước
        )
        
        bearish_harami = (
            (df['close'].shift(1) > df['open'].shift(1)) &  # Nến trước là nến tăng
            (df['close'] < df['open']) &  # Nến hiện tại là nến giảm
            (df['open'] < df['close'].shift(1)) &  # Mở cửa thấp hơn đóng cửa nến trước
            (df['close'] > df['open'].shift(1))  # Đóng cửa cao hơn mở cửa nến trước
        )
        
        return pd.DataFrame({
            'Bullish_Harami': bullish_harami,
            'Bearish_Harami': bearish_harami
        })

class MorningStarPattern:
    def identify(self, df):
        # Xác định mô hình Morning Star
        morning_star = (
            (df['close'].shift(2) < df['open'].shift(2)) &  # Nến đầu tiên là nến giảm
            (abs(df['close'].shift(1) - df['open'].shift(1)) < 
             0.1 * (df['high'].shift(1) - df['low'].shift(1))) &  # Nến thứ hai là Doji
            (df['close'] > df['open']) &  # Nến thứ ba là nến tăng
            (df['close'] > (df['open'].shift(2) + df['close'].shift(2)) / 2)  # Đóng cửa nến thứ ba vượt qua điểm giữa nến đầu tiên
        )
        
        return morning_star

class EveningStarPattern:
    def identify(self, df):
        # Xác định mô hình Evening Star
        evening_star = (
            (df['close'].shift(2) > df['open'].shift(2)) &  # Nến đầu tiên là nến tăng
            (abs(df['close'].shift(1) - df['open'].shift(1)) < 
             0.1 * (df['high'].shift(1) - df['low'].shift(1))) &  # Nến thứ hai là Doji
            (df['close'] < df['open']) &  # Nến thứ ba là nến giảm
            (df['close'] < (df['open'].shift(2) + df['close'].shift(2)) / 2)  # Đóng cửa nến thứ ba dưới điểm giữa nến đầu tiên
        )
        
        return evening_star

class HeadAndShouldersPattern:
    def __init__(self, window=20, threshold=0.02):
        self.window = window
        self.threshold = threshold
    
    def identify(self, df):
        # Tìm các đỉnh
        peaks = df['high'].rolling(window=self.window, center=True).max()
        
        # Xác định mô hình Head and Shoulders
        left_shoulder = peaks.shift(2)
        head = peaks.shift(1)
        right_shoulder = peaks
        
        # Kiểm tra điều kiện
        pattern = (
            (abs(left_shoulder - right_shoulder) / left_shoulder < self.threshold) &  # Hai vai cân đối
            (head > left_shoulder) &  # Đỉnh đầu cao hơn vai
            (head > right_shoulder)  # Đỉnh đầu cao hơn vai
        )
        
        return pattern

class DoubleTopBottomPattern:
    def __init__(self, window=20, threshold=0.02):
        self.window = window
        self.threshold = threshold
    
    def identify(self, df):
        # Tìm các đỉnh và đáy
        peaks = df['high'].rolling(window=self.window, center=True).max()
        troughs = df['low'].rolling(window=self.window, center=True).min()
        
        # Xác định mô hình Double Top
        double_top = (
            (abs(peaks.shift(1) - peaks) / peaks.shift(1) < self.threshold) &  # Hai đỉnh gần bằng nhau
            (df['close'] < peaks.shift(1))  # Giá đóng cửa dưới đỉnh
        )
        
        # Xác định mô hình Double Bottom
        double_bottom = (
            (abs(troughs.shift(1) - troughs) / troughs.shift(1) < self.threshold) &  # Hai đáy gần bằng nhau
            (df['close'] > troughs.shift(1))  # Giá đóng cửa trên đáy
        )
        
        return pd.DataFrame({
            'Double_Top': double_top,
            'Double_Bottom': double_bottom
        })

class TrendIdentifier:
    def __init__(self, short_period=20, long_period=50):
        self.short_period = short_period
        self.long_period = long_period
    
    def identify_trend(self, df):
        # Tính toán các đường trung bình
        short_ma = df['close'].rolling(window=self.short_period).mean()
        long_ma = df['close'].rolling(window=self.long_period).mean()
        
        # Xác định xu hướng
        trend = pd.Series(index=df.index)
        trend[short_ma > long_ma] = 1  # Xu hướng tăng
        trend[short_ma < long_ma] = -1  # Xu hướng giảm
        trend[short_ma == long_ma] = 0  # Không có xu hướng rõ ràng
        
        return trend

class ADXIndicator:
    def __init__(self, period=14):
        self.period = period
    
    def calculate(self, df):
        # Tính toán True Range
        tr1 = df['high'] - df['low']
        tr2 = abs(df['high'] - df['close'].shift(1))
        tr3 = abs(df['low'] - df['close'].shift(1))
        tr = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
        
        # Tính toán Directional Movement
        up_move = df['high'] - df['high'].shift(1)
        down_move = df['low'].shift(1) - df['low']
        
        plus_dm = np.where((up_move > down_move) & (up_move > 0), up_move, 0)
        minus_dm = np.where((down_move > up_move) & (down_move > 0), down_move, 0)
        
        # Tính toán ADX
        tr_smoothed = tr.rolling(window=self.period).mean()
        plus_di = 100 * pd.Series(plus_dm).rolling(window=self.period).mean() / tr_smoothed
        minus_di = 100 * pd.Series(minus_dm).rolling(window=self.period).mean() / tr_smoothed
        
        dx = 100 * abs(plus_di - minus_di) / (plus_di + minus_di)
        adx = dx.rolling(window=self.period).mean()
        
        return pd.DataFrame({
            'ADX': adx,
            'Plus_DI': plus_di,
            'Minus_DI': minus_di
        })