Blog

import numpy as np
import pandas as pd

# Create a class for the market following algorithm
class AdvancedMarketFollowingAlgo:
    def __init__(self, data, initial_capital, position_size, profit_taking_gap):
        self.data = data
        self.initial_capital = initial_capital
        self.position_size = position_size
        self.profit_taking_gap = profit_taking_gap
        self.positions = []
        self.returns = []
        
    # Function to identify short trends in the market
    def identify_trends(self):
        # Use a rolling window to calculate the moving average and standard deviation
        window = 20
        ma = self.data.rolling(window=window).mean()
        std = self.data.rolling(window=window).std()
        
        # Identify short trends by looking for periods where the market is outside of 2 standard deviations
        trends = []
        for i in range(window, len(self.data)):
            if (self.data[i] > (ma[i] + 2*std[i])) or (self.data[i] < (ma[i] - 2*std[i])):
                trends.append(i)
                
        return trends
    
    # Function to build positions in the market
    def build_positions(self):
        # Use game theory to determine the optimal position size
        optimal_position_size = self.position_size * (1 - (len(self.positions) / len(self.data)))
        
        # Identify short trends and build positions accordingly
        trends = self.identify_trends()
        for trend in trends:
            if self.data[trend] > self.data[trend-1]:
                self.positions.append(optimal_position_size)
            elif self.data[trend] < self.data[trend-1]:
                self.positions.append(-optimal_position_size)
                
    # Function to take profits on short trends
    def take_profits(self):
        for i in range(len(self.positions)):
            if self.positions[i] > 0:
                if (self.data[i] - self.data[i-1]) > self.profit_taking_gap:
                    self.positions[i] = 0
            elif self.positions[i] < 0:
                if (self.data[i-1] - self.data[i]) > self.profit_taking_gap:
                    self.positions[i] = 0
                    
    # Function to calculate returns on the positions
    def calculate_returns(self):
        for i in range(len(self.positions)):
            if self.positions[i] > 0:
                self.returns.append((self.data[i] - self.data[i-1]) * self.positions[i])
            elif self.positions[i] < 0:
                self.returns.append((self.data[i-1] - self.data[i]) * self.positions[i])
                
    # Function to run the entire algorithm
    def run(self):
        self.build_positions()