Trend

Trend indicators help identify the direction and strength of market trends. All examples use real market data fetched via OpenAlgo API.

Data Setup

from openalgo import api, ta
import pandas as pd

# Initialize API client
client = api(api_key='your_api_key_here', host='http://127.0.0.1:5000')

# Fetch historical data
df = client.history(symbol="SBIN", 
                   exchange="NSE", 
                   interval="5m", 
                   start_date="2025-04-01", 
                   end_date="2025-04-08")

print(df.head())
#                            close    high     low    open  volume
# timestamp                                                        
# 2025-04-01 09:15:00+05:30  772.50  774.00  763.20  766.50  318625
# 2025-04-01 09:20:00+05:30  773.20  774.95  772.10  772.45  197189

Simple Moving Average (SMA)

Description: The most basic trend indicator, calculated by averaging closing prices over a specified period.

Parameters

data (array-like): Price data (typically closing prices)
period (int): Number of periods for the moving average

Returns

pandas.Series: SMA values with original index preserved

Usage Example

# Calculate 20-period SMA
df['SMA_20'] = ta.sma(df['close'], 20)

# Calculate multiple SMAs
df['SMA_10'] = ta.sma(df['close'], 10)
df['SMA_50'] = ta.sma(df['close'], 50)

print(df[['close', 'SMA_10', 'SMA_20', 'SMA_50']].tail())
#                            close   SMA_10   SMA_20   SMA_50
# timestamp                                                  
# 2025-04-08 14:00:00+05:30  768.25  770.12  771.45  773.28
# 2025-04-08 14:05:00+05:30  769.10  769.98  771.33  773.22

Exponential Moving Average (EMA)

Description: Gives more weight to recent prices, making it more responsive to new information than SMA.

Parameters

data (array-like): Price data (typically closing prices)
period (int): Number of periods for the moving average

Returns

pandas.Series: EMA values with original index preserved

Usage Example

# Calculate 20-period EMA
df['EMA_20'] = ta.ema(df['close'], 20)

# Compare with SMA
df['SMA_20'] = ta.sma(df['close'], 20)

# Plot comparison
import matplotlib.pyplot as plt
plt.figure(figsize=(12, 6))
plt.plot(df.index, df['close'], label='Close Price', alpha=0.7)
plt.plot(df.index, df['SMA_20'], label='SMA 20', alpha=0.8)
plt.plot(df.index, df['EMA_20'], label='EMA 20', alpha=0.8)
plt.legend()
plt.title('SBIN: Close Price vs Moving Averages')
plt.show()

Weighted Moving Average (WMA)

Description: Assigns greater weight to recent data points using a linear weighting scheme.

Parameters

data (array-like): Price data (typically closing prices)
period (int): Number of periods for the moving average

Returns

numpy.ndarray: WMA values

Usage Example

# Calculate 20-period WMA
df['WMA_20'] = ta.wma(df['close'], 20)

# Compare responsiveness of different MAs
df['MA_Comparison'] = df['close'] - df['SMA_20']
df['EMA_Comparison'] = df['close'] - df['EMA_20'] 
df['WMA_Comparison'] = df['close'] - df['WMA_20']

print(df[['MA_Comparison', 'EMA_Comparison', 'WMA_Comparison']].tail())

Hull Moving Average (HMA)

Description: Attempts to minimize lag while improving smoothing using weighted moving averages.

Parameters

data (array-like): Price data (typically closing prices)
period (int): Number of periods for the moving average

Returns

pandas.Series: HMA values with original index preserved

Usage Example

# Calculate 16-period HMA (common period for HMA)
df['HMA_16'] = ta.hma(df['close'], 16)

# Compare lag between different MAs
df['Price_Change'] = df['close'].pct_change()
df['HMA_Change'] = df['HMA_16'].pct_change()
df['EMA_Change'] = df['EMA_20'].pct_change()

# Calculate correlation to measure responsiveness
correlation_hma = df['Price_Change'].corr(df['HMA_Change'])
correlation_ema = df['Price_Change'].corr(df['EMA_Change'])
print(f"HMA Correlation: {correlation_hma:.4f}")
print(f"EMA Correlation: {correlation_ema:.4f}")

Volume Weighted Moving Average (VWMA)

Description: Gives more weight to periods with higher volume, making it more responsive to volume-driven price movements.

Parameters

data (array-like): Price data (typically closing prices)
volume (array-like): Volume data
period (int): Number of periods for the moving average

Returns

pandas.Series: VWMA values with original index preserved

Usage Example

# Calculate 20-period VWMA
df['VWMA_20'] = ta.vwma(df['close'], df['volume'], 20)

# Compare VWMA with regular SMA during high/low volume periods
df['Volume_MA'] = ta.sma(df['volume'], 20)
df['High_Volume'] = df['volume'] > df['Volume_MA']

# Analyze performance during high volume periods
high_vol_periods = df[df['High_Volume'] == True]
print("VWMA vs SMA during high volume periods:")
print(high_vol_periods[['close', 'SMA_20', 'VWMA_20', 'volume']].tail())

Kaufman's Adaptive Moving Average (KAMA)

Description: Adjusts its smoothing based on market volatility, becoming more responsive in trending markets and smoother in sideways markets.

Parameters

data (array-like): Price data (typically closing prices)
length (int, default=14): Period for efficiency ratio calculation
fast_length (int, default=2): Fast EMA length
slow_length (int, default=30): Slow EMA length

Returns

pandas.Series: KAMA values with original index preserved

Usage Example

# Calculate KAMA with default parameters
df['KAMA_14'] = ta.kama(df['close'])

# Calculate market efficiency ratio manually for analysis
def calculate_efficiency_ratio(prices, period):
    direction = abs(prices.iloc[-1] - prices.iloc[-period-1])
    volatility = abs(prices.diff()).rolling(period).sum().iloc[-1]
    return direction / volatility if volatility > 0 else 0

# Analyze KAMA adaptation
df['ER'] = df['close'].rolling(14).apply(lambda x: calculate_efficiency_ratio(x, 14))
df['KAMA_vs_Close'] = abs(df['KAMA_14'] - df['close'])

print("KAMA Efficiency and Adaptation:")
print(df[['close', 'KAMA_14', 'ER', 'KAMA_vs_Close']].tail(10))

Supertrend

Description: A trend-following indicator that uses ATR to calculate dynamic support and resistance levels.

Parameters

high (array-like): High prices
low (array-like): Low prices
close (array-like): Closing prices
period (int, default=10): ATR period
multiplier (float, default=3.0): ATR multiplier

Returns

tuple: (supertrend_values, direction_values) as pandas.Series
- direction: -1 for uptrend (green), 1 for downtrend (red)

Usage Example

# Calculate Supertrend with default parameters
df['Supertrend'], df['ST_Direction'] = ta.supertrend(df['high'], df['low'], df['close'])

# Calculate custom Supertrend for shorter timeframes
df['ST_Fast'], df['ST_Fast_Dir'] = ta.supertrend(df['high'], df['low'], df['close'], 
                                                period=7, multiplier=2.0)

# Identify trend changes
df['Trend_Change'] = df['ST_Direction'].diff() != 0

# Analyze trend statistics
uptrend_periods = len(df[df['ST_Direction'] == -1])
downtrend_periods = len(df[df['ST_Direction'] == 1])
trend_changes = df['Trend_Change'].sum()

print(f"Uptrend periods: {uptrend_periods}")
print(f"Downtrend periods: {downtrend_periods}")
print(f"Trend changes: {trend_changes}")

# Show recent Supertrend signals
print("\nRecent Supertrend Data:")
print(df[['close', 'Supertrend', 'ST_Direction']].tail())

Ichimoku Cloud

Description: A comprehensive indicator that defines support and resistance, identifies trend direction, and provides trading signals.

Parameters

high (array-like): High prices
low (array-like): Low prices
close (array-like): Closing prices
conversion_periods (int, default=9): Conversion Line Length
base_periods (int, default=26): Base Line Length
lagging_span2_periods (int, default=52): Leading Span B Length
displacement (int, default=26): Lagging Span displacement

Returns

tuple: (conversion_line, base_line, leading_span_a, leading_span_b, lagging_span) as pandas.Series

Usage Example

# Calculate Ichimoku Cloud components
(df['Ichimoku_Conversion'], 
 df['Ichimoku_Base'], 
 df['Ichimoku_SpanA'], 
 df['Ichimoku_SpanB'], 
 df['Ichimoku_Lagging']) = ta.ichimoku(df['high'], df['low'], df['close'])

# Analyze cloud signals
df['Cloud_Top'] = df[['Ichimoku_SpanA', 'Ichimoku_SpanB']].max(axis=1)
df['Cloud_Bottom'] = df[['Ichimoku_SpanA', 'Ichimoku_SpanB']].min(axis=1)
df['Above_Cloud'] = df['close'] > df['Cloud_Top']
df['Below_Cloud'] = df['close'] < df['Cloud_Bottom']
df['In_Cloud'] = ~(df['Above_Cloud'] | df['Below_Cloud'])

# TK Cross signals
df['TK_Bullish'] = (df['Ichimoku_Conversion'] > df['Ichimoku_Base']) & \
                   (df['Ichimoku_Conversion'].shift(1) <= df['Ichimoku_Base'].shift(1))
df['TK_Bearish'] = (df['Ichimoku_Conversion'] < df['Ichimoku_Base']) & \
                   (df['Ichimoku_Conversion'].shift(1) >= df['Ichimoku_Base'].shift(1))

print("Ichimoku Analysis:")
print(f"Periods above cloud: {df['Above_Cloud'].sum()}")
print(f"Periods below cloud: {df['Below_Cloud'].sum()}")
print(f"Periods in cloud: {df['In_Cloud'].sum()}")
print(f"TK Bullish signals: {df['TK_Bullish'].sum()}")
print(f"TK Bearish signals: {df['TK_Bearish'].sum()}")

Arnaud Legoux Moving Average (ALMA)

Description: Combines the features of SMA and EMA with a configurable phase and smoothing factor.

Parameters

data (array-like): Price data (typically closing prices)
period (int, default=21): Number of periods for the moving average
offset (float, default=0.85): Phase offset (0 to 1)
sigma (float, default=6.0): Smoothing factor

Returns

pandas.Series: ALMA values with original index preserved

Usage Example

# Calculate ALMA with different configurations
df['ALMA_Default'] = ta.alma(df['close'])  # Default: period=21, offset=0.85, sigma=6.0
df['ALMA_Fast'] = ta.alma(df['close'], period=14, offset=0.9, sigma=4.0)
df['ALMA_Smooth'] = ta.alma(df['close'], period=21, offset=0.5, sigma=8.0)

# Compare responsiveness
df['ALMA_vs_EMA'] = df['ALMA_Default'] - ta.ema(df['close'], 21)
print("ALMA vs EMA difference (last 10 periods):")
print(df['ALMA_vs_EMA'].tail(10))

Zero Lag Exponential Moving Average (ZLEMA)

Description: Attempts to eliminate lag by using price momentum in its calculation.

Parameters

data (array-like): Price data (typically closing prices)
period (int): Number of periods for the moving average

Returns

pandas.Series: ZLEMA values with original index preserved

Usage Example

# Calculate ZLEMA and compare with regular EMA
df['ZLEMA_20'] = ta.zlema(df['close'], 20)
df['EMA_20'] = ta.ema(df['close'], 20)

# Measure responsiveness to price changes
df['Price_Change'] = df['close'].diff()
df['ZLEMA_Change'] = df['ZLEMA_20'].diff()
df['EMA_Change'] = df['EMA_20'].diff()

# Calculate lead/lag relationship
correlation_zlema = df['Price_Change'].corr(df['ZLEMA_Change'])
correlation_ema = df['Price_Change'].corr(df['EMA_Change'])

print(f"ZLEMA responsiveness: {correlation_zlema:.4f}")
print(f"EMA responsiveness: {correlation_ema:.4f}")

Multiple Exponential Moving Average (DEMA & TEMA)

Description: DEMA and TEMA reduce lag by applying exponential smoothing multiple times.

Parameters

data (array-like): Price data (typically closing prices)
period (int): Number of periods for the moving average

Returns

pandas.Series: DEMA/TEMA values with original index preserved

Usage Example

# Calculate DEMA and TEMA
df['DEMA_20'] = ta.dema(df['close'], 20)
df['TEMA_20'] = ta.tema(df['close'], 20)
df['EMA_20'] = ta.ema(df['close'], 20)

# Compare lag characteristics
price_peaks = df['close'].rolling(5).max() == df['close']
df['Peak_Signals'] = price_peaks

# Analyze how quickly each MA responds to peaks
peak_periods = df[df['Peak_Signals']]
print("Response at price peaks:")
print(peak_periods[['close', 'EMA_20', 'DEMA_20', 'TEMA_20']].tail())

Complete Trading Analysis Example

from openalgo import api, ta
import pandas as pd
import matplotlib.pyplot as plt

# Fetch data
client = api(api_key='your_api_key_here', host='http://127.0.0.1:5000')
df = client.history(symbol="SBIN", exchange="NSE", interval="5m", 
                   start_date="2025-04-01", end_date="2025-04-08")

# Calculate multiple trend indicators
df['SMA_20'] = ta.sma(df['close'], 20)
df['EMA_20'] = ta.ema(df['close'], 20)
df['KAMA_14'] = ta.kama(df['close'])
df['Supertrend'], df['ST_Direction'] = ta.supertrend(df['high'], df['low'], df['close'])

# Calculate Ichimoku components
(df['Conversion'], df['Base'], df['SpanA'], 
 df['SpanB'], df['Lagging']) = ta.ichimoku(df['high'], df['low'], df['close'])

# Generate trading signals
df['MA_Bullish'] = (df['close'] > df['SMA_20']) & (df['EMA_20'] > df['SMA_20'])
df['ST_Bullish'] = df['ST_Direction'] == -1
df['Ichimoku_Bullish'] = (df['close'] > df[['SpanA', 'SpanB']].max(axis=1)) & \
                         (df['Conversion'] > df['Base'])

# Combined signal
df['Combined_Signal'] = (df['MA_Bullish'] & df['ST_Bullish'] & df['Ichimoku_Bullish']).astype(int)

# Performance analysis
signal_changes = df['Combined_Signal'].diff()
buy_signals = signal_changes == 1
sell_signals = signal_changes == -1

print(f"Buy signals: {buy_signals.sum()}")
print(f"Sell signals: {sell_signals.sum()}")

# Show recent analysis
print("\nRecent Trading Analysis:")
columns_to_show = ['close', 'SMA_20', 'EMA_20', 'Supertrend', 'ST_Direction', 'Combined_Signal']
print(df[columns_to_show].tail(10))

# Plot results
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(15, 10), sharex=True)

# Price and moving averages
ax1.plot(df.index, df['close'], label='Close', linewidth=1)
ax1.plot(df.index, df['SMA_20'], label='SMA 20', alpha=0.7)
ax1.plot(df.index, df['EMA_20'], label='EMA 20', alpha=0.7)
ax1.plot(df.index, df['Supertrend'], label='Supertrend', alpha=0.8)
ax1.legend()
ax1.set_title('SBIN Price and Trend Indicators')
ax1.grid(True, alpha=0.3)

# Signals
ax2.plot(df.index, df['Combined_Signal'], label='Combined Signal', linewidth=2)
ax2.fill_between(df.index, 0, df['Combined_Signal'], alpha=0.3)
ax2.set_ylabel('Signal')
ax2.set_xlabel('Time')
ax2.set_title('Combined Trading Signals')
ax2.grid(True, alpha=0.3)
ax2.legend()

plt.tight_layout()
plt.show()

This documentation demonstrates how to use OpenAlgo trend indicators with real market data fetched via the OpenAlgo API, maintaining pandas DataFrame structure throughout the analysis process.

PreviousIndicators NextMomentum

Last updated 4 months ago

Was this helpful?