tessl/pypi-ta
Technical Analysis Library in Python for financial time series datasets with 43 indicators across Volume, Volatility, Trend, Momentum, and Others categories
others-indicators.mddocs/
Others Indicators
Financial return calculation indicators that measure different aspects of price performance over time. These indicators help traders and analysts assess portfolio performance, risk metrics, and investment returns from various mathematical perspectives.
Capabilities
Daily Return (DR)
Calculates the simple percentage change in price from one period to the next, representing the daily performance as a percentage.
class DailyReturnIndicator:
def __init__(self, close, fillna=False):
"""
Daily Return (DR).
Parameters:
- close (Series): Dataset 'Close' column
- fillna (bool): If True, fill NaN values with 0 (default: False)
"""
def daily_return(self):
"""Returns: Series with daily return values (percentage)"""
def daily_return(close, fillna=False):
"""Functional interface for Daily Return"""Calculation: ((Price_t / Price_t-1) - 1) * 100
Use Cases:
- Portfolio performance measurement
- Risk analysis and volatility estimation
- Backtesting trading strategies
- Comparing performance across different assets
Daily Log Return (DLR)
Calculates the logarithmic return, which is more appropriate for continuous compounding and has better statistical properties for financial analysis.
class DailyLogReturnIndicator:
def __init__(self, close, fillna=False):
"""
Daily Log Return (DLR).
Parameters:
- close (Series): Dataset 'Close' column
- fillna (bool): If True, fill NaN values with 0 (default: False)
"""
def daily_log_return(self):
"""Returns: Series with daily log return values (percentage)"""
def daily_log_return(close, fillna=False):
"""Functional interface for Daily Log Return"""Calculation: ln(Price_t / Price_t-1) * 100
Use Cases:
- Statistical analysis of returns (normal distribution assumption)
- Risk modeling and Value at Risk (VaR) calculations
- Portfolio optimization
- Academic research and quantitative analysis
Advantages over Simple Returns:
- Time-additive (log returns can be summed over time)
- Better statistical properties for modeling
- Symmetric around zero
- More appropriate for continuous compounding
Cumulative Return (CR)
Measures the total return from the beginning of the period to the current point, showing overall performance relative to the starting value.
class CumulativeReturnIndicator:
def __init__(self, close, fillna=False):
"""
Cumulative Return (CR).
Parameters:
- close (Series): Dataset 'Close' column
- fillna (bool): If True, fill NaN values with -1 (default: False)
"""
def cumulative_return(self):
"""Returns: Series with cumulative return values (percentage)"""
def cumulative_return(close, fillna=False):
"""Functional interface for Cumulative Return"""Calculation: ((Price_t / Price_0) - 1) * 100
Use Cases:
- Long-term performance tracking
- Investment growth visualization
- Benchmark comparison
- Portfolio evaluation over entire holding periods
Usage Examples
Basic Return Calculations
from ta.others import *
import pandas as pd
def calculate_returns(df):
# Calculate all return types
df['Daily_Return'] = daily_return(df['Close'])
df['Log_Return'] = daily_log_return(df['Close'])
df['Cumulative_Return'] = cumulative_return(df['Close'])
return df
# Apply return calculations
df_returns = calculate_returns(df)Return Analysis Workflow
from ta.others import DailyReturnIndicator, DailyLogReturnIndicator, CumulativeReturnIndicator
# Create return indicators with class-based interface
daily_ret_indicator = DailyReturnIndicator(close=df['Close'], fillna=True)
log_ret_indicator = DailyLogReturnIndicator(close=df['Close'], fillna=True)
cum_ret_indicator = CumulativeReturnIndicator(close=df['Close'], fillna=True)
# Calculate return metrics
df['Daily_Return'] = daily_ret_indicator.daily_return()
df['Log_Return'] = log_ret_indicator.daily_log_return()
df['Cumulative_Return'] = cum_ret_indicator.cumulative_return()
# Calculate summary statistics
print(f"Average Daily Return: {df['Daily_Return'].mean():.4f}%")
print(f"Daily Return Volatility: {df['Daily_Return'].std():.4f}%")
print(f"Total Return: {df['Cumulative_Return'].iloc[-1]:.2f}%")Risk and Performance Analysis
import numpy as np
from ta.others import daily_return, daily_log_return, cumulative_return
def comprehensive_return_analysis(df, risk_free_rate=0.02):
# Calculate returns
df['Daily_Return'] = daily_return(df['Close'])
df['Log_Return'] = daily_log_return(df['Close'])
df['Cumulative_Return'] = cumulative_return(df['Close'])
# Performance metrics
total_return = df['Cumulative_Return'].iloc[-1]
avg_daily_return = df['Daily_Return'].mean()
volatility = df['Daily_Return'].std()
# Risk-adjusted metrics
annualized_return = avg_daily_return * 252 # Assuming 252 trading days
annualized_volatility = volatility * np.sqrt(252)
sharpe_ratio = (annualized_return - risk_free_rate) / annualized_volatility
# Downside metrics
negative_returns = df['Daily_Return'][df['Daily_Return'] < 0]
downside_deviation = negative_returns.std() * np.sqrt(252)
# Maximum drawdown
cumulative_max = (1 + df['Cumulative_Return'] / 100).cummax()
drawdown = (1 + df['Cumulative_Return'] / 100) / cumulative_max - 1
max_drawdown = drawdown.min() * 100
metrics = {
'Total Return (%)': total_return,
'Annualized Return (%)': annualized_return,
'Annualized Volatility (%)': annualized_volatility,
'Sharpe Ratio': sharpe_ratio,
'Max Drawdown (%)': max_drawdown,
'Downside Deviation (%)': downside_deviation
}
return df, metrics
# Perform comprehensive analysis
df_analyzed, performance_metrics = comprehensive_return_analysis(df)
for metric, value in performance_metrics.items():
print(f"{metric}: {value:.4f}")Comparative Return Analysis
from ta.others import *
def compare_return_types(df):
# Calculate different return types
df['Simple_Return'] = daily_return(df['Close'])
df['Log_Return'] = daily_log_return(df['Close'])
# Compare cumulative effects
df['Cumulative_Simple'] = (1 + df['Simple_Return'] / 100).cumprod() - 1
df['Cumulative_Log'] = df['Log_Return'].cumsum() / 100
# Calculate differences
df['Return_Difference'] = df['Simple_Return'] - df['Log_Return']
df['Cumulative_Difference'] = df['Cumulative_Simple'] - df['Cumulative_Log']
return df
# Compare return methodologies
df_comparison = compare_return_types(df)
# Analyze the differences
print("Return Type Analysis:")
print(f"Average Simple Return: {df_comparison['Simple_Return'].mean():.4f}%")
print(f"Average Log Return: {df_comparison['Log_Return'].mean():.4f}%")
print(f"Average Difference: {df_comparison['Return_Difference'].mean():.6f}%")Rolling Return Analysis
from ta.others import daily_return, cumulative_return
def rolling_return_analysis(df, windows=[30, 60, 90, 252]):
# Calculate daily returns
df['Daily_Return'] = daily_return(df['Close'])
# Calculate rolling returns for different periods
for window in windows:
# Rolling annualized return
rolling_mean = df['Daily_Return'].rolling(window=window).mean()
df[f'Rolling_{window}d_Return'] = rolling_mean * 252
# Rolling volatility (annualized)
rolling_std = df['Daily_Return'].rolling(window=window).std()
df[f'Rolling_{window}d_Volatility'] = rolling_std * np.sqrt(252)
# Rolling Sharpe ratio
df[f'Rolling_{window}d_Sharpe'] = (
df[f'Rolling_{window}d_Return'] / df[f'Rolling_{window}d_Volatility']
)
return df
# Perform rolling analysis
df_rolling = rolling_return_analysis(df)
# Display recent rolling metrics
recent_metrics = df_rolling[['Rolling_30d_Return', 'Rolling_60d_Return',
'Rolling_90d_Return', 'Rolling_252d_Return']].tail(1)
print("Recent Rolling Returns (Annualized):")
print(recent_metrics)Key Differences and When to Use Each
Daily Return vs Daily Log Return
- Daily Return: Intuitive percentage change, better for short-term analysis
- Log Return: Better statistical properties, time-additive, preferred for modeling
Use Case Guidelines
- Daily Return: Day-to-day performance tracking, simple return calculations
- Daily Log Return: Risk modeling, statistical analysis, academic research
- Cumulative Return: Long-term performance evaluation, investment tracking
Statistical Properties
- Log Returns: Approximately normally distributed, suitable for parametric tests
- Simple Returns: May exhibit skewness, especially during volatile periods
- Cumulative Returns: Show compounding effects and long-term trends
Install with Tessl CLI
npx tessl i tessl/pypi-ta