HowTo: Use Parameters with Permutations

[mrddter]

Hello,

here an example of how to use parameters with permutations.

First of all, you need to pass the parameters you want to permute. For example, in the following scenario, both lowSMA and highSMA have multiple values. I could also have lowSMA as 10 and highSMA as an array, but let's make things a bit more complicated.

  const startTime = new Date('2024-02-01').getTime()
  const endTime = new Date('2024-10-14').getTime()

  const strategyResult = await runStrategy({
    strategyName: 'demo',
    historicalData: ['BTCEUR-8h'],
    params: {
      lowSMA: [10, 20],
      highSMA: [30, 40, 50]
    },
    startingAmount: 1000,
    startTime: startTime,
    endTime: endTime
  })

In this case, we'll have 6 permutations. The "demo" strategy will operate as if there is only one pair of lowSMA and highSMA values at a time. So first low: 10 and high: 30, then low: 10 and high: 40, then low: 10 and high: 50, and so on.

Here the code:

import { BTH } from '@backtest/framework'

export const properties = {
  params: ['lowSMA', 'highSMA'],
  dynamicParams: false
}

export async function runStrategy(bth: BTH) {
  if (bth.tradingCandle) {
    const lowSMAInput = bth.params.lowSMA
    const highSMAInput = bth.params.highSMA

    // Here your strategy ..
  } else {
    // Here is your code to analyze the potential support candles,
    // if they have been defined (aka supportHistoricalData)
  }
}

In the end, the strategyResult structure will contain all the permutations created with various data, such as sharpe ratio, maximum/minimum drawdown, number of candles, and, of course, the end amount.

Something like this:

// console.log(strategyResult)

{
  name: "demo-BTCEUR-multi",
  strategyName: "demo",
  symbols: [
    "BTCEUR-8h",
  ],
  permutationCount: 6,
  params: {
    lowSMA: [
      10,
      20,
    ],
    highSMA: [
      30,
      40,
      50,
    ],
  },
  startTime: 1706745600000,
  endTime: 1728864000000,
  txFee: 0,
  slippage: 0,
  startingAmount: 1000,
  multiResults: [
    {
      lowSMA: 10,
      highSMA: 30,
      symbol: "BTCEUR",
      interval: "8h",
      endAmount: 1143.53,
      maxDrawdownAmount: 21.94,
      maxDrawdownPercent: 2.16,
      numberOfCandlesInvested: 431,
      sharpeRatio: 10000,
      assetAmounts: {
        startingAssetAmount: 39085.8,
        endingAssetAmount: 57341.52,
        highestAssetAmount: 67462.84,
        highestAssetAmountDate: 1710403199999,
        lowestAssetAmount: 38725.76,
        lowestAssetAmountDate: 1706774399999,
        numberOfCandles: 768,
      },
    },
    //..... and the others 5 ........
  ],
  isMultiValue: true,
  isMultiSymbol: false,
}

It is possible to access a summary structure in this way:

const parsed = await parseRunResultsStats(strategyResult)

This way, parsed will contain other useful information about the various permutations executed. Of course, if you want significantly more detail (e.g., all executed orders with notes, each individual gain/loss per transaction, etc.), then it is necessary to execute the strategy without permutation.

Essentially, with permutation, it is possible to run challenges between different values and evaluate the effectiveness of the strategy in the initial analysis. To investigate more thoroughly, you can execute the single strategy with the best individual values for even more accurate details.

// console.log(parsed)

{
  totals: [
    {
      name: "Start EUR Amount",
      amount: 1000,
      percent: "-",
      date: "2/1/2024, 1:00:00 AM",
    },
    {
      name: "Number Of Candles",
      amount: 768,
      percent: "-",
      date: "Duration: 256 days 00:00:00",
    },
    {
      name: "Average Ending EUR Amount",
      amount: 1200.28,
      percent: "20.03%",
      date: "Duration: 256 days 00:00:00",
    },
    {
      name: "Highest Ending EUR Amount",
      amount: 1465.48,
      percent: "46.55%",
      date: "Duration: 256 days 00:00:00",
    },
    {
      name: "Lowest Ending EUR Amount",
      amount: 1000.93,
      percent: "0.09%",
      date: "Duration: 256 days 00:00:00",
    },
    {
      name: "Average Drawdown",
      amount: "125.03",
      percent: "8.61%",
      date: "Duration: 256 days 00:00:00",
    },
    {
      name: "Highest Drawdown",
      amount: 640.5,
      percent: "40.86%",
      date: "Duration: 256 days 00:00:00",
    },
    {
      name: "Lowest Drawdown",
      amount: 21.94,
      percent: "2.16%",
      date: "Duration: 256 days 00:00:00",
    },
  ],
  assetAmountsPercentages: [
    {
      name: "Start BTC Amount",
      amount: 39085.8,
      percent: "-",
      date: "2/1/2024, 1:00:00 AM",
    },
    {
      name: "End BTC Amount",
      amount: 57341.52,
      percent: "-",
      date: "10/14/2024, 2:00:00 AM",
    },
    {
      name: "BTC Went Up",
      amount: 18255.72,
      percent: "46.71%",
      date: "Duration: 256 days 00:00:00",
    },
    {
      name: "BTC Highest",
      amount: 67462.84,
      percent: "72.6%",
      date: "3/14/2024, 8:59:59 AM",
    },
    {
      name: "BTC Lowest",
      amount: 38725.76,
      percent: "-0.92%",
      date: "2/1/2024, 8:59:59 AM",
    },
    {
      name: "BTC Lowest To Highest",
      amount: 28737.079999999994,
      percent: "74.21%",
      date: "Duration: 42 days 00:00:00",
    },
  ],
  generalData: [
    {
      name: "Strategy Name",
      value: "demo",
    },
    {
      name: "Parameter - lowSMA",
      value: [
        10,
        20,
      ],
    },
    {
      name: "Parameter - highSMA",
      value: [
        30,
        40,
        50,
      ],
    },
    {
      name: "Permutation Count",
      value: 6,
    },
    {
      name: "Symbol",
      value: "BTCEUR",
    },
    {
      name: "Base",
      value: "BTC",
    },
    {
      name: "Quote",
      value: "EUR",
    },
    {
      name: "Interval",
      value: "8h",
    },
    {
      name: "TX Fee",
      value: 0,
    },
    {
      name: "Slippage",
      value: 0,
    },
  ],
}

NB: If you want to use or visualize these data, you might want to check out backtestjs/command-line. The README for this project includes images of the charts created, so you can get an idea of what I mean.