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

ticker = "AAPL"
start_date = "2020-01-01"
end_date = "2023-01-01"
data = yf.download(ticker, start=start_date, end=end_date)

short_window = 40
long_window = 100

data['short_mavg'] = data['Close'].rolling(window=short_window, min_periods=1).mean()
data['long_mavg'] = data['Close'].rolling(window=long_window, min_periods=1).mean()

data['signal'] = 0.0
data['signal'][short_window:] = np.where(data['short_mavg'][short_window:] > data['long_mavg'][short_window:], 1.0, 0.0)   
data['positions'] = data['signal'].diff()

initial_capital = float(100000.0)
positions = pd.DataFrame(index=data.index).fillna(0.0)
positions[ticker] = 100*data['signal']   
portfolio = positions.multiply(data['Close'], axis=0)
pos_diff = positions.diff()

portfolio['holdings'] = (positions.multiply(data['Close'], axis=0)).sum(axis=1)
portfolio['cash'] = initial_capital - (pos_diff.multiply(data['Close'], axis=0)).sum(axis=1).cumsum()   
portfolio['total'] = portfolio['cash'] + portfolio['holdings']
portfolio['returns'] = portfolio['total'].pct_change()

fig = plt.figure()
ax1 = fig.add_subplot(111, ylabel='Portfolio value in $')

portfolio['total'].plot(ax=ax1, lw=2.)
data['signal'].plot(ax=ax1, lw=2.)

ax1.plot(data.loc[data.positions == 1.0].index, 
         data.short_mavg[data.positions == 1.0],
         '^', markersize=10, color='m')

ax1.plot(data.loc[data.positions == -1.0].index, 
         data.short_mavg[data.positions == -1.0],
         'v', markersize=10, color='k')

plt.show()

ticker = "^FTSE"
start_date = "2000-01-01"
end_date = "2023-01-01"
data = yf.download(ticker, start=start_date, end=end_date)

ticker = "^STI"
start_date = "2000-01-01"
end_date = "2023-01-01"
data = yf.download(ticker, start=start_date, end=end_date)

momentum_window = 20
data['momentum'] = data['Close'].pct_change(momentum_window)

data['signal'] = 0.0
data['signal'] = np.where(data['momentum'] > 0, 1.0, 0.0)
data['positions'] = data['signal'].diff()

beginning_value = portfolio['total'].iloc[0]
ending_value = portfolio['total'].iloc[-1]
years = (data.index[-1] - data.index[0]).days / 365.25

CAGR = (ending_value / beginning_value) ** (1 / years) - 1
print(f"CAGR: {CAGR:.2%}")

risk_free_rate = 0.02
mean_return = portfolio['returns'].mean()
std_return = portfolio['returns'].std()

sharpe_ratio = (mean_return - risk_free_rate) / std_return
print(f"Sharpe Ratio: {sharpe_ratio:.2f}")

## Case Study: BlackRock

### Overview
BlackRock, the world’s largest asset manager, leverages algorithmic trading to manage its extensive portfolio. The firm employs sophisticated algorithms to execute trades, manage risks, and optimize portfolio performance.

### Trading Strategies
BlackRock’s algo trading strategies include:

- **Index Arbitrage:** Exploiting price differences between index futures and underlying stocks.
- **Mean Reversion:** Identifying stocks that have deviated from their historical price patterns and betting on their return to the mean.
- **Momentum Trading:** Capitalizing on stocks that show strong trends in a particular direction.

### Technology Stack
BlackRock uses a proprietary trading platform called Aladdin, which integrates risk management, trading, and portfolio management. Aladdin employs advanced data analytics, machine learning, and cloud computing to support algo trading activities.

### Impact
BlackRock’s algorithmic trading has significantly enhanced its trading efficiency, reduced transaction costs, and improved overall portfolio performance. The firm’s ability to execute large volumes of trades with minimal market impact has been a critical factor in its success.

### Real-World Example: Index Arbitrage on LSE

#### Index Arbitrage Strategy:
Assume a scenario where BlackRock is using index arbitrage on the FTSE 100 index. If the index futures price is trading above its fair value compared to the underlying stocks, BlackRock would sell the futures and buy the underlying stocks.

### Calculations:
- **Fair Value of Futures**: \( \text{Futures Price} = \text{Spot Price} \times (1 + \text{Risk-Free Rate} - \text{Dividend Yield})^{T} \)
- **Spot Price**: Current price of the underlying index.
- **Risk-Free Rate**: Assume a risk-free rate of 2%.
- **Dividend Yield**: Assume a dividend yield of 3%.
- **Time to Maturity (T)**: Assume 0.5 years.

### Impact:
If the actual futures price is significantly higher than the fair value, BlackRock can capitalize on this discrepancy by executing the arbitrage strategy.

## Case Study: Tower Research

### Overview
Tower Research Capital, a leading HFT firm, is renowned for its low-latency trading strategies. The firm employs cutting-edge technology and sophisticated algorithms to trade across various asset classes.

### Trading Strategies
Tower Research’s strategies include:

- **Statistical Arbitrage:** Using statistical models to identify and exploit price discrepancies between related financial instruments.
- **Market Making:** Providing liquidity by continuously quoting buy and sell prices and profiting from the bid-ask spread.
- **Event-Driven Trading:** Trading based on news events, earnings announcements, and economic data releases.

### Technology Stack
Tower Research invests heavily in low-latency infrastructure. The firm uses custom-built hardware, co-located servers, and high-speed communication networks to achieve ultra-fast trade execution.

### Impact
Tower Research’s focus on low latency has enabled it to gain a competitive edge in the market. The firm’s ability to execute trades within microseconds has resulted in consistent profitability and significant market share in the HFT space.

### Real-World Example: Statistical Arbitrage on SGX

#### Statistical Arbitrage Strategy:
Assume a scenario where Tower Research is using statistical arbitrage to trade pairs of stocks on the SGX. If stock A and stock B are typically correlated but have diverged, Tower Research can buy the underperforming stock and short the outperforming stock, expecting them to revert to their mean correlation.

### Calculations:
- **Z-Score Calculation**: \( Z = \frac{\text{Price Spread} - \mu}{\sigma} \)
- **Price Spread**: Difference between the prices of stock A and stock B.
- **Mean (\(\mu\)) and Standard Deviation (\(\sigma\)) of Price Spread**: Calculated based on historical data.

### Trading Signals:
- **Buy Signal**: If Z-Score < -1.0 (Buy stock A and short stock B).
- **Sell Signal**: If Z-Score > 1.0 (Sell stock A and buy stock B).

### Impact:
By implementing statistical arbitrage, Tower Research can profit from temporary deviations in the prices of correlated stocks.

## Conclusion

Algorithmic trading and quants have revolutionized the financial markets, enabling firms to execute trades with speed, precision, and efficiency. The cases of BlackRock and Tower Research highlight the diverse applications and impact of algo trading in the industry. Real-world examples from the LSE and SGX illustrate how these strategies can be applied and the calculations involved. As technology continues to evolve, the role of quants and the sophistication of algorithmic trading systems are expected to grow, further transforming the landscape of financial markets.