Is it possible to simulate order with size smaller than 1?

[masafumimori]

Apologies if this has been answered already, but I couldn't find the same question in the discussions or issues.

My question is: is there a way to place orders with a size less than 1 using the backtesting.py package?

For example, let's say the BTCUSDT price is 20k, and my balance is 10k. I would like to place an order with a size of 0.5 (10k/20k).

As it stands, when the size is set between 0 and 1, it's treated as a fraction of the balance (cash + position P&L - margin), but it doesn't execute orders with a size smaller than 1.

I tried the following code, but the backtest stops once self.equity can no longer buy/sell a size of 1, meaning the equity is smaller than the price:

class HeikinStrategy(Strategy):
    def init(self):
        # pos has 1 or -1 for long/short
        self.pos = self.I(Heikin, self.data)

    def next(self):
        price = self.data.Close[-1]
        size = self.equity / price if self.equity < price else 0.9999
        # Long entry
       if self.pos == 1:
            self.buy(size=size)
        # Short exit
        elif self.pos == -1:
            self.sell(size=size)

So, I was wondering if I can place an order with a size less than 1.
When the price is small, like EURUSD, it should not be a problem. However, for BTC, buying 1 BTC nowadays requires a significant amount of money, and backtesting with an unrealistic cash value won't be very informative for validating the strategy, I suppose?

Thank you for your help in advance.

[kernc]

What did you search for, I wonder. See #134.

[masafumimori]

Thank you very much!
I am sorry i was very wrong in searching... (just searching about setting sizes)

Thank you again!!

[masafumimori]

@kernc,

Thank you for your answer. However, I'm still having trouble understanding why the Return [%] differs when using or not using μBTC.

For example, when I set cash=100,000, Return [%] is 298.1342. But when I follow your suggestion to do df = (df / 1e6).assign(Volume=df.Volume * 1e6), the Return [%] becomes 310.268262 with initial cash 1000. (I am using the same strategy for both and both trade 728 times)

Isn't this strange? The return should be the same regardless of the initial cash and BTC price, as long as the number of trades is the same. Otherwise, the strategy seems to be influenced by the initial cash amount and BTC price scale.

Please let me know if I'm missing something or if there's a better way to adjust for μBTC.

Thank you!

[kernc]

With μBTC the factor is 10e6, but with your initial cash only 100. I suspect whence the difference.

[masafumimori]

Thank you for your answer.

I still don't quite understand that, though... (Sorry I am not good at math)
So, after all, do the price scale and initial cash affect the strategy performance in terms of Return [%] even doing the same number of trades?

Additionally, I was wondering why I get a different return value when using the code snippet below, compared to what I get in Return [%].

# result is returned value from backtest.run()
ret = result._trades["ReturnPct"].cumsum()*100
ret.iloc[-1]

For example, I get Return [%] 138.897456 from bt.run().
But when using the code above, I get 131.49769140262327. (Shouldn't this be 138.897456?)

Another one is Return [%] 391.060317 from bt.run() while 206.45595741647105 by the code above.

Are they meant to be different?

[kernc]

This is how Return [%] is computed:

backtesting.py/backtesting/_stats.py

Line 95 in 0ce24d8

s.loc['Return [%]'] = (equity[-1] - equity[0]) / equity[0] * 100

Individual trade returns are their P/L over their entry price, adjusted for commission.

backtesting.py/backtesting/backtesting.py

Lines 644 to 647 in 0ce24d8

	def pl_pct(self):
	"""Trade profit (positive) or loss (negative) in percent."""
	price = self.__exit_price or self.__broker.last_price
	return copysign(1, self.__size) * (price / self.__entry_price - 1)

I'm also not that good at match to confirm whether one should match the other, sorry.
If you happen to spot a bug, fixes are welcome.

[masafumimori]

@kernc
Thank you for your answer.
As the calculations are different, it seems ok for them to be different I suppose.

FYI, I asked "ChatGPT4" about why they are different and it seems fine that the two values are different. Reply from chatgpt is below.

This discrepancy occurs because the Return [%] you see in the summary of the backtesting results is calculated differently from the cumulative sum of the individual trade return percentages.

The Return [%] in the backtesting results is the overall return of the strategy, calculated as the percentage change in the total value of your portfolio from the beginning to the end of the backtesting period.
This takes into account the compounding effect, where each trade's returns are based on the updated portfolio value.

On the other hand, when you calculate the cumulative sum of the individual trade return percentages (_trades["ReturnPct"].cumsum()), you are simply adding up the return percentages of all trades without considering the compounding effect.

To better understand the difference, let's consider an example:

Suppose you have a portfolio with an initial value of $10,000. You make two trades with the following return percentages:

Trade 1: +10%
Trade 2: +20%
Calculating the overall return with compounding:

After Trade 1: $10,000 * (1 + 10%) = $11,000
After Trade 2: $11,000 * (1 + 20%) = $13,200
Overall Return [%] = (($13,200 - $10,000) / $10,000) * 100 = 32%
Calculating the cumulative sum of individual trade return percentages:

10% + 20% = 30%
As you can see, the overall return (32%) is different from the cumulative sum of individual trade return percentages (30%) because the overall return takes into account the compounding effect.