I'm trying to capture profits and set a stop loss in my trading strategy. I want the stop loss to be set daily based on the past data and if the current price, i.e., price for the date falls below the stop_loss levels, sell the stock!

Here I have included my code which takes in stop loss calculated using certain logic for all the days. Another dataframe tells me about the trading dates, with TRUE valeu indicating, I enter the trade and FALSE value indicating, I exit the trade. With this logic I enter the trade, see if stop loss is met? If not get going to the next date, if it is met, then sell else continue the loop till the end of the closing price dataframe is met. I will then log the entry and exit prices in a dataframe and save it.

This code, returns empty logging_stop_loss dataframe and it has no entry in the dataframe. This being the case, I want to understand what is causing the issue and rectify it. Can someone lead me to the direction which is causing this error and I can modify my logic accordingly.

I'm trying to capture profits and set a stop loss in my trading strategy. I want the stop loss to be set daily based on the past data and if the current price, i.e., price for the date falls below the stop_loss levels, sell the stock.

I have included my code which takes in stop loss calculated using certain logic for all the days. Another dataframe tells me about the trading dates, with TRUE value indicating I enter the trade, and FALSE value indicating I exit the trade. With this logic, I enter the trade and see if stop loss is met. If not, get going to the next date, if it is met, then sell else continue the loop till the end of the closing price dataframe is met. I will then log the entry and exit prices in a dataframe and save it.

This code returns empty logging_stop_loss dataframe, and it has no entry in the dataframe. This being the case, I want to understand what is causing the issue and rectify it. Can someone lead me to the direction which is causing this error and I can modify my logic accordingly.

I'm trying to capture profits and set a stop loss in my trading strategy. I want the stop loss to be set daily based on the past data, from the date of calculation into the past.

For calculating the stop-loss, I first measure the expected returns that I aim at securing, the volatility of the stock and based on these informations, I then calculate stop loss level.

The data that I have is, a dataframe which contain information on when to enter the trade for which stock? It is a boolean dataframe where the row index are dates and columns are stock names. If it is a true, I will enter the trade, false will ensure I stay out.

For the first instance, I calculate the stop loss level, and save it, then I apply loops to calculate the stop loss in a similar fashion for the stock but in the context of the next day, using the data for the proceeding day.

This is taking very very long because of the loops and I am afraid this code doesn't work correctly either.

def drawdown(result_df, dict_dfs):
    last_year_df = pd.DataFrame(data=np.nan, index=result_df.index, columns=result_df.columns)

    for idx in range(len(result_df)):
        for stock in result_df.columns:
            if result_df.iloc[idx][stock]:
                past_date_idx = max(0, idx - 250)
                past_date = result_df.index[past_date_idx]
                current_date = result_df.index[idx]

                last_year = dict_dfs['close'].loc[past_date:current_date, stock]

                drawdowns = []
                for i in range(len(last_year)):
                    rolling_min = last_year.iloc[:i + 1].min()
                    rolling_max = last_year.iloc[i:].max()
                    if rolling_min != 0:
                        drawdown = (rolling_max - rolling_min) / rolling_min
                        drawdowns.append(drawdown)

                last_year_df.iloc[idx][stock] = np.median(drawdowns)
    return last_year_df

def stop_loss(expectations, volatility):
    stop_loss_levels = pd.DataFrame(
        np.minimum(20,
                   np.minimum(0.4 * expectations, (1 / volatility))),
        index=expectations.index,
        columns=expectations.columns
    )

    stop_loss_levels = stop_loss_levels.where(expectations.notna() & volatility.notna())

    return stop_loss_levels

def volatility_cal(result_df, dict_dfs):
    volatility_year = pd.DataFrame(data=np.nan, index=result_df.index, columns=result_df.columns)

    for idx in range(len(result_df)):
        for stock in result_df.columns:
            if result_df.iloc[idx][stock]:
                past_date_idx = max(0, idx - 250)
                past_date = result_df.index[past_date_idx]
                current_date = result_df.index[idx]

                last_year = dict_dfs['close'].loc[past_date:current_date, stock]
                standard_dev = last_year.std()
                volatility_year.iloc[idx][stock] = standard_dev
    return volatility_year


def logging_stop_loss(dict_dfs, result_df):
    trades = []
    positions = {}
    expectations = drawdown(result_df, dict_dfs)
    volatility = volatility_cal(result_df, dict_dfs)
    stop_loss_levels = stop_loss(expectations, volatility)

    for date_idx in range(len(result_df.index)):
        date = result_df.index[date_idx]
        for stock_idx, stock in enumerate(result_df.columns):
            if result_df.iloc[date_idx, stock_idx]:
                if stock not in positions:
                    entry_price = dict_dfs['close'].iloc[date_idx, stock_idx]
                    positions[(stock, date)] = {
                        'entry_date': date,
                        'entry_price': entry_price,
                        'stop_loss': entry_price * (1 - stop_loss_levels.iloc[date_idx, stock_idx])
                    }

        closed_positions = []
        count = 0
        for (stock, entry_date) in list(positions.keys()):
            count=count+1
            pos = positions[(stock, entry_date)]
            date = result_df.index[date_idx+count]
            current_price = dict_dfs['close'].loc[date, stock]

            current_expectations = drawdown(result_df.shift(count), dict_dfs)
            current_volatility = volatility_cal(result_df.shift(count), dict_dfs)
            current_stop_loss_levels = stop_loss(current_expectations, current_volatility)

            pos['stop_loss'] = current_price * (1 - current_stop_loss_levels.loc[date, stock])

            if current_price < pos['stop_loss']:
                trades.append({
                    'stock': stock,
                    'entry_date': pos['entry_date'],
                    'entry_price': pos['entry_price'],
                    'exit_date': date,
                    'exit_price': current_price,
                    'return': (current_price - pos['entry_price']) / pos['entry_price']
                })
                closed_positions.append((stock, pos['entry_date']))

        for stock, entry_date in closed_positions:
            del positions[(stock, entry_date)]
    return pd.DataFrame(trades)

Here drawdown is the first function to be called and it gives me the expected returns. The logic for the same is absolutely correct and no changes should happen there. Next is volatility_cal function and it gives me standard deviation. Next is then Stop Loss calculator, which lets me know the stop loss percent that I can incur the following percent loss.

Post this, I then aim at logging the information of when to exit the trades based on continuous stop loss calculations. I first calculate the entry price and stop loss associated with it. With this I maintain a counter which say how many days have passed after entering the trade and helps in moving the boolean dataframe into the future. By moving the boolean dataframe into the future, I get an idea that yes, now I enter the trade on this day again and accordingly gives me the stop loss levels. If the price falls below stop loss percentages, I exit the trade and marks the observations in the logger.

Once all the TRUE values from original boolean dataframe is satisfied, it returns the logger.

The code is getting stuck in an infinite loop or it is just inefficient, as I have not been able to observe the results for the above function even after waiting a couple of hours.

Therefore please help me improve the time complexity by using dataframes and matrix, instead of loops.

I'm trying to capture profits and set a stop loss in my trading strategy. I want the stop loss to be set daily based on the past data and if the current price, i.e., price for the date falls below the stop_loss levels, sell the stock!

def logging_stop_loss(dict_dfs, result_df, stop_loss_levels):
    trades = []
    positions = {}

    for date_idx, date in enumerate(result_df.index):
        for stock in result_df.columns[result_df.iloc[date_idx]]:
            if (stock, date) not in positions:
                entry_price = dict_dfs['close'].at[date, stock]
                stop_loss_level = stop_loss_levels.at[date, stock]
                positions[(stock, date)] = {
                    'entry_date': date,
                    'entry_price': entry_price,
                    'stop_loss': entry_price * (1 - stop_loss_level),
                    'count': 0  # Initialize count to track days since entry
                }

        closed_positions = []
        for (stock, entry_date), pos in list(positions.items()):
            pos['count'] += 1
            future_date = result_df.index[min(date_idx + pos['count'], len(result_df) - 1)]
            current_price = dict_dfs['close'].at[future_date, stock]
            stop_loss_level = stop_loss_levels.at[future_date, stock]
            pos['stop_loss'] = current_price * (1 - stop_loss_level)

            if current_price < pos['stop_loss']:
                trades.append({
                    'stock': stock,
                    'entry_date': pos['entry_date'],
                    'entry_price': pos['entry_price'],
                    'exit_date': future_date,
                    'exit_price': current_price,
                    'return': (current_price - pos['entry_price']) / pos['entry_price']
                })
                closed_positions.append((stock, entry_date))

        for stock_entry in closed_positions:
            del positions[stock_entry]

    return pd.DataFrame(trades)

Here I have included my code which takes in stop loss calculated using certain logic for all the days. Another dataframe tells me about the trading dates, with TRUE valeu indicating, I enter the trade and FALSE value indicating, I exit the trade. With this logic I enter the trade, see if stop loss is met? If not get going to the next date, if it is met, then sell else continue the loop till the end of the closing price dataframe is met. I will then log the entry and exit prices in a dataframe and save it.

This code, returns empty logging_stop_loss dataframe and it has no entry in the dataframe. This being the case, I want to understand what is causing the issue and rectify it. Can someone lead me to the direction which is causing this error and I can modify my logic accordingly.