Initialize parameters and constants
Initialize data buffers for multiple timeframes
Initialize historical performance record

For each new bar:
    For each timeframe in {Fast, Medium, Slow}:
        Update price buffer
        Compute AbstractMetric_A[timeframe]  // e.g., some transformation of price history

    Compute AbstractFeatureSet1 from AbstractMetric_A and other transformations

    RawSignal ? AbstractDecisionFunction1(AbstractFeatureSet1)

    ModelInput1 ? AbstractFeatureSet1
    [ProbLong, ProbShort] ? Model1(ModelInput1)
    AdjustedSignal ? AbstractSignalFilter(RawSignal, ProbLong, ProbShort)

    Update performance history from closed trades
    Compute AbstractFeatureSet2 from AbstractMetric_A and performance statistics

    ModelInput2 ? AbstractFeatureSet2
    [StopMultiplier, TakeProfitMultiplier] ? Model2(ModelInput2)
    Constrain StopMultiplier, TakeProfitMultiplier to allowable ranges

    StopDistance ? AbstractVolatilityMeasure * StopMultiplier
    TakeProfitDistance ? AbstractVolatilityMeasure * TakeProfitMultiplier

    If in training mode:
        Execute trades based on RawSignal
    Else:
        Execute trades based on AdjustedSignal

    Plot monitoring metrics (non-trading)

#include <stdio.h>

#define INT_BITS 32
#define MAX_NODES 1024 

// Trie node structure
typedef struct TrieNode {
    struct TrieNode* bit[2];
} TrieNode;

TrieNode trieNodes[MAX_NODES]; 
int trieNodeCount = 0; 


TrieNode* newTrieNode() {
    if (trieNodeCount >= MAX_NODES) {
        printf("Exceeded maximum trie nodes\n");
        return NULL;
    }
    TrieNode* newNode = &trieNodes[trieNodeCount++];
    newNode->bit[0] = NULL;
    newNode->bit[1] = NULL;
    return newNode;
}


void insert(TrieNode* root, int number) {
    TrieNode* current = root;
    int i, bit;
    for (i = INT_BITS - 1; i >= 0; i--) {
        bit = (number >> i) & 1;
        if (!current->bit[bit]) {
            current->bit[bit] = newTrieNode();
            if (!current->bit[bit]) return; 
        }
        current = current->bit[bit];
    }
}


int findMaxXOR(TrieNode* root, int number) {
    TrieNode* current = root;
    int maxXOR = 0;
    int i, bit;
    for (i = INT_BITS - 1; i >= 0; i--) {
        bit = (number >> i) & 1;
        if (current->bit[1 - bit]) {
            maxXOR |= (1 << i);
            current = current->bit[1 - bit];
        } else {
            current = current->bit[bit];
        }
    }
    return maxXOR;
}


int getMaxXOR(int* arr, int size) {
    TrieNode* root = newTrieNode();
    if (!root) return 0; 
    int maxXOR = 0;
    int i, currentXOR;
    for (i = 0; i < size; i++) {
        insert(root, arr[i]);
        currentXOR = findMaxXOR(root, arr[i]);
        if (currentXOR > maxXOR) {
            maxXOR = currentXOR;
        }
    }
    return maxXOR;
}

void main() {
    int arr[10] = {3, 10, 5, 25, 2, 8};
    int size = 6;
    int result = getMaxXOR(arr, size);
    printf("Maximum XOR: %d\n", result);
}

#define INT_BITS 32
#define MAX_NODES 1024 
#define MAX_ARRAY_SIZE 10
#define RAND_MAX_VALUE 100  // maximum random number value

// Trie node structure
typedef struct TrieNode {
    struct TrieNode* bit[2];
} TrieNode;

TrieNode trieNodes[MAX_NODES]; 
int trieNodeCount = 0; 

// === Clear trie memory safely ===
void clearTrie()
{
    int i;
    for(i = 0; i < MAX_NODES; i++) {
        trieNodes[i].bit[0] = NULL;
        trieNodes[i].bit[1] = NULL;
    }
    trieNodeCount = 0;
}

// === Allocate new node ===
TrieNode* newTrieNode() {
    if (trieNodeCount >= MAX_NODES) {
        printf("\nExceeded maximum trie nodes\n");
        return NULL;
    }
    TrieNode* newNode = &trieNodes[trieNodeCount++];
    newNode->bit[0] = NULL;
    newNode->bit[1] = NULL;
    return newNode;
}

// === Insert number into trie ===
void insert(TrieNode* root, int number) {
    TrieNode* current = root;
    int i, bit;
    for (i = INT_BITS - 1; i >= 0; i--) {
        bit = (number >> i) & 1;
        if (!current->bit[bit]) {
            current->bit[bit] = newTrieNode();
            if (!current->bit[bit]) return; 
        }
        current = current->bit[bit];
    }
}

// === Find max XOR for given number ===
int findMaxXOR(TrieNode* root, int number) {
    TrieNode* current = root;
    int maxXOR = 0;
    int i, bit;
    for (i = INT_BITS - 1; i >= 0; i--) {
        bit = (number >> i) & 1;
        if (current->bit[1 - bit]) {
            maxXOR |= (1 << i);
            current = current->bit[1 - bit];
        } else {
            current = current->bit[bit];
        }
    }
    return maxXOR;
}

// === Compute max XOR from array & track best pair ===
int getMaxXOR(int* arr, int size, int* num1, int* num2) {
    clearTrie();  // ensure trie is empty before use

    TrieNode* root = newTrieNode();
    if (!root) return 0; 

    int maxXOR = 0;
    int i, currentXOR;

    *num1 = 0;
    *num2 = 0;

    for (i = 0; i < size; i++) {
        insert(root, arr[i]);
        currentXOR = findMaxXOR(root, arr[i]);
        if (currentXOR > maxXOR) {
            maxXOR = currentXOR;
            *num1 = arr[i];
            *num2 = arr[i] ^ maxXOR; // second number from XOR relation
        }
    }
    return maxXOR;
}

// === Zorro entry point ===
function run() {
    int size = MAX_ARRAY_SIZE;
    int arr[MAX_ARRAY_SIZE];
    int i;

    // Generate random integers
    printf("\nGenerated numbers: ");
    for (i = 0; i < size; i++) {
        arr[i] = random(RAND_MAX_VALUE); 
        printf("%d ", arr[i]);
    }
    printf("\n");

    int n1, n2;
    int result = getMaxXOR(arr, size, &n1, &n2);

    printf("Maximum XOR: %d (from %d ^ %d)\n", result, n1, n2);
}

Data Structure:
- Array of KeyValue objects

Operations:
- CreateDictionary(size)
- Insert(key, value)
- Lookup(key)

Function customHash(key, size):
    return key % size

Function CreateDictionary(size):
    dictionary = new KeyValue[size]
    for i = 0 to size - 1:
        dictionary[i].key = -1
    return dictionary

Function Insert(dictionary, size, key, value):
    index = customHash(key, size)
    while dictionary[index].key != -1:
        index = (index + 1) % size
    dictionary[index].key = key
    dictionary[index].value = value

Function Lookup(dictionary, size, key):
    index = customHash(key, size)
    while dictionary[index].key != key:
        if dictionary[index].key == -1:
            return -1
        index = (index + 1) % size
    return dictionary[index].value

___________________________________________

Data Structure:
- Array of ComplexElement objects

Operations:
- InitializeComplexDataStructure(size)
- ExecuteComplexOperation(key)

Function InitializeComplexDataStructure(size):
    complexDataStructure = new ComplexElement[size]
    // Initialize complexDataStructure as needed
    return complexDataStructure

Function ExecuteComplexOperation(complexDataStructure, size, key):
    // Perform a complex trading operation on complexDataStructure based on the key
    // This operation has a complexity of O(n^(n*n-1)).

Main:
    n = 10
    dictionarySize = n * n * n * n
    complexDataStructureSize = n * n * n * n  // Adjust the size based on complexity requirements

    dictionary = CreateDictionary(dictionarySize)
    complexDataStructure = InitializeComplexDataStructure(complexDataStructureSize)

    for i = 0 to n - 1:
        for j = 0 to n - 1:
            key = i * n + j
            value = key * key
            Insert(dictionary, dictionarySize, key, value)

    searchKey = 7
    result = Lookup(dictionary, dictionarySize, searchKey)
    if result != -1:
        Print "Value for key", searchKey, "in ComplexDictionary:", result
    else:
        Print "Key", searchKey, "not found in ComplexDictionary."

    // Execute a complex trading operation on ComplexTradingOperation
    complexKey = 5  // Adjust the key as needed
    ExecuteComplexOperation(complexDataStructure, complexDataStructureSize, complexKey)

#include <contract.c>

// Define your global parameters such as target profit, days to expiration, and strike price offset
var TargetProfit = 500; // Example target profit
int DaysToExpiration = 30; // Target days until expiration
var StrikeOffset = 50; // Offset from the current price for strike selection

void run() {
  // Setup basic parameters
  BarPeriod = 1440; // Use daily bars
  LookBack = 0; // No need for historical bars in options trading setup
  StartDate = 2020;
  EndDate = 2024; // Set your backtest period
  assetList("AssetsIB");
  asset("SPY"); // Example using SPY ETF as the underlying asset

  // Ensure we're trading in American Options for SPY
  AmericanOption = 1;

  // Update the contract chain for the underlying asset
  if(!contractUpdate(Asset, 0, CALL | PUT)) return;

  // Trading logic executed once per day
  if(is(EXITRUN)) return; // Skip logic at the end of the backtest
  
  // Define your strangle strategy here
  if(NumOpenLong + NumOpenShort == 0) { // Check if there's no open position
    // Calculate target strike prices based on current price and offset
    var CurrentPrice = priceClose(0);
    var StrikeCall = CurrentPrice + StrikeOffset;
    var StrikePut = CurrentPrice - StrikeOffset;

    // Attempt to find and enter a Strangle combo
    if(combo(
      contractFind(CALL, DaysToExpiration, StrikeCall), 1, // Buy 1 Call
      contractFind(PUT, DaysToExpiration, StrikePut), 1,  // Buy 1 Put
      0, 0)) { 
        // Enter the combo trade
        enterLong(comboLeg(1)); // Enter long for the call option leg
        enterLong(comboLeg(2)); // Enter long for the put option leg
    }
  }

  // Monitor and manage open positions
  for(open_trades) { // Loop through all open trades
    if(TradeIsOption && TradeIsOpen && (comboProfit(TradePriceClose, 1) > TargetProfit || daysToExpiration() < 5)) {
      exitTrade(ThisTrade); // Close the trade if target profit is reached or approaching expiration
    }
  }
}

// Placeholder function for days to expiration calculation - implement as needed
int daysToExpiration() {
  // Custom logic to calculate and return days to expiration for the current combo
  return 10; // Placeholder return value
}

// Placeholder function for calculating combo profit - implement based on actual requirements
var comboProfit(var CurrentClosePrice, int Leg) {
  // Custom logic to calculate and return profit for the combo based on current prices
  return 600; // Placeholder return value
}

#include <contract.c>

// Global parameters for the covered call strategy
var PremiumTarget = 100; // Target premium income from selling the call
int DaysToExpiration = 45; // Target days until expiration for the call option
var StrikeOffset = 100; // Offset from the current price for strike selection

void run() {
  // Setup basic parameters
  BarPeriod = 1440; // Use daily bars
  LookBack = 0; // No need for historical bars in this setup
  StartDate = 2020;
  EndDate = 2024; // Set your backtest period
  assetList("AssetsIB");
  asset("SPY"); // Example using SPY ETF as the underlying asset
  
  // Ensure we're trading in American Options for SPY
  AmericanOption = 1;

  // Update the contract chain for the underlying asset
  if(!contractUpdate(Asset, 0, CALL)) return;

  // Trading logic executed once per day
  if(is(EXITRUN)) return; // Skip logic at the end of the backtest

  // Check if we already own SPY
  if(!NumOpenLong) enterLong(1); // Enter long position if we don't own SPY

  // Sell a call option if we haven't already
  if(NumOpenShort == 0) {
    var CurrentPrice = priceClose(0);
    var StrikeCall = CurrentPrice + StrikeOffset;

    // Finding the call option contract
    CONTRACT* callContract = contractFind(CALL, DaysToExpiration, StrikeCall);
    if(callContract) {
      // Enter a short position by selling the call option
      enterShort(1, callContract); 
    }
  }

  // Managing the open option position
  for(open_trades) {
    CONTRACT* c = ThisTrade->Contract;
    if(TradeIsOption && TradeIsShort && (comboProfit(c->fAsk, 1) > PremiumTarget || daysToExpiration(c) < 5)) {
      exitTrade(ThisTrade); // Close the call option if premium target is reached or approaching expiration
    }
  }
}

// A more refined function for calculating days to expiration based on contract data
int daysToExpiration(CONTRACT* c) {
  if(!c) return 0;
  return (c->Expiry - wdate()) / 86400; // Convert seconds to days
}

#include <contract.c>

var FuzzyRange = 0.1; // Adjust based on market volatility or strategy needs
var PremiumTarget = 100; // Example target premium from selling a call
var StrikeOffset = 50; // Offset from the current price for strike selection
int DaysToExpiration = 30; // Target days until expiration

// Initialize fuzzy logic settings - no changes needed here
void initFuzzyLogic() {
  FuzzyRange = 0.1; 
}

// Decision-making on whether to initiate an option combo trade
bool shouldSellCallOption(var currentPrice, var strikeOffset) {
  // Selling a call option if the current price plus strikeOffset is fuzzy-above the current price
  return fuzzy(aboveF(currentPrice + strikeOffset, currentPrice));
}

// Logic for closing position based on profit and days to expiration
bool shouldClosePosition(var tradeProfit, int daysToExpiration) {
  var profitCondition = aboveF(tradeProfit, PremiumTarget);
  var expirationCondition = belowF((var)daysToExpiration, 5.0); // Close if less than 5 days to expiration
  
  return fuzzy(orF(profitCondition, expirationCondition));
}

void run() {
  BarPeriod = 1440; // Use daily bars
  LookBack = 0; // No need for historical bars in this strategy
  StartDate = 2020;
  EndDate = 2024;
  assetList("AssetsIB");
  asset("SPY");
  AmericanOption = 1; // Trading American options
  
  initFuzzyLogic();

  if (!contractUpdate(Asset, 0, CALL)) return;

  if (is(EXITRUN)) return;

  // Decision to sell a call option
  if (NumOpenShort == 0 && shouldSellCallOption(priceClose(0), StrikeOffset)) {
    CONTRACT* CallContract = contractFind(CALL, DaysToExpiration, priceClose(0) + StrikeOffset);
    if (CallContract) {
      combo(CallContract, -1, 0, 0, 0, 0); // Prepare a combo to sell 1 call option
      enterShort(comboLeg(1)); // Enter short position on the combo leg
    }
  }

  // Loop through open trades to manage the position
  for(open_trades) {
    if (TradeIsOption && TradeIsShort && shouldClosePosition(TradeProfit, daysToExpiration())) {
      exitTrade(ThisTrade); // Close the position based on fuzzy logic conditions
    }
  }
}

// You might need to implement or adjust the daysToExpiration function to suit your requirements
int daysToExpiration() {
  // Implement logic to calculate days to expiration for the current option combo
  return 10; // Placeholder return value
}

#include <contract.c>

vars PriceClose;

void run() {
    BarPeriod = 1440; // Daily bars for trend analysis
    LookBack = 30; // Looking back 30 bars for accurate trend detection
    StartDate = 2020;
    EndDate = 2024;
    assetList("AssetsIB");
    asset("SPY");

    PriceClose = series(priceClose());

    AmericanOption = 1; // Trading American Options
    
    if (is(EXITRUN)) return; // Exit if at the end of the backtest

    // Ensure the contract chain is updated for SPY
    if (!contractUpdate(Asset, 0, CALL | PUT)) return;

    // Entry Logic: Detect a rising trend to sell a call option
    if (NumOpenLong + NumOpenShort == 0) { // Check if there's no open position
        var trendStrength = risingF(PriceClose); // Assess the rising trend strength
        if (trendStrength > 0.5) { // Threshold for a strong rising trend
            // Define the strike price a bit above the current price for selling a call
            var StrikeCall = priceClose(0) + 100; // Offset from the current price for the strike
            int CallContract = contractFind(CALL, 45, StrikeCall); // Find a call option 45 days to expiration
            if (CallContract >= 0) {
                CONTRACT* c = contract(CallContract);
                if (combo(c, -1, 0, 0, 0, 0, 0, 0) > 0) { // Prepare the combo for selling 1 call
                    enterShort(comboLeg(1)); // Enter short for the call option leg
                }
            }
        }
    }

    // Exit Logic: Close the short call option position on a falling trend
    for(open_trades) {
        if (TradeIsOption && TradeIsShort) {
            var reversalStrength = fallingF(PriceClose); // Assess the strength of the falling trend
            if (reversalStrength > 0.5) { // Threshold indicating a strong downward trend
                exitTrade(ThisTrade); // Close the call option position
            }
        }
    }
}

#include <contract.c>

vars PriceClose;
var Volatility;

void initFuzzyLogicSettings() {
  FuzzyRange = 0.05; // Adjust based on backtesting
}

var calculateVolatility(vars Data, int period) {
  var sumDelta = 0;
  for(int i = 1; i <= period; i++) {
    sumDelta += abs(Data[i] - Data[i-1]);
  }
  return sumDelta / period;
}

var adjustFuzzyForVolatility(var fuzzyValue) {
  var adjustmentFactor = 1 + Volatility * 10;
  return clamp(fuzzyValue / adjustmentFactor, 0, 1);
}

bool fuzzyEntryCondition(vars Data) {
  var entryFuzzy = max(risingF(Data), valleyF(Data));
  return adjustFuzzyForVolatility(entryFuzzy) > 0.5;
}

bool fuzzyExitCondition(vars Data) {
  var exitFuzzy = max(fallingF(Data), peakF(Data));
  return adjustFuzzyForVolatility(exitFuzzy) > 0.5;
}

void optionComboTrade() {
  CONTRACT* C1; // Define pointer for the first leg of the combo
  CONTRACT* C2; // Define pointer for the second leg of the combo
  
  // Dynamically adjust option strike based on current price and volatility
  var strikeCall = round(priceClose(0) + 10 + Volatility * 5); // Example for call strike
  var strikePut = round(priceClose(0) - 10 - Volatility * 5); // Example for put strike
  
  // Initialize contracts for a strangle combo
  C1 = contractFind(CALL, 30, strikeCall); // Find call option contract
  C2 = contractFind(PUT, 30, strikePut); // Find put option contract

  // Check if contracts are found and if entry condition is met
  if(C1 && C2 && fuzzyEntryCondition(PriceClose)) {
    combo(C1, 1, C2, 1, 0, 0, 0, 0); // Create a strangle combo
    enterLong(comboLeg(1)); // Enter long on both legs of the combo
    enterLong(comboLeg(2));
  }
}

void run() {
  BarPeriod = 60;
  LookBack = 100;
  StartDate = 2020;
  EndDate = 2024;
  assetList("AssetsIB");
  asset("SPY");

  PriceClose = series(priceClose());
  initFuzzyLogicSettings();

  Volatility = calculateVolatility(PriceClose, 20); // Calculate market volatility

  if (is(EXITRUN)) return;

  optionComboTrade(); // Execute the option combo trade based on fuzzy logic conditions
}

#include <contract.c>

vars PriceClose, VolatilityEMA;

void init() {
  assetList("AssetsIB");
  BarPeriod = 60; // Setting bar period for the price series
  LookBack = 100; // Lookback period for technical indicators

  PriceClose = series(priceClose());
  initFuzzyLogicSettings();
  calculateEMAVolatility(20); // Initialize volatility calculation
}

void initFuzzyLogicSettings() {
  FuzzyRange = 0.05; // Adjust based on backtesting
}

void calculateEMAVolatility(int period) {
  vars ATRValues = series(ATR(period));
  VolatilityEMA = series(EMA(ATRValues, period));
}

void tradeOptions() {
  // Assuming current asset is SPY and we're setting up a strangle
  if (NumOpenLong == 0 && fuzzyEntryCondition()) {
    // Find contracts for the call and put options
    CONTRACT* callContract = contractFind("Call", 30, priceClose(0) + 10); // Example: 30 days to expiration, strike 10 points above
    CONTRACT* putContract = contractFind("Put", 30, priceClose(0) - 10); // Example: 30 days to expiration, strike 10 points below

    if(callContract && putContract) {
      // Setup the combo - buying 1 call and 1 put
      combo(callContract, 1, putContract, 1, 0, 0, 0, 0);
      
      // Enter the combo trade
      enterLong(comboLeg(1)); // Enter long for the call option leg
      enterLong(comboLeg(2)); // Enter long for the put option leg
      
      printf("\nEntered a Strangle on SPY");
    }
  }
}

void run() {
  StartDate = 2020;
  EndDate = 2024;
  assetList("AssetsIB");
  asset("SPY");

  while(asset(loop("SPY","AAPL","MSFT"))) {
    if (is(EXITRUN)) continue;
    tradeOptions();
  }
}

#include <contract.h>

// Initialize global variables for storing price and volatility data
vars PriceClose, VolatilityEMA;

void init() {
  assetList("AssetsIB");
  BarPeriod = 60;
  LookBack = 100;
  StartDate = 2020;
  EndDate = 2024;
  
  PriceClose = series(priceClose());
  initFuzzyLogicSettings();
  calculateEMAVolatility(20); // Initialize volatility calculation
}

void initFuzzyLogicSettings() {
  FuzzyRange = 0.05; // Adjust based on backtesting
}

void calculateEMAVolatility(int period) {
  vars ATRValues = series(ATR(period));
  VolatilityEMA = series(EMA(ATRValues, period));
}

// Cumulative Normal Distribution Function for use in Black-Scholes Model
var CNDF(var x) {
  int neg = (x < 0.0) ? 1 : 0;
  if (neg) x = -x;
  
  var k = (1.0 / ( 1.0 + 0.2316419 * x));
  var y = (((1.330274429 * k - 1.821255978) * k + 1.781477937) *
           k - 0.356563782) * k + 0.319381530;
  y = 1.0 - 0.398942280401 * exp(-0.5 * x * x) * y;
  
  return (1.0 - neg) * y + neg * (1.0 - y);
}

// Black-Scholes Option Pricing Model
var BlackScholes(char *CallPutFlag, var S, var X, var T, var r, var v) {
  var d1, d2;
  d1 = (log(S / X) + (r + 0.5 * v * v) * T) / (v * sqrt(T));
  d2 = d1 - v * sqrt(T);
  
  if (CallPutFlag[0] == 'c' || CallPutFlag[0] == 'C') {
    return S * CNDF(d1) - X * exp(-r * T) * CNDF(d2);
  } else {
    return X * exp(-r * T) * CNDF(-d2) - S * CNDF(-d1);
  }
}

bool fuzzyEntryCondition() {
  return risingF(PriceClose) > 0.5 && VolatilityEMA[0] < 0.2;
}

bool fuzzyExitCondition() {
  return fallingF(PriceClose) > 0.5 || VolatilityEMA[0] > 0.3;
}

void tradeOptions() {
  CONTRACT* CallContract;
  CONTRACT* PutContract;
  var strikePrice = round(priceClose(0),100); // Example for rounding to nearest hundred
  var expirationDays = 30; // Targeting options 30 days to expiration

  if (fuzzyEntryCondition()) {
    // Prepare to trade a call option
    CallContract = contractFind("Call", strikePrice, wdate() + expirationDays * 86400);
    if(CallContract) {
      // Buy the call option
      combo(CallContract, 1, 0, 0, 0, 0, 0, 0);
      enterLong(comboLeg(1));
    }
  } else if (fuzzyExitCondition()) {
    // Prepare to trade a put option
    PutContract = contractFind("Put", strikePrice, wdate() + expirationDays * 86400);
    if(PutContract) {
      // Buy the put option
      combo(0, 0, PutContract, 1, 0, 0, 0, 0);
      enterLong(comboLeg(2));
    }
  }
}

void main() {
  init();
  while(asset(loop("Assets"))) {
    if (is(EXITRUN)) continue;
    tradeOptions(); // Execute the option trading logic based on market conditions
  }
}

#include <contract.h>

// Initialize global variables for storing price and volatility data
vars PriceClose, VolatilityEMA, BollingerBands, StdDevVolatility;

// Parameter optimization
var BarPeriod, LookBack, FuzzyRange, emaPeriod, StopLoss, TakeProfit, Lots, threshold, momentumThreshold;

void init() {
  assetList("AssetsIB");
  BarPeriod = optimize(60, 30, 120, 10);
  LookBack = optimize(100, 50, 200, 10);
  FuzzyRange = optimize(0.05, 0.01, 0.1, 0.01);
  emaPeriod = optimize(20, 10, 50, 5);
  
  PriceClose = series(priceClose());
  calculateEMAVolatility(emaPeriod); // Initialize volatility calculation
  
  // Initialize additional volatility measures
  BollingerBands = series(BBands(priceClose(), 20, 2));
  StdDevVolatility = series(StdDev(priceClose(), 20));
  
  // Risk management parameters
  StopLoss = optimize(50, 10, 100, 10) * ATR(20);
  TakeProfit = optimize(100, 50, 200, 10) * ATR(20);
  
  // Position sizing
  Lots = optimize(1, 0.1, 2, 0.1) * (1 / VolatilityEMA[0]);
}

void calculateEMAVolatility(int period) {
  vars ATRValues = series(ATR(period));
  VolatilityEMA = series(EMA(ATRValues, period));
}

// Cumulative Normal Distribution Function for use in Black-Scholes Model
var CNDF(var x) {
  int neg = (x < 0.0) ? 1 : 0;
  if (neg) x = -x;
  
  var k = (1.0 / ( 1.0 + 0.2316419 * x));
  var y = (((1.330274429 * k - 1.821255978) * k + 1.781477937) *
           k - 0.356563782) * k + 0.319381530;
  y = 1.0 - 0.398942280401 * exp(-0.5 * x * x) * y;
  
  return (1.0 - neg) * y + neg * (1.0 - y);
}

// Black-Scholes Option Pricing Model
var BlackScholes(char *CallPutFlag, var S, var X, var T, var r, var v) {
  var d1, d2;
  d1 = (log(S / X) + (r + 0.5 * v * v) * T) / (v * sqrt(T));
  d2 = d1 - v * sqrt(T);
  
  if (CallPutFlag[0] == 'c' || CallPutFlag[0] == 'C') {
    return S * CNDF(d1) - X * exp(-r * T) * CNDF(d2);
  } else {
    return X * exp(-r * T) * CNDF(-d2) - S * CNDF(-d1);
  }
}

bool enhancedFuzzyEntryCondition() {
  return risingF(PriceClose) > 0.5 && VolatilityEMA[0] < 0.2 && RSI(PriceClose, 14) < 30 && additionalFilters();
}

bool enhancedFuzzyExitCondition() {
  return fallingF(PriceClose) > 0.5 || VolatilityEMA[0] > 0.3;
}

bool additionalFilters() {
  return MarketVolatility() > threshold && momentum > momentumThreshold;
}

void tradeOptions() {
  CONTRACT* CallContract;
  CONTRACT* PutContract;
  var strikePrice = round(priceClose(0), 100); // Example for rounding to nearest hundred
  var expirationDays = 30; // Targeting options 30 days to expiration

  if (enhancedFuzzyEntryCondition()) {
    // Prepare to trade a call option
    CallContract = contractFind("Call", strikePrice, wdate() + expirationDays * 86400);
    if(CallContract) {
      // Buy the call option
      combo(CallContract, 1, 0, 0, 0, 0, 0, 0);
      enterLong(comboLeg(1));
    }
  } else if (enhancedFuzzyExitCondition()) {
    // Prepare to trade a put option
    PutContract = contractFind("Put", strikePrice, wdate() + expirationDays * 86400);
    if(PutContract) {
      // Buy the put option
      combo(0, 0, PutContract, 1, 0, 0, 0, 0);
      enterLong(comboLeg(2));
    }
  }
}

void run() {
  if (is(INITRUN)) {
    init();
    set(TESTNOW | TRAINMODE);
  }
  
  while(asset(loop("Assets"))) {
    if (is(EXITRUN)) continue;
    tradeOptions(); // Execute the option trading logic based on market conditions

    // Debugging and logging
    if (is(LOGFILE)) {
      log("Entering trade: PriceClose = %.2f, VolatilityEMA = %.2f", PriceClose[0], VolatilityEMA[0]);
    }
  }
  
  // Machine learning integration
  if(is(TRAINMODE)) {
    trainModel(PriceClose, LookBack);
  } else {
    var prediction = predictModel(PriceClose, LookBack);
    if(prediction > threshold) {
      enterLong();
    } else if(prediction < -threshold) {
      enterShort();
    }
  }
}

#include <default.c>

var alpha, beta;
var filt, filttr, hband, lband;
vars PriceClose, GaussianFiltered, GaussianFilteredTR;

void init() {
  BarPeriod = 60; // 1-hour bars
  LookBack = 144; // Lookback period for the Gaussian filter

  PriceClose = series(priceClose());
  GaussianFiltered = series(0);
  GaussianFilteredTR = series(0);
  
  alpha = calculateAlpha(144, 4); // Sampling Period and Poles
  beta = (1 - cos(2 * PI / 144)) / (pow(1.414, 2 / 4) - 1);
}

var calculateAlpha(int period, int poles) {
  var beta = (1 - cos(2 * PI / period)) / (pow(1.414, 2 / poles) - 1);
  return -beta + sqrt(beta * beta + 2 * beta);
}

void calculateGaussianFilter(vars src, int poles, int period) {
  vars filtSeries = series(0);
  vars filtSeriesTR = series(0);
  var lag = (period - 1) / (2 * poles);
  vars srcData = series(0);
  vars trData = series(0);
  
  for(int i = 0; i < Bar; i++) {
    if(i > lag) {
      srcData[i] = src[i] + (src[i] - src[i - lag]);
      trData[i] = TR() + (TR() - TR(lag));
    } else {
      srcData[i] = src[i];
      trData[i] = TR();
    }
  }
  
  for(int i = 0; i < Bar; i++) {
    filtSeries[i] = filt9x(alpha, srcData[i], 1, poles);
    filtSeriesTR[i] = filt9x(alpha, trData[i], 1, poles);
  }
  
  GaussianFiltered[0] = filtSeries[0];
  GaussianFilteredTR[0] = filtSeriesTR[0];
  
  hband = GaussianFiltered[0] + GaussianFilteredTR[0] * 1.414;
  lband = GaussianFiltered[0] - GaussianFilteredTR[0] * 1.414;
}

var filt9x(var a, var s, int i, int poles) {
  static vars f[10];
  var x = 1 - a;
  var filt = pow(a, i) * s + i * x * f[1] - (i >= 2 ? 36 * pow(x, 2) * f[2] : 0) + (i >= 3 ? 84 * pow(x, 3) * f[3] : 0)
            - (i >= 4 ? 126 * pow(x, 4) * f[4] : 0) + (i >= 5 ? 126 * pow(x, 5) * f[5] : 0) - (i >= 6 ? 84 * pow(x, 6) * f[6] : 0)
            + (i >= 7 ? 36 * pow(x, 7) * f[7] : 0) - (i >= 8 ? 9 * pow(x, 8) * f[8] : 0) + (i == 9 ? 1 * pow(x, 9) * f[9] : 0);
  
  for(int j = 9; j > 0; j--) {
    f[j] = f[j - 1];
  }
  f[0] = filt;
  
  return filt;
}

bool crossOver(vars data, var level) {
  return (data[1] < level && data[0] >= level);
}

bool crossUnder(vars data, var level) {
  return (data[1] > level && data[0] <= level);
}

void run() {
  if(is(INITRUN)) {
    init();
  }

  calculateGaussianFilter(PriceClose, 4, 144);
  
  bool longCondition = crossOver(priceClose(), hband);
  bool closeAllCondition = crossUnder(priceClose(), hband);

  if (longCondition) {
    enterLong();
  }

  if (closeAllCondition) {
    exitLong();
  }
}

#include <default.c>

var alpha, beta;
var filt, filttr, hband, lband;
vars PriceClose, GaussianFiltered, GaussianFilteredTR;

// Define additional factor variables
vars FactorExposure, MarketCap, IndustryData;
var beta0, betaFactor, betaMktCap, betaIndustry;

// Initialize factors for each time period
void initFactors() {
  FactorExposure = series(0);
  MarketCap = series(0);
  IndustryData = series(0);
  
  // Set coefficients based on your model or optimization
  beta0 = 0.01;
  betaFactor = 0.02;
  betaMktCap = 0.03;
  betaIndustry = 0.04;
}

void init() {
  BarPeriod = 60; // 1-hour bars
  LookBack = 144; // Lookback period for the Gaussian filter

  PriceClose = series(priceClose());
  GaussianFiltered = series(0);
  GaussianFilteredTR = series(0);
  
  alpha = calculateAlpha(144, 4); // Sampling Period and Poles
  beta = (1 - cos(2 * PI / 144)) / (pow(1.414, 2 / 4) - 1);
  
  initFactors();
}

var calculateAlpha(int period, int poles) {
  var beta = (1 - cos(2 * PI / period)) / (pow(1.414, 2 / poles) - 1);
  return -beta + sqrt(beta * beta + 2 * beta);
}

void calculateGaussianFilter(vars src, int poles, int period) {
  vars filtSeries = series(0);
  vars filtSeriesTR = series(0);
  var lag = (period - 1) / (2 * poles);
  vars srcData = series(0);
  vars trData = series(0);
  
  for(int i = 0; i < Bar; i++) {
    if(i > lag) {
      srcData[i] = src[i] + (src[i] - src[i - lag]);
      trData[i] = TR() + (TR() - TR(lag));
    } else {
      srcData[i] = src[i];
      trData[i] = TR();
    }
  }
  
  for(int i = 0; i < Bar; i++) {
    filtSeries[i] = filt9x(alpha, srcData[i], 1, poles);
    filtSeriesTR[i] = filt9x(alpha, trData[i], 1, poles);
  }
  
  GaussianFiltered[0] = filtSeries[0];
  GaussianFilteredTR[0] = filtSeriesTR[0];
  
  hband = GaussianFiltered[0] + GaussianFilteredTR[0] * 1.414;
  lband = GaussianFiltered[0] - GaussianFilteredTR[0] * 1.414;
}

var filt9x(var a, var s, int i, int poles) {
  static vars f[10];
  var x = 1 - a;
  var filt = pow(a, i) * s + i * x * f[1] - (i >= 2 ? 36 * pow(x, 2) * f[2] : 0) + (i >= 3 ? 84 * pow(x, 3) * f[3] : 0)
            - (i >= 4 ? 126 * pow(x, 4) * f[4] : 0) + (i >= 5 ? 126 * pow(x, 5) * f[5] : 0) - (i >= 6 ? 84 * pow(x, 6) * f[6] : 0)
            + (i >= 7 ? 36 * pow(x, 7) * f[7] : 0) - (i >= 8 ? 9 * pow(x, 8) * f[8] : 0) + (i == 9 ? 1 * pow(x, 9) * f[9] : 0);
  
  for(int j = 9; j > 0; j--) {
    f[j] = f[j - 1];
  }
  f[0] = filt;
  
  return filt;
}

bool crossOver(vars data, var level) {
  return (data[1] < level && data[0] >= level);
}

bool crossUnder(vars data, var level) {
  return (data[1] > level && data[0] <= level);
}

// Predict returns based on factors
var predictReturn() {
  var predictedReturn = beta0 + betaFactor * FactorExposure[0] + betaMktCap * MarketCap[0] + betaIndustry * IndustryData[0];
  return predictedReturn;
}

void run() {
  if(is(INITRUN)) {
    init();
  }

  calculateGaussianFilter(PriceClose, 4, 144);
  
  bool longCondition = crossOver(priceClose(), hband) && predictReturn() > 0;
  bool closeAllCondition = crossUnder(priceClose(), hband) || predictReturn() < 0;

  if (longCondition) {
    enterLong();
  }

  if (closeAllCondition) {
    exitLong();
  }
}

#include <default.c>

// Variables
var alpha, beta;
var filt, filttr, hband, lband;
vars PriceClose, GaussianFiltered, GaussianFilteredTR;
vars UpperBand, LowerBand;

// Initialization
void init() {
  BarPeriod = 60; // 1-hour bars
  LookBack = 144; // Lookback period for the Gaussian filter

  PriceClose = series(priceClose());
  GaussianFiltered = series(0);
  GaussianFilteredTR = series(0);
  UpperBand = series(0);
  LowerBand = series(0);

  alpha = calculateAlpha(144, 4); // Sampling Period and Poles
  beta = (1 - cos(2 * PI / 144)) / (pow(1.414, 2 / 4) - 1);
}

// Calculate Alpha
var calculateAlpha(int period, int poles) {
  var beta = (1 - cos(2 * PI / period)) / (pow(1.414, 2 / poles) - 1);
  return -beta + sqrt(beta * beta + 2 * beta);
}

// Modified Gaussian Filter with Bands
var filt9x_with_bands(var a, var s, int poles, var deviationMultiplier, var* upperBand, var* lowerBand) {
  static vars f[10]; // Array to store previous filter values
  var x = 1 - a;
  var filt = s * a;

  // Precompute powers of x to avoid redundant calculations
  var x2 = x * x;
  var x3 = x2 * x;
  var x4 = x3 * x;
  var x5 = x4 * x;
  var x6 = x5 * x;
  var x7 = x6 * x;
  var x8 = x7 * x;
  var x9 = x8 * x;

  // Calculate the filter value iteratively
  for (int i = 1; i <= poles; i++) {
    switch (i) {
      case 1:
        filt += x * f[i];
        break;
      case 2:
        filt -= 36 * x2 * f[i];
        break;
      case 3:
        filt += 84 * x3 * f[i];
        break;
      case 4:
        filt -= 126 * x4 * f[i];
        break;
      case 5:
        filt += 126 * x5 * f[i];
        break;
      case 6:
        filt -= 84 * x6 * f[i];
        break;
      case 7:
        filt += 36 * x7 * f[i];
        break;
      case 8:
        filt -= 9 * x8 * f[i];
        break;
      case 9:
        filt += x9 * f[i];
        break;
    }
  }

  // Shift the previous values in the array
  for (int j = 9; j > 0; j--) {
    f[j] = f[j - 1];
  }
  f[0] = filt;

  // Calculate standard deviation of filter values
  var sum = 0, mean = 0, count = 10;
  for (int j = 0; j < count; j++) {
    sum += f[j];
  }
  mean = sum / count;

  var varianceSum = 0;
  for (int j = 0; j < count; j++) {
    varianceSum += (f[j] - mean) * (f[j] - mean);
  }
  var stddev = sqrt(varianceSum / count);

  // Calculate upper and lower bands
  *upperBand = filt + deviationMultiplier * stddev;
  *lowerBand = filt - deviationMultiplier * stddev;

  return filt;
}

// Gaussian Filter Calculation
void calculateGaussianFilter(vars src, int poles, int period) {
  vars filtSeries = series(0);
  vars filtSeriesTR = series(0);
  var lag = (period - 1) / (2 * poles);
  vars srcData = series(0);
  vars trData = series(0);
  
  for(int i = 0; i < Bar; i++) {
    if(i > lag) {
      srcData[i] = src[i] + (src[i] - src[i - lag]);
      trData[i] = TR() + (TR() - TR(lag));
    } else {
      srcData[i] = src[i];
      trData[i] = TR();
    }
  }
  
  for(int i = 0; i < Bar; i++) {
    var upper, lower;
    filtSeries[i] = filt9x_with_bands(alpha, srcData[i], poles, 1.414, &upper, &lower);
    filtSeriesTR[i] = filt9x_with_bands(alpha, trData[i], poles, 1.414, &upper, &lower);
    UpperBand[i] = upper;
    LowerBand[i] = lower;
  }
  
  GaussianFiltered[0] = filtSeries[0];
  GaussianFilteredTR[0] = filtSeriesTR[0];
  
  hband = UpperBand[0];
  lband = LowerBand[0];
}

// CrossOver and CrossUnder Functions
bool crossOver(vars data, var level) {
  return (data[1] < level && data[0] >= level);
}

bool crossUnder(vars data, var level) {
  return (data[1] > level && data[0] <= level);
}

// Main Trading Logic
void run() {
  if(is(INITRUN)) {
    init();
  }

  calculateGaussianFilter(PriceClose, 4, 144);
  
  bool longCondition = crossOver(priceClose(), hband);
  bool closeAllCondition = crossUnder(priceClose(), lband);

  if (longCondition) {
    enterLong();
  }

  if (closeAllCondition) {
    exitLong();
  }
}

#include <default.c>

// Variables
var alpha, beta;
var filt, filttr, hband, lband;
vars PriceClose, GaussianFiltered, GaussianFilteredTR;
vars UpperBand, LowerBand;

// Initialization
void init() {
    BarPeriod = 60; // 1-hour bars
    LookBack = 150; // Lookback period for the Gaussian filter

    PriceClose = series(priceClose());
    GaussianFiltered = series(0);
    GaussianFilteredTR = series(0);
    UpperBand = series(0);
    LowerBand = series(0);

    alpha = calculateAlpha(144, 4); // Sampling Period and Poles
    beta = (1 - cos(2 * PI / 144)) / (pow(1.414, 2 / 4) - 1);

    adviseLong(DTREE, 0, NULL, 0); // Initialize the Decision Tree model
}

// Calculate Alpha
var calculateAlpha(int period, int poles) {
    var beta = (1 - cos(2 * PI / period)) / (pow(1.414, 2 / poles) - 1);
    return -beta + sqrt(beta * beta + 2 * beta);
}

// Modified Gaussian Filter with Bands
var filt9x_with_bands(var a, var s, int poles, var deviationMultiplier, var* upperBand, var* lowerBand) {
    static vars f[10]; // Array to store previous filter values
    var x = 1 - a;
    var filt = s * a;

    // Precompute powers of x to avoid redundant calculations
    var x2 = x * x;
    var x3 = x2 * x;
    var x4 = x3 * x;
    var x5 = x4 * x;
    var x6 = x5 * x;
    var x7 = x6 * x;
    var x8 = x7 * x;
    var x9 = x8 * x;

    // Calculate the filter value iteratively
    for (int i = 1; i <= poles; i++) {
        switch (i) {
            case 1:
                filt += x * f[i];
                break;
            case 2:
                filt -= 36 * x2 * f[i];
                break;
            case 3:
                filt += 84 * x3 * f[i];
                break;
            case 4:
                filt -= 126 * x4 * f[i];
                break;
            case 5:
                filt += 126 * x5 * f[i];
                break;
            case 6:
                filt -= 84 * x6 * f[i];
                break;
            case 7:
                filt += 36 * x7 * f[i];
                break;
            case 8:
                filt -= 9 * x8 * f[i];
                break;
            case 9:
                filt += x9 * f[i];
                break;
        }
    }

    // Shift the previous values in the array
    for (int j = 9; j > 0; j--) {
        f[j] = f[j - 1];
    }
    f[0] = filt;

    // Calculate standard deviation of filter values
    var sum = 0, mean = 0, count = 10;
    for (int j = 0; j < count; j++) {
        sum += f[j];
    }
    mean = sum / count;

    var varianceSum = 0;
    for (int j = 0; j < count; j++) {
        varianceSum += (f[j] - mean) * (f[j] - mean);
    }
    var stddev = sqrt(varianceSum / count);

    // Calculate upper and lower bands
    *upperBand = filt + deviationMultiplier * stddev;
    *lowerBand = filt - deviationMultiplier * stddev;

    return filt;
}

// Gaussian Filter Calculation
void calculateGaussianFilter(vars src, int poles, int period) {
    vars filtSeries = series(0);
    vars filtSeriesTR = series(0);
    var lag = (period - 1) / (2 * poles);
    vars srcData = series(0);
    vars trData = series(0);
    
    for (int i = 0; i < Bar; i++) {
        if (i > lag) {
            srcData[i] = src[i] + (src[i] - src[i - lag]);
            trData[i] = TR() + (TR() - TR(lag));
        } else {
            srcData[i] = src[i];
            trData[i] = TR();
        }
    }
    
    for (int i = 0; i < Bar; i++) {
        var upper, lower;
        filtSeries[i] = filt9x_with_bands(alpha, srcData[i], poles, 1.414, &upper, &lower);
        filtSeriesTR[i] = filt9x_with_bands(alpha, trData[i], poles, 1.414, &upper, &lower);
        UpperBand[i] = upper;
        LowerBand[i] = lower;
    }
    
    GaussianFiltered[0] = filtSeries[0];
    GaussianFilteredTR[0] = filtSeriesTR[0];
    
    hband = UpperBand[0];
    lband = LowerBand[0];
}

// Main Trading Logic
void run() {
    BarPeriod = 60; // 1-hour bars
    LookBack = 150; // Lookback period
    TradesPerBar = 2;

    if (Train) {
        Hedge = 2; // Hedge during training
    }

    set(RULES | TESTNOW); // Set rules and test mode

    if (is(INITRUN)) {
        init();
    }

    calculateGaussianFilter(PriceClose, 4, 144);

    // Generate some signals from GaussianFiltered in the -100..100 range
    var Signals[2]; 
    Signals[0] = (GaussianFiltered[0] - GaussianFilteredTR[0]) / PIP;
    Signals[1] = 100 * FisherN(priceClose(), 100);

    // Train and trade the signals using the decision tree model
    if (adviseLong(DTREE, 0, Signals, 2) > 0)
        enterLong();
    if (adviseShort(DTREE, 0, Signals, 2) > 0)
        enterShort();
}

#include <default.c>

// Variables
var alpha, beta;
var filt, filttr, hband, lband;
vars PriceClose, GaussianFiltered, GaussianFilteredTR;
vars UpperBand, LowerBand;
var Signals[2];
var MetaSignals[2]; // Signals for the meta-model

// Initialization
void init() {
    BarPeriod = 60; // 1-hour bars
    LookBack = 150; // Lookback period for the Gaussian filter

    PriceClose = series(priceClose());
    GaussianFiltered = series(0);
    GaussianFilteredTR = series(0);
    UpperBand = series(0);
    LowerBand = series(0);

    alpha = calculateAlpha(144, 4); // Sampling Period and Poles
    beta = (1 - cos(2 * PI / 144)) / (pow(1.414, 2 / 4) - 1);

    adviseLong(DTREE, 0, NULL, 0); // Initialize the Decision Tree model
    adviseLong(NN, 0, NULL, 0); // Initialize the Neural Network model
    adviseLong(NN, 1, NULL, 0); // Initialize the Meta-Model Neural Network
}

// Calculate Alpha
var calculateAlpha(int period, int poles) {
    var beta = (1 - cos(2 * PI / period)) / (pow(1.414, 2 / poles) - 1);
    return -beta + sqrt(beta * beta + 2 * beta);
}

// Optimized Gaussian Filter with Bands
var filt9x_with_bands(var a, var s, int poles, var deviationMultiplier, var* upperBand, var* lowerBand) {
    static vars f[10]; // Array to store previous filter values
    var x = 1 - a;
    var filt = s * a;

    // Precompute powers of x to avoid redundant calculations
    var x_powers[10];
    x_powers[1] = x;
    for (int i = 2; i <= 9; i++) {
        x_powers[i] = x_powers[i - 1] * x;
    }

    // Calculate the filter value iteratively
    var coefficients[10] = {0, 1, -36, 84, -126, 126, -84, 36, -9, 1};
    for (int i = 1; i <= poles; i++) {
        filt += coefficients[i] * x_powers[i] * f[i];
    }

    // Shift the previous values in the array
    for (int j = 9; j > 0; j--) {
        f[j] = f[j - 1];
    }
    f[0] = filt;

    // Calculate mean and variance in a single pass
    var sum = 0, varianceSum = 0, count = 10;
    for (int j = 0; j < count; j++) {
        sum += f[j];
    }
    var mean = sum / count;

    for (int j = 0; j < count; j++) {
        varianceSum += (f[j] - mean) * (f[j] - mean);
    }
    var stddev = sqrt(varianceSum / count);

    // Calculate upper and lower bands
    *upperBand = filt + deviationMultiplier * stddev;
    *lowerBand = filt - deviationMultiplier * stddev;

    return filt;
}

// Gaussian Filter Calculation
void calculateGaussianFilter(vars src, int poles, int period) {
    vars filtSeries = series(0);
    vars filtSeriesTR = series(0);
    var lag = (period - 1) / (2 * poles);
    vars srcData = series(0);
    vars trData = series(0);
    
    for (int i = 0; i < Bar; i++) {
        if (i > lag) {
            srcData[i] = src[i] + (src[i] - src[i - lag]);
            trData[i] = TR() + (TR() - TR(lag));
        } else {
            srcData[i] = src[i];
            trData[i] = TR();
        }
    }
    
    for (int i = 0; i < Bar; i++) {
        var upper, lower;
        filtSeries[i] = filt9x_with_bands(alpha, srcData[i], poles, 1.414, &upper, &lower);
        filtSeriesTR[i] = filt9x_with_bands(alpha, trData[i], poles, 1.414, &upper, &lower);
        UpperBand[i] = upper;
        LowerBand[i] = lower;
    }
    
    GaussianFiltered[0] = filtSeries[0];
    GaussianFilteredTR[0] = filtSeriesTR[0];
    
    hband = UpperBand[0];
    lband = LowerBand[0];
}

// Meta-Model for Combining Predictions using Neural Network
var metaModel(var dtreePrediction, var nnPrediction) {
    MetaSignals[0] = dtreePrediction;
    MetaSignals[1] = nnPrediction;
    return advise(NN, 1, MetaSignals, 2); // Use another neural network (NN) model as meta-model
}

// Main Trading Logic
void run() {
    BarPeriod = 60; // 1-hour bars
    LookBack = 150; // Lookback period
    TradesPerBar = 2;

    if (Train) {
        Hedge = 2; // Hedge during training
    }

    set(RULES | TESTNOW); // Set rules and test mode

    if (is(INITRUN)) {
        init();
    }

    calculateGaussianFilter(PriceClose, 4, 144);

    // Generate some signals from GaussianFiltered in the -100..100 range
    Signals[0] = (GaussianFiltered[0] - GaussianFilteredTR[0]) / PIP;
    Signals[1] = 100 * FisherN(priceClose(), 100);

    // Train and trade the signals using decision tree and neural network models
    var dtreePrediction = advise(DTREE, 0, Signals, 2);
    var nnPrediction = advise(NN, 0, Signals, 2);

    var finalDecision = metaModel(dtreePrediction, nnPrediction);
    
    if (finalDecision > 0)
        enterLong();
    else if (finalDecision < 0)
        enterShort();
    else {
        if (isLong()) exitLong();
        if (isShort()) exitShort();
    }
}

import torch
from torch import nn, optim

# Example DRL Model (Adjust according to your architecture)
class TradingModel(nn.Module):
    def __init__(self):
        super(TradingModel, self).__init__()
        self.fc1 = nn.Linear(NumSignals, Neurons)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(Neurons, 1)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.sigmoid(self.fc2(x))
        return x

# Training function
def train_model(data_path, model_save_path):
    data = np.loadtxt(data_path, delimiter=',')  # Load data from CSV
    X, y = data[:, :-1], data[:, -1]
    X = torch.tensor(X, dtype=torch.float32)
    y = torch.tensor(y, dtype=torch.float32).view(-1, 1)

    model = TradingModel()
    criterion = nn.BCELoss()
    optimizer = optim.Adam(model.parameters(), lr=Rate)

    for epoch in range(Epochs):
        optimizer.zero_grad()
        predictions = model(X)
        loss = criterion(predictions, y)
        loss.backward()
        optimizer.step()

    # Save model for use in Zorro
    torch.save(model.state_dict(), model_save_path)

train_model("Data/Signals.csv", "model.pth")

import torch
import numpy as np
from TradingModel import TradingModel  # Import your model class

# Initialize model
model = TradingModel()
model.load_state_dict(torch.load("model.pth"))  # Load saved model
model.eval()  # Set model to evaluation mode

def predict(input_data):
    input_tensor = torch.tensor(input_data, dtype=torch.float32)
    with torch.no_grad():
        prediction = model(input_tensor)
    return prediction.item()

# Example usage for testing
# Replace [0.5, 1.2, -0.7, ...] with real data passed from Zorro
print(predict([0.5, 1.2, -0.7, ...]))  # Output a prediction for testing

function run()
{
    vars InputData = series(priceClose());
    double Data[NumSignals];
    for(int i = 0; i < NumSignals; i++)
        Data[i] = InputData[i];  // Gather recent data for model input

    // Save input data to CSV format expected by predict.py
    file_write("Data\\input_data.csv", Data, 0);

    // Call Python predict script and retrieve prediction
    Rx("Y <- predict('Data/input_data.csv')");
    var prediction = Rd("Y[1]"); // Assuming Y[1] holds the prediction result

    // Based on prediction, send buy or sell order
    if(prediction > 0.5)
        enterLong();  // Buy if prediction is above 0.5 threshold
    else
        enterShort(); // Sell if prediction is 0.5 or below
}

pip3 install torch numpy math

PythonPath64 = "C:\Users\YourName\AppData\Local\Programs\Python\Python312"

import torch
import torch.nn as nn
import numpy as np

class TradingModel(nn.Module):
    def __init__(self, input_size, hidden_size):
        super(TradingModel, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, 1)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.sigmoid(self.fc2(x))
        return x

# Initialize the model with input size and hidden layer size
model = TradingModel(input_size=8, hidden_size=256)  # Adjust based on your input features

# Load trained model weights if available
try:
    model.load_state_dict(torch.load("model.pth"))
    model.eval()
except FileNotFoundError:
    print("Model weights file not found. Train the model first.")

def predict(input_data):
    input_tensor = torch.tensor(input_data, dtype=torch.float32)
    with torch.no_grad():
        prediction = model(input_tensor)
    return prediction.item()

function run()
{
    vars InputData = series(priceClose());
    double Data[8];  // Adjust based on your input features
    for(int i = 0; i < 8; i++)
        Data[i] = InputData[i];  // Gather recent data for model input

    // Call the predict function in MyStrategy.py
    python("Y = predict", Data, 8); // Sends data to the Python function `predict`
    var prediction = python("Y");   // Retrieve the prediction result from Python

    // Trade decision based on prediction
    if(prediction > 0.5) enterLong();
    else enterShort();
}

function run()
{
    vars InputData = series(priceClose());  // Example data series
    
    // Save data to CSV file for the DRL model
    file_write("Data/live_data.csv", InputData, 0);

    // Execute trades based on external signals
    var signal = file_read("Data/drl_signal.txt");  // Read DRL action signal
    if (signal > 0.5)
        enterLong();
    else if (signal <= 0.5)
        enterShort();
}

import torch
import numpy as np
import time
from model import TradingModel  # Define your model in model.py

model = TradingModel(input_size=8, hidden_size=256)
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
criterion = torch.nn.BCELoss()

def train_model(input_data, target):
    model.train()
    input_tensor = torch.tensor(input_data, dtype=torch.float32)
    target_tensor = torch.tensor([target], dtype=torch.float32)

    optimizer.zero_grad()
    prediction = model(input_tensor)
    loss = criterion(prediction, target_tensor)
    loss.backward()
    optimizer.step()
    return loss.item()

while True:
    # Read the latest data from live_data.csv
    try:
        data = np.loadtxt("Data/live_data.csv", delimiter=',')
        input_data = data[-1]  # Get the most recent row of data
        prediction = model(torch.tensor(input_data, dtype=torch.float32)).item()
        
        # Save the action decision back to a file that Zorro reads
        with open("Data/drl_signal.txt", "w") as f:
            f.write("1" if prediction > 0.5 else "0")  # Save the signal for Zorro
        
        # Optionally train model with feedback (e.g., profit from the last trade)
        # target = get_trade_feedback()  # You may define a function to get trade results
        # train_model(input_data, target)

    except Exception as e:
        print(f"Error reading data or training model: {e}")

    time.sleep(1)  # Polling interval, adjust based on data frequency

import socket
import torch
import numpy as np
from model import TradingModel

model = TradingModel(input_size=8, hidden_size=256)

# Initialize socket server
HOST = 'localhost'  
PORT = 65432        
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind((HOST, PORT))
server.listen()

print("Waiting for Zorro connection...")

conn, addr = server.accept()
print(f"Connected by {addr}")

while True:
    data = conn.recv(1024)  # Adjust buffer size as needed
    if not data:
        break
    
    # Convert data to numpy array
    input_data = np.frombuffer(data, dtype=np.float32)
    
    # Make a prediction
    prediction = model(torch.tensor(input_data)).item()

    # Send decision to Zorro
    decision = b'1' if prediction > 0.5 else b'0'
    conn.sendall(decision)

function run()
{
    vars InputData = series(priceClose());
    double Data[NumSignals];
    for(int i = 0; i < NumSignals; i++)
        Data[i] = InputData[i];

    // Send data to Python via socket
    int socket = socket_connect("localhost", 65432);
    if (socket != 0) {
        socket_send(socket, Data, sizeof(Data));  // Send data
        int action = socket_receive(socket);      // Receive action decision
        socket_close(socket);

        // Act on received decision
        if (action == '1')
            enterLong();
        else if (action == '0')
            enterShort();
    }
}

#include <winsock2.h>
#include <ws2tcpip.h>

#pragma comment(lib, "ws2_32.lib")

extern "C" {
    SOCKET sock = INVALID_SOCKET;

    __declspec(dllexport) int socket_connect(const char* ip, int port) {
        WSADATA wsaData;
        WSAStartup(MAKEWORD(2,2), &wsaData);
        
        sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (sock == INVALID_SOCKET) return -1;

        sockaddr_in clientService;
        clientService.sin_family = AF_INET;
        clientService.sin_addr.s_addr = inet_addr(ip);
        clientService.sin_port = htons(port);

        if (connect(sock, (SOCKADDR*)&clientService, sizeof(clientService)) == SOCKET_ERROR) {
            closesocket(sock);
            WSACleanup();
            return -1;
        }
        return 0;
    }

    __declspec(dllexport) int socket_send(const char* data, int length) {
        if (sock == INVALID_SOCKET) return -1;
        return send(sock, data, length, 0);
    }

    __declspec(dllexport) int socket_receive(char* buffer, int length) {
        if (sock == INVALID_SOCKET) return -1;
        return recv(sock, buffer, length, 0);
    }

    __declspec(dllexport) void socket_close() {
        if (sock != INVALID_SOCKET) {
            closesocket(sock);
            WSACleanup();
        }
    }
}

function run()
{
    // Load the socket DLL
    int connect_result = call("SocketDLL.dll", "socket_connect", "localhost", 65432);

    if (connect_result == 0) {
        printf("\nConnected to socket.");

        // Example data to send
        double data[8] = { 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9 };
        call("SocketDLL.dll", "socket_send", data, sizeof(data));

        // Buffer for receiving data
        char buffer[8];
        int bytes_received = call("SocketDLL.dll", "socket_receive", buffer, sizeof(buffer));
        
        if (bytes_received > 0) {
            printf("\nReceived data: %s", buffer);  // Example printout
        }
        
        // Close the socket connection
        call("SocketDLL.dll", "socket_close");
    } else {
        printf("\nFailed to connect to socket.");
    }
}

import socket

HOST = 'localhost'
PORT = 65432

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind((HOST, PORT))
server.listen()
print("Server listening...")

conn, addr = server.accept()
print(f"Connected by {addr}")

while True:
    data = conn.recv(1024)
    if not data:
        break
    print("Received data:", data)

    # Send response
    response = b"1"  # For example, send a '1' signal for buy
    conn.sendall(response)

conn.close()

import socket
import torch
import numpy as np
from model import TradingModel  # Assume TradingModel is defined appropriately

# Initialize models and load them if available
agents = {
    "EURUSD": TradingModel(input_size=5, hidden_layers=2, neurons_per_layer=64),
    "GBPUSD": TradingModel(input_size=5, hidden_layers=2, neurons_per_layer=64),
    "EURGBP": TradingModel(input_size=5, hidden_layers=2, neurons_per_layer=64)
}

for name, model in agents.items():
    try:
        model.load_state_dict(torch.load(f"{name}_model.pth"))
        model.eval()
    except FileNotFoundError:
        print(f"No saved model found for {name}, starting fresh.")

# Start a socket server to handle prediction requests
HOST = 'localhost'
PORT = 65432
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind((HOST, PORT))
server.listen()
print("Waiting for Zorro connection...")

conn, addr = server.accept()
print(f"Connected by {addr}")

while True:
    data = conn.recv(1024)
    if not data:
        break
    
    try:
        # Parse data to identify agent and extract feature inputs
        data_str = data.decode().split(',')
        agent_name = data_str[0]
        input_data = np.array(data_str[1:], dtype=np.float32)
        
        # Make a prediction if the agent exists
        if agent_name in agents:
            model = agents[agent_name]
            input_tensor = torch.tensor(input_data, dtype=torch.float32)
            with torch.no_grad():
                prediction = model(input_tensor).item()
            decision = '1' if prediction > 0.5 else '0'
        else:
            decision = '0'  # Default action if agent is unrecognized

        # Send the prediction decision back to Zorro
        conn.sendall(decision.encode())

    except Exception as e:
        print(f"Error processing request: {e}")
        break

conn.close()

function run()
{
    // Define data feeds for each pair
    double EURUSD_Data[5] = { priceHigh(), priceLow(), priceClose(), priceOpen(), Vol() };
    double GBPUSD_Data[5] = { priceHigh(), priceLow(), priceClose(), priceOpen(), Vol() };
    double EURGBP_Data[5] = { priceHigh(), priceLow(), priceClose(), priceOpen(), Vol() };

    // Connect to Python server
    int socket = socket_connect("localhost", 65432);
    if (socket == 0) {
        printf("\nFailed to connect to Python socket.");
        return;
    }

    // Agent 1: EURUSD - Send data and get prediction
    string eurusd_data_str = strf("EURUSD,%f,%f,%f,%f,%f", EURUSD_Data[0], EURUSD_Data[1], EURUSD_Data[2], EURUSD_Data[3], EURUSD_Data[4]);
    socket_send(socket, eurusd_data_str, strlen(eurusd_data_str));
    char buffer[2];
    int bytes_received = socket_receive(socket, buffer, sizeof(buffer));
    if (bytes_received > 0 && buffer[0] == '1')
        enterLong("EURUSD");
    else
        enterShort("EURUSD");

    // Agent 2: GBPUSD - Send data and get prediction
    string gbpusd_data_str = strf("GBPUSD,%f,%f,%f,%f,%f", GBPUSD_Data[0], GBPUSD_Data[1], GBPUSD_Data[2], GBPUSD_Data[3], GBPUSD_Data[4]);
    socket_send(socket, gbpusd_data_str, strlen(gbpusd_data_str));
    bytes_received = socket_receive(socket, buffer, sizeof(buffer));
    if (bytes_received > 0 && buffer[0] == '1')
        enterLong("GBPUSD");
    else
        enterShort("GBPUSD");

    // Agent 3: EURGBP - Send data and get prediction
    string eurgbp_data_str = strf("EURGBP,%f,%f,%f,%f,%f", EURGBP_Data[0], EURGBP_Data[1], EURGBP_Data[2], EURGBP_Data[3], EURGBP_Data[4]);
    socket_send(socket, eurgbp_data_str, strlen(eurgbp_data_str));
    bytes_received = socket_receive(socket, buffer, sizeof(buffer));
    if (bytes_received > 0 && buffer[0] == '1')
        enterLong("EURGBP");
    else
        enterShort("EURGBP");

    // Close socket connection
    socket_close(socket);
}

#define PAIRS 28 // Number of currency pairs

string CurrencyPairs[PAIRS] = {
    "EURUSD", "GBPUSD", "USDJPY", "GBPJPY", "USDCAD", "EURAUD", "EURJPY", 
    "AUDCAD", "AUDJPY", "AUDNZD", "AUDUSD", "CADJPY", "EURCAD", "EURCHF", 
    "EURGBP", "EURNZD", "GBPCAD", "GBPCHF", "NZDCAD", "NZDJPY", "NZDUSD", 
    "USDCHF", "CHFJPY", "AUDCHF", "GBPNZD", "NZDCHF", "CADCHF", "GBPAUD"
};

vars CorrelationMatrix[PAIRS][PAIRS]; // Correlation adjacency matrix
vars ArbitrageMatrix[PAIRS][PAIRS];  // Arbitrage adjacency matrix
int StateMatrix[PAIRS][3][3];        // Transition matrix for each pair
int LookBack = 200;                 // Lookback period for calculations

// Function to calculate correlation between two series
function calculateCorrelation(vars series1, vars series2, int len) {
    var mean1 = SMA(series1, len);
    var mean2 = SMA(series2, len);
    var numerator = 0, denom1 = 0, denom2 = 0;
    for (int i = 0; i < len; i++) {
        numerator += (series1[i] - mean1) * (series2[i] - mean2);
        denom1 += pow(series1[i] - mean1, 2);
        denom2 += pow(series2[i] - mean2, 2);
    }
    return numerator / sqrt(denom1 * denom2);
}

// Initialize the correlation network
function initializeCorrelationNetwork() {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            if (i != j) {
                vars series1 = series(price(CurrencyPairs[i]));
                vars series2 = series(price(CurrencyPairs[j]));
                CorrelationMatrix[i][j] = calculateCorrelation(series1, series2, LookBack);
            } else {
                CorrelationMatrix[i][j] = 1; // Self-correlation
            }
        }
    }
}

// Calculate arbitrage opportunities between pairs
function calculateArbitrage() {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            if (i != j) {
                ArbitrageMatrix[i][j] = log(price(CurrencyPairs[i]) / price(CurrencyPairs[j]));
            } else {
                ArbitrageMatrix[i][j] = 0; // No arbitrage within the same pair
            }
        }
    }
}

// Detect arbitrage cycles using a Bellman-Ford-like algorithm
function detectArbitrageCycles() {
    for (int k = 0; k < PAIRS; k++) {
        for (int i = 0; i < PAIRS; i++) {
            for (int j = 0; j < PAIRS; j++) {
                if (ArbitrageMatrix[i][k] + ArbitrageMatrix[k][j] < ArbitrageMatrix[i][j]) {
                    ArbitrageMatrix[i][j] = ArbitrageMatrix[i][k] + ArbitrageMatrix[k][j];
                }
            }
        }
    }
}

// Get the current market state for a currency pair
function getState(string pair) {
    var fastMA = SMA(series(price(pair)), 50);
    var slowMA = SMA(series(price(pair)), 200);
    if (fastMA > slowMA) return 1;  // Bull
    else if (fastMA < slowMA) return -1; // Bear
    return 0;  // Sideways
}

// Update the state transition matrix
function updateStateTransition(int pairIndex) {
    int currentState = getState(CurrencyPairs[pairIndex]);
    int lastState = StateMatrix[pairIndex][2]; // Store last state
    StateMatrix[pairIndex][lastState + 1][currentState + 1]++;
    StateMatrix[pairIndex][2] = currentState; // Update last state
}

// Main trading function
function run() {
    set(PLOTNOW);

    // Initialize networks
    initializeCorrelationNetwork();
    calculateArbitrage();

    // Update state transitions for each pair
    for (int i = 0; i < PAIRS; i++) {
        updateStateTransition(i);
    }

    // Example: Trade when arbitrage is detected
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            if (ArbitrageMatrix[i][j] > 0.01) { // Arbitrage threshold
                enterLong(CurrencyPairs[i]);
                enterShort(CurrencyPairs[j]);
            }
        }
    }
}

#define PAIRS 28 // Number of currency pairs

string CurrencyPairs[PAIRS] = {
    "EURUSD", "GBPUSD", "USDJPY", "GBPJPY", "USDCAD", "EURAUD", "EURJPY", 
    "AUDCAD", "AUDJPY", "AUDNZD", "AUDUSD", "CADJPY", "EURCAD", "EURCHF", 
    "EURGBP", "EURNZD", "GBPCAD", "GBPCHF", "NZDCAD", "NZDJPY", "NZDUSD", 
    "USDCHF", "CHFJPY", "AUDCHF", "GBPNZD", "NZDCHF", "CADCHF", "GBPAUD"
};

vars CorrelationMatrix[PAIRS][PAIRS]; // Correlation adjacency matrix
vars ArbitrageMatrix[PAIRS][PAIRS];  // Arbitrage adjacency matrix
vars RiskMatrix[PAIRS];             // Risk matrix for each pair (e.g., volatility)
int StateMatrix[PAIRS][3][3];       // Transition matrix for each pair
vars PortfolioWeights[PAIRS];       // Optimized portfolio weights
int LookBack = 200;                 // Lookback period for calculations

// Function to calculate correlation between two series
function calculateCorrelation(vars series1, vars series2, int len) {
    var mean1 = SMA(series1, len);
    var mean2 = SMA(series2, len);
    var numerator = 0, denom1 = 0, denom2 = 0;
    for (int i = 0; i < len; i++) {
        numerator += (series1[i] - mean1) * (series2[i] - mean2);
        denom1 += pow(series1[i] - mean1, 2);
        denom2 += pow(series2[i] - mean2, 2);
    }
    return numerator / sqrt(denom1 * denom2);
}

// Initialize the correlation network
function initializeCorrelationNetwork() {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            if (i != j) {
                vars series1 = series(price(CurrencyPairs[i]));
                vars series2 = series(price(CurrencyPairs[j]));
                CorrelationMatrix[i][j] = calculateCorrelation(series1, series2, LookBack);
            } else {
                CorrelationMatrix[i][j] = 1; // Self-correlation
            }
        }
    }
}

// Calculate arbitrage opportunities between pairs
function calculateArbitrage() {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            if (i != j) {
                ArbitrageMatrix[i][j] = log(price(CurrencyPairs[i]) / price(CurrencyPairs[j]));
            } else {
                ArbitrageMatrix[i][j] = 0; // No arbitrage within the same pair
            }
        }
    }
}

// Calculate risk for each pair (volatility-based)
function calculateRiskMatrix() {
    for (int i = 0; i < PAIRS; i++) {
        RiskMatrix[i] = StdDev(series(price(CurrencyPairs[i])), LookBack);
    }
}

// Optimize portfolio weights based on risk and correlation
function optimizePortfolio() {
    var TotalWeight = 0;
    for (int i = 0; i < PAIRS; i++) {
        PortfolioWeights[i] = 1 / RiskMatrix[i]; // Risk-based weighting
        TotalWeight += PortfolioWeights[i];
    }
    for (int i = 0; i < PAIRS; i++) {
        PortfolioWeights[i] /= TotalWeight; // Normalize weights
    }
}

// Detect arbitrage cycles using a Bellman-Ford-like algorithm
function detectArbitrageCycles() {
    for (int k = 0; k < PAIRS; k++) {
        for (int i = 0; i < PAIRS; i++) {
            for (int j = 0; j < PAIRS; j++) {
                if (ArbitrageMatrix[i][k] + ArbitrageMatrix[k][j] < ArbitrageMatrix[i][j]) {
                    ArbitrageMatrix[i][j] = ArbitrageMatrix[i][k] + ArbitrageMatrix[k][j];
                }
            }
        }
    }
}

// Get the current market state for a currency pair
function getState(string pair) {
    var fastMA = SMA(series(price(pair)), 50);
    var slowMA = SMA(series(price(pair)), 200);
    if (fastMA > slowMA) return 1;  // Bull
    else if (fastMA < slowMA) return -1; // Bear
    return 0;  // Sideways
}

// Update the state transition matrix
function updateStateTransition(int pairIndex) {
    int currentState = getState(CurrencyPairs[pairIndex]);
    int lastState = StateMatrix[pairIndex][2]; // Store last state
    StateMatrix[pairIndex][lastState + 1][currentState + 1]++;
    StateMatrix[pairIndex][2] = currentState; // Update last state
}

// Execute trades based on portfolio weights and arbitrage opportunities
function executeTrades() {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            if (ArbitrageMatrix[i][j] > 0.01) { // Arbitrage threshold
                var WeightI = PortfolioWeights[i];
                var WeightJ = PortfolioWeights[j];
                enterLong(CurrencyPairs[i], WeightI);  // Weighted trade
                enterShort(CurrencyPairs[j], WeightJ); // Weighted trade
            }
        }
    }
}

// Main trading function
function run() {
    set(PLOTNOW);

    // Initialize all networks and matrices
    initializeCorrelationNetwork();
    calculateArbitrage();
    calculateRiskMatrix();
    optimizePortfolio();

    // Update state transitions for each pair
    for (int i = 0; i < PAIRS; i++) {
        updateStateTransition(i);
    }

    // Execute trades based on analysis
    executeTrades();
}

#define PAIRS 28 // Number of currency pairs

string CurrencyPairs[PAIRS] = {
    "EURUSD", "GBPUSD", "USDJPY", "GBPJPY", "USDCAD", "EURAUD", "EURJPY", 
    "AUDCAD", "AUDJPY", "AUDNZD", "AUDUSD", "CADJPY", "EURCAD", "EURCHF", 
    "EURGBP", "EURNZD", "GBPCAD", "GBPCHF", "NZDCAD", "NZDJPY", "NZDUSD", 
    "USDCHF", "CHFJPY", "AUDCHF", "GBPNZD", "NZDCHF", "CADCHF", "GBPAUD"
};

vars CorrelationMatrix[PAIRS][PAIRS];    // Correlation adjacency matrix
vars ArbitrageMatrix[PAIRS][PAIRS];     // Arbitrage adjacency matrix
vars VolatilityMatrix[PAIRS];           // Volatility levels for each pair
vars DynamicThresholdMatrix[PAIRS][PAIRS]; // Dynamic arbitrage thresholds
vars RiskAdjustedWeights[PAIRS];        // Risk-adjusted portfolio weights
int StateMatrix[PAIRS][3][3];           // Transition matrix for each pair
vars CurrentDrawdown;                   // Current drawdown level
int LookBack = 200;                     // Lookback period for calculations

// Function to calculate correlation between two series
function calculateCorrelation(vars series1, vars series2, int len) {
    var mean1 = SMA(series1, len);
    var mean2 = SMA(series2, len);
    var numerator = 0, denom1 = 0, denom2 = 0;
    for (int i = 0; i < len; i++) {
        numerator += (series1[i] - mean1) * (series2[i] - mean2);
        denom1 += pow(series1[i] - mean1, 2);
        denom2 += pow(series2[i] - mean2, 2);
    }
    return numerator / sqrt(denom1 * denom2);
}

// Initialize the correlation network
function initializeCorrelationNetwork() {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            if (i != j) {
                vars series1 = series(price(CurrencyPairs[i]));
                vars series2 = series(price(CurrencyPairs[j]));
                CorrelationMatrix[i][j] = calculateCorrelation(series1, series2, LookBack);
            } else {
                CorrelationMatrix[i][j] = 1; // Self-correlation
            }
        }
    }
}

// Calculate arbitrage opportunities between pairs with dynamic thresholds
function calculateDynamicArbitrage() {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            if (i != j) {
                var priceRatio = log(price(CurrencyPairs[i]) / price(CurrencyPairs[j]));
                var threshold = max(0.01, VolatilityMatrix[i] * 0.5); // Dynamic threshold
                DynamicThresholdMatrix[i][j] = threshold;
                ArbitrageMatrix[i][j] = (abs(priceRatio) > threshold) ? priceRatio : 0;
            } else {
                ArbitrageMatrix[i][j] = 0; // No arbitrage within the same pair
            }
        }
    }
}

// Calculate volatility levels for each pair
function calculateVolatilityMatrix() {
    for (int i = 0; i < PAIRS; i++) {
        VolatilityMatrix[i] = StdDev(series(price(CurrencyPairs[i])), LookBack);
    }
}

// Risk adjustment based on drawdown and portfolio composition
function adjustRiskWeights() {
    var TotalWeight = 0;
    for (int i = 0; i < PAIRS; i++) {
        var riskFactor = max(0.1, 1 - CurrentDrawdown / 0.2); // Reduce risk if drawdown exceeds 20%
        RiskAdjustedWeights[i] = (1 / VolatilityMatrix[i]) * riskFactor;
        TotalWeight += RiskAdjustedWeights[i];
    }
    for (int i = 0; i < PAIRS; i++) {
        RiskAdjustedWeights[i] /= TotalWeight; // Normalize weights
    }
}

// Execute trades based on dynamic arbitrage and risk-adjusted weights
function executeDynamicTrades() {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            if (ArbitrageMatrix[i][j] != 0) {
                var WeightI = RiskAdjustedWeights[i];
                var WeightJ = RiskAdjustedWeights[j];
                if (ArbitrageMatrix[i][j] > 0) { // Long-Short arbitrage
                    enterLong(CurrencyPairs[i], WeightI);
                    enterShort(CurrencyPairs[j], WeightJ);
                } else if (ArbitrageMatrix[i][j] < 0) { // Short-Long arbitrage
                    enterShort(CurrencyPairs[i], WeightI);
                    enterLong(CurrencyPairs[j], WeightJ);
                }
            }
        }
    }
}

// Track drawdown levels
function monitorDrawdown() {
    CurrentDrawdown = max(0, 1 - (Equity / MaxEquity));
    if (CurrentDrawdown > 0.2) { // Emergency shutdown at 20% drawdown
        exitLong();
        exitShort();
        printf("Emergency risk controls triggered. All positions closed.");
    }
}

// Main trading function
function run() {
    set(PLOTNOW);

    // Update and calculate all matrices
    initializeCorrelationNetwork();
    calculateVolatilityMatrix();
    calculateDynamicArbitrage();
    adjustRiskWeights();
    monitorDrawdown();

    // Execute trades based on advanced analysis
    executeDynamicTrades();
}

#define PAIRS 28 // Number of currency pairs

string CurrencyPairs[PAIRS] = {
    "EURUSD", "GBPUSD", "USDJPY", "GBPJPY", "USDCAD", "EURAUD", "EURJPY", 
    "AUDCAD", "AUDJPY", "AUDNZD", "AUDUSD", "CADJPY", "EURCAD", "EURCHF", 
    "EURGBP", "EURNZD", "GBPCAD", "GBPCHF", "NZDCAD", "NZDJPY", "NZDUSD", 
    "USDCHF", "CHFJPY", "AUDCHF", "GBPNZD", "NZDCHF", "CADCHF", "GBPAUD"
};

vars ProfitMatrix[PAIRS][PAIRS]; // Edge weights (profitability)
int Previous[PAIRS];            // Stores the previous node in the path
vars PathProfit[PAIRS];         // Stores cumulative profit along the path
vars DynamicDeltaThreshold;     // Dynamic threshold to execute trades

// Function to calculate profitability matrix
function calculateProfitMatrix() {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            if (i != j) {
                var priceRatio = price(CurrencyPairs[i]) / price(CurrencyPairs[j]);
                ProfitMatrix[i][j] = log(priceRatio); // Logarithmic profitability
            } else {
                ProfitMatrix[i][j] = 0; // No self-loop
            }
        }
    }
}

// Calculate the Dynamic Delta Threshold with risk-adjustment and feedback
function calculateDynamicDeltaThreshold() {
    var totalRiskAdjustedProfit = 0;
    int count = 0;

    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            if (i != j && ProfitMatrix[i][j] > 0) {
                var volatility = StdDev(series(price(CurrencyPairs[i])), 50); // 50-period volatility
                var riskAdjustedProfit = ProfitMatrix[i][j] / volatility; // Risk-adjusted profit
                totalRiskAdjustedProfit += riskAdjustedProfit;
                count++;
            }
        }
    }

    if (count > 0) {
        var baselineThreshold = totalRiskAdjustedProfit / count; // Average risk-adjusted profit
        var performanceFactor = Equity / MaxEquity; // Performance feedback
        DynamicDeltaThreshold = baselineThreshold * performanceFactor; // Adjust threshold dynamically
    } else {
        DynamicDeltaThreshold = 0.001; // Default fallback
    }

    // Log the threshold for backtesting and analysis
    printf("DynamicDeltaThreshold: %.6f\n", DynamicDeltaThreshold);
}

// Bellman-Ford algorithm to find paths with the highest cumulative profit
function bellmanFord(int start) {
    for (int i = 0; i < PAIRS; i++) {
        PathProfit[i] = -1e10; // Negative infinity for unvisited nodes
        Previous[i] = -1;     // No predecessor
    }
    PathProfit[start] = 0; // Profit starts at 0 from the source

    for (int k = 0; k < PAIRS - 1; k++) {
        for (int i = 0; i < PAIRS; i++) {
            for (int j = 0; j < PAIRS; j++) {
                if (ProfitMatrix[i][j] != 0 && PathProfit[i] + ProfitMatrix[i][j] > PathProfit[j]) {
                    PathProfit[j] = PathProfit[i] + ProfitMatrix[i][j]; // Update cumulative profit
                    Previous[j] = i; // Track the path
                }
            }
        }
    }
}

// Execute trades along the highest cumulative profit path
function executePath(int start, int end) {
    int current = end;

    while (current != -1) {
        int previous = Previous[current];
        if (previous == -1) break;

        if (ProfitMatrix[previous][current] > 0) {
            enterLong(CurrencyPairs[previous]);
            enterShort(CurrencyPairs[current]);
        } else {
            enterShort(CurrencyPairs[previous]);
            enterLong(CurrencyPairs[current]);
        }

        current = previous;
    }
}

// Continuously execute trades while conditions exist
function executeContinuousTrades(int start) {
    while (1) {
        calculateProfitMatrix();          // Update the graph with live data
        calculateDynamicDeltaThreshold(); // Adjust the threshold dynamically
        bellmanFord(start);               // Recalculate paths with the highest cumulative profit

        for (int i = 0; i < PAIRS; i++) {
            for (int j = 0; j < PAIRS; j++) {
                if (i != j && ProfitMatrix[i][j] > DynamicDeltaThreshold) {
                    enterLong(CurrencyPairs[i]);
                    enterShort(CurrencyPairs[j]);
                    printf("Executing Trade: Long %s, Short %s\n", CurrencyPairs[i], CurrencyPairs[j]);
                }
            }
        }

        // Add a condition to exit the loop for backtesting or analysis
        if (isBacktest() && getBacktestPeriod() == "End") {
            break;
        }
    }
}

// Main trading function
function run() {
    set(PLOTNOW);
    int startPair = 0; // Start from the first currency pair

    executeContinuousTrades(startPair);
}

#define PAIRS 28 // Number of currency pairs

string CurrencyPairs[PAIRS] = {
    "EURUSD", "GBPUSD", "USDJPY", "GBPJPY", "USDCAD", "EURAUD", "EURJPY", 
    "AUDCAD", "AUDJPY", "AUDNZD", "AUDUSD", "CADJPY", "EURCAD", "EURCHF", 
    "EURGBP", "EURNZD", "GBPCAD", "GBPCHF", "NZDCAD", "NZDJPY", "NZDUSD", 
    "USDCHF", "CHFJPY", "AUDCHF", "GBPNZD", "NZDCHF", "CADCHF", "GBPAUD"
};

vars ProfitMatrix[PAIRS][PAIRS];  // Profitability matrix
int Previous[PAIRS];             // Tracks the previous node in the path
vars PathProfit[PAIRS];          // Cumulative profit along the path
vars DynamicDeltaThreshold;      // Dynamic threshold for trade execution

var thresholdZ = 2;              // Z-score threshold
var volatilityThreshold = 1;     // Relative volatility threshold
int lookback = 50;               // Lookback period for mean and volatility

// Function to calculate profitability matrix
function calculateProfitMatrix() {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            if (i != j) {
                // Calculate price ratio and mean reversion metrics
                var priceRatio = price(CurrencyPairs[i]) / price(CurrencyPairs[j]);
                var mean = SMA(series(price(CurrencyPairs[i])), lookback);
                var zScore = (price(CurrencyPairs[i]) - mean) / StdDev(series(price(CurrencyPairs[i])), lookback);
                var volatility = StdDev(series(price(CurrencyPairs[i])), lookback);
                var relativeVolatility = volatility / SMA(series(volatility), lookback);

                // Filter trades based on Z-score and volatility
                if (abs(zScore) > thresholdZ && relativeVolatility > volatilityThreshold) {
                    ProfitMatrix[i][j] = log(priceRatio) - (DynamicDeltaThreshold / volatility);
                } else {
                    ProfitMatrix[i][j] = -INF; // Disqualify trade
                }
            } else {
                ProfitMatrix[i][j] = 0; // No self-loops
            }
        }
    }
}

// Calculate the dynamic delta threshold with risk-adjustment
function calculateDynamicDeltaThreshold() {
    var totalRiskAdjustedProfit = 0;
    int count = 0;

    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            if (i != j && ProfitMatrix[i][j] > -INF) {
                var volatility = StdDev(series(price(CurrencyPairs[i])), lookback);
                var riskAdjustedProfit = ProfitMatrix[i][j] / volatility;
                totalRiskAdjustedProfit += riskAdjustedProfit;
                count++;
            }
        }
    }

    if (count > 0) {
        var baselineThreshold = totalRiskAdjustedProfit / count; // Average risk-adjusted profit
        var performanceFactor = Equity / MaxEquity; // Performance feedback
        DynamicDeltaThreshold = baselineThreshold * performanceFactor; // Adjust threshold dynamically
    } else {
        DynamicDeltaThreshold = 0.001; // Default fallback
    }
}

// Bellman-Ford algorithm to find paths with the highest cumulative profit
function bellmanFord(int start) {
    for (int i = 0; i < PAIRS; i++) {
        PathProfit[i] = -INF; // Negative infinity for unvisited nodes
        Previous[i] = -1;     // No predecessor
    }
    PathProfit[start] = 0; // Profit starts at 0 from the source

    for (int k = 0; k < PAIRS - 1; k++) {
        for (int i = 0; i < PAIRS; i++) {
            for (int j = 0; j < PAIRS; j++) {
                if (ProfitMatrix[i][j] != -INF && PathProfit[i] + ProfitMatrix[i][j] > PathProfit[j]) {
                    PathProfit[j] = PathProfit[i] + ProfitMatrix[i][j]; // Update cumulative profit
                    Previous[j] = i; // Track the path
                }
            }
        }
    }
}

// Execute trades along the highest cumulative profit path
function executePath(int start, int end) {
    int current = end;

    while (current != -1) {
        int prev = Previous[current];
        if (prev == -1) break;

        if (ProfitMatrix[prev][current] > 0) {
            enterLong(CurrencyPairs[prev]);
            enterShort(CurrencyPairs[current]);
        } else {
            enterShort(CurrencyPairs[prev]);
            enterLong(CurrencyPairs[current]);
        }

        current = prev;
    }
}

// Continuously execute trades while conditions exist
function executeContinuousTrades(int start) {
    while (1) {
        calculateProfitMatrix();          // Update the graph with live data
        calculateDynamicDeltaThreshold(); // Adjust the threshold dynamically
        bellmanFord(start);               // Recalculate paths with the highest cumulative profit

        for (int i = 0; i < PAIRS; i++) {
            for (int j = 0; j < PAIRS; j++) {
                if (i != j && ProfitMatrix[i][j] > DynamicDeltaThreshold) {
                    enterLong(CurrencyPairs[i]);
                    enterShort(CurrencyPairs[j]);
                    printf("Executing Trade: Long %s, Short %s\n", CurrencyPairs[i], CurrencyPairs[j]);
                }
            }
        }

        // Add a condition to exit the loop for backtesting or analysis
        if (isBacktest() && getBacktestPeriod() == "End") {
            break;
        }
    }
}

// Main trading function
function run() {
    set(PLOTNOW);
    int startPair = 0; // Start from the first currency pair

    executeContinuousTrades(startPair);
}

#define PAIRS 28 // Number of currency pairs

string CurrencyPairs[PAIRS] = {
    "EURUSD", "GBPUSD", "USDJPY", "GBPJPY", "USDCAD", "EURAUD", "EURJPY",
    "AUDCAD", "AUDJPY", "AUDNZD", "AUDUSD", "CADJPY", "EURCAD", "EURCHF",
    "EURGBP", "EURNZD", "GBPCAD", "GBPCHF", "NZDCAD", "NZDJPY", "NZDUSD",
    "USDCHF", "CHFJPY", "AUDCHF", "GBPNZD", "NZDCHF", "CADCHF", "GBPAUD"
};

vars VolatilityMatrix[PAIRS][PAIRS];  // Volatility relationship matrix
vars CovMatrix[PAIRS][PAIRS];        // Covariance matrix
vars Eigenvalues[PAIRS];             // Eigenvalues from PCA
vars Eigenvectors[PAIRS][PAIRS];     // Eigenvectors from PCA
vars volatilities[PAIRS];            // Volatility for each pair
vars ReducedMatrix[PAIRS][PAIRS];    // Reduced matrix for all components
int lookback = 50;                   // Lookback period for volatility calculation

// Function to calculate volatilities for all pairs
function calculateVolatilities() {
    for (int i = 0; i < PAIRS; i++) {
        volatilities[i] = StdDev(series(price(CurrencyPairs[i])), lookback);
    }
}

// Function to calculate the volatility matrix (volatility spreads)
function calculateVolatilityMatrix() {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            if (i != j) {
                VolatilityMatrix[i][j] = volatilities[i] - volatilities[j];
            } else {
                VolatilityMatrix[i][j] = 0; // Self-loops have no effect
            }
        }
    }
}

// Calculate the covariance between two series of data
function covariance(vars series1, vars series2, int length) {
    var mean1 = 0, mean2 = 0, cov = 0;

    // Step 1: Compute the means of both series
    for (int i = 0; i < length; i++) {
        mean1 += series1[i];
        mean2 += series2[i];
    }
    mean1 /= length;
    mean2 /= length;

    // Step 2: Compute the covariance
    for (int i = 0; i < length; i++) {
        cov += (series1[i] - mean1) * (series2[i] - mean2);
    }

    return cov / length;
}

// Function to calculate the covariance matrix
function calculateCovarianceMatrix() {
    int length = PAIRS; // Length of the series (number of pairs)
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            CovMatrix[i][j] = covariance(VolatilityMatrix[i], VolatilityMatrix[j], length);
        }
    }
}

// Perform PCA: Decompose the covariance matrix into eigenvalues and eigenvectors
function performPCA() {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            Eigenvectors[i][j] = CovMatrix[i][j]; // Initialize with CovMatrix for decomposition
        }
    }

    // Perform power iteration or similar numerical eigenvalue decomposition
    for (int i = 0; i < PAIRS; i++) {
        Eigenvalues[i] = 0;
        for (int j = 0; j < PAIRS; j++) {
            Eigenvalues[i] += Eigenvectors[i][j] * Eigenvectors[i][j];
        }
        Eigenvalues[i] = sqrt(Eigenvalues[i]); // Compute the eigenvalue magnitude
    }

    // Sort eigenvalues and eigenvectors by descending eigenvalue order
    for (int i = 0; i < PAIRS - 1; i++) {
        for (int j = i + 1; j < PAIRS; j++) {
            if (Eigenvalues[i] < Eigenvalues[j]) {
                // Swap eigenvalues
                var tempValue = Eigenvalues[i];
                Eigenvalues[i] = Eigenvalues[j];
                Eigenvalues[j] = tempValue;

                // Swap eigenvectors
                for (int k = 0; k < PAIRS; k++) {
                    var tempVector = Eigenvectors[k][i];
                    Eigenvectors[k][i] = Eigenvectors[k][j];
                    Eigenvectors[k][j] = tempVector;
                }
            }
        }
    }
}

// Determine the optimal number of components based on cumulative variance explained
function optimizeComponents(vars Eigenvalues, int totalComponents, var targetVariance) {
    var totalVariance = 0;
    for (int i = 0; i < totalComponents; i++) {
        totalVariance += Eigenvalues[i];
    }

    var cumulativeVariance = 0;
    for (int i = 0; i < totalComponents; i++) {
        cumulativeVariance += Eigenvalues[i];
        if (cumulativeVariance / totalVariance >= targetVariance) { // Target variance explained
            return i + 1; // Return the optimal number of components
        }
    }
    return totalComponents; // Default to all components
}

// Project the volatility matrix onto the top principal components
function reduceMatrix(int topComponents) {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < topComponents; j++) {
            ReducedMatrix[i][j] = dotProduct(VolatilityMatrix[i], Eigenvectors[j]);
        }
    }
}

// Trade logic based on PCA-reduced components
function tradeWithPCA(int topComponents, var threshold) {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < topComponents; j++) {
            if (abs(ReducedMatrix[i][j]) > threshold) {
                if (ReducedMatrix[i][j] > 0) {
                    enterLong(CurrencyPairs[i]);
                } else {
                    enterShort(CurrencyPairs[i]);
                }
            }
        }
    }
}

// Main trading function
function run() {
    set(PLOTNOW);

    calculateVolatilities();          // Step 1: Calculate volatilities
    calculateVolatilityMatrix();      // Step 2: Compute volatility matrix
    calculateCovarianceMatrix();      // Step 3: Compute covariance matrix
    performPCA();                     // Step 4: Perform PCA

    // Optimize the number of components based on 90% variance explained
    int optimalComponents = optimizeComponents(Eigenvalues, PAIRS, 0.90);

    // Reduce the matrix using the optimal number of components
    reduceMatrix(optimalComponents);

    // Trade using PCA-reduced features
    var threshold = 0.05; // Set a trading threshold
    tradeWithPCA(optimalComponents, threshold);
}

#define PAIRS 28 // Number of currency pairs

string CurrencyPairs[PAIRS] = {
    "EURUSD", "GBPUSD", "USDJPY", "GBPJPY", "USDCAD", "EURAUD", "EURJPY",
    "AUDCAD", "AUDJPY", "AUDNZD", "AUDUSD", "CADJPY", "EURCAD", "EURCHF",
    "EURGBP", "EURNZD", "GBPCAD", "GBPCHF", "NZDCAD", "NZDJPY", "NZDUSD",
    "USDCHF", "CHFJPY", "AUDCHF", "GBPNZD", "NZDCHF", "CADCHF", "GBPAUD"
};

vars VolatilityMatrix[PAIRS][PAIRS];  // Volatility relationship matrix
vars kernelMatrix[PAIRS][PAIRS];     // Kernel matrix for Kernel PCA
vars eigenvalues[PAIRS];             // Eigenvalues from Kernel PCA
vars eigenvectors[PAIRS][PAIRS];     // Eigenvectors from Kernel PCA
vars volatilities[PAIRS];            // Volatility for each pair
vars ReducedMatrix[PAIRS][PAIRS];    // Reduced matrix for all components
vars smoothedSignals[PAIRS];         // Smoothed signals for risk control
int lookback = 50;                   // Lookback period for volatility calculation
var sigma = 0.5;                     // Kernel width parameter
var dynamicThreshold;                // Dynamic trading threshold

// Function to calculate volatilities for all pairs
function calculateVolatilities() {
    for (int i = 0; i < PAIRS; i++) {
        volatilities[i] = StdDev(series(price(CurrencyPairs[i]), lookback));
    }
}

// Function to calculate the volatility matrix (volatility spreads)
function calculateVolatilityMatrix() {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            if (i != j) {
                VolatilityMatrix[i][j] = volatilities[i] - volatilities[j];
            } else {
                VolatilityMatrix[i][j] = 0; // Self-loops have no effect
            }
        }
    }
}

// Function to calculate the kernel matrix using a Gaussian kernel
function calculateKernelMatrix(vars VolatilityMatrix[PAIRS][PAIRS], vars kernelMatrix[PAIRS][PAIRS], var sigma) {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            kernelMatrix[i][j] = exp(-pow(VolatilityMatrix[i][j], 2) / (2 * pow(sigma, 2))); // Gaussian kernel
        }
    }
}

// Perform Kernel PCA: Decompose the kernel matrix into eigenvalues and eigenvectors
function performKernelPCA(vars kernelMatrix[PAIRS][PAIRS], vars eigenvalues, vars eigenvectors) {
    eigenDecomposition(kernelMatrix, eigenvalues, eigenvectors); // Decompose the kernel matrix
}

// Reduce data using the top principal components
function reduceKernelData(vars kernelMatrix[PAIRS][PAIRS], vars eigenvectors[PAIRS][PAIRS], vars ReducedMatrix[PAIRS][PAIRS], int numComponents) {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < numComponents; j++) {
            ReducedMatrix[i][j] = dotProduct(kernelMatrix[i], eigenvectors[j]);
        }
    }
}

// Calculate a dynamic threshold based on standard deviation of reduced signals
function calculateDynamicThreshold(int topComponents) {
    var sumSquares = 0;
    int count = 0;

    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < topComponents; j++) {
            sumSquares += ReducedMatrix[i][j] * ReducedMatrix[i][j];
            count++;
        }
    }
    return sqrt(sumSquares / count); // Standard deviation as threshold
}

// Smooth signals to reduce noise
function smoothSignals(int topComponents) {
    for (int i = 0; i < PAIRS; i++) {
        smoothedSignals[i] = SMA(series(ReducedMatrix[i][0]), lookback); // Smooth first component
    }
}

// Trade logic based on Kernel PCA-reduced components
function tradeWithKernelPCA(int topComponents) {
    for (int i = 0; i < PAIRS; i++) {
        if (abs(smoothedSignals[i]) > dynamicThreshold) {
            if (smoothedSignals[i] > 0) {
                enterLong(CurrencyPairs[i]);
            } else {
                enterShort(CurrencyPairs[i]);
            }
        }
    }
}

// Main trading function
function run() {
    set(PLOTNOW);

    calculateVolatilities();          // Step 1: Calculate volatilities
    calculateVolatilityMatrix();      // Step 2: Compute volatility matrix

    // Step 3: Compute kernel matrix
    calculateKernelMatrix(VolatilityMatrix, kernelMatrix, sigma);

    // Step 4: Perform Kernel PCA
    performKernelPCA(kernelMatrix, eigenvalues, eigenvectors);

    // Step 5: Optimize the number of components based on variance explained
    int optimalComponents = optimizeComponents(eigenvalues, PAIRS, 0.90);

    // Step 6: Reduce data using the top principal components
    reduceKernelData(kernelMatrix, eigenvectors, ReducedMatrix, optimalComponents);

    // Step 7: Calculate dynamic threshold
    dynamicThreshold = calculateDynamicThreshold(optimalComponents);

    // Step 8: Smooth signals for stability
    smoothSignals(optimalComponents);

    // Step 9: Execute trades based on Kernel PCA-reduced features
    tradeWithKernelPCA(optimalComponents);
}

#define PAIRS 28 // Number of currency pairs

string CurrencyPairs[PAIRS] = {
    "EURUSD", "GBPUSD", "USDJPY", "GBPJPY", "USDCAD", "EURAUD", "EURJPY",
    "AUDCAD", "AUDJPY", "AUDNZD", "AUDUSD", "CADJPY", "EURCAD", "EURCHF",
    "EURGBP", "EURNZD", "GBPCAD", "GBPCHF", "NZDCAD", "NZDJPY", "NZDUSD",
    "USDCHF", "CHFJPY", "AUDCHF", "GBPNZD", "NZDCHF", "CADCHF", "GBPAUD"
};

vars kernelMatrix[PAIRS][PAIRS];     // Kernel matrix for Kernel PCA
vars ReducedMatrix[PAIRS][PAIRS];    // Reduced matrix for principal components
vars Thresholds[PAIRS];              // Neural network predicted thresholds
vars smoothedSignals[PAIRS];         // Smoothed signals for risk control
vars Predictions[PAIRS];             // Neural network predictions
vars volatilities[PAIRS];            // Volatility for each pair
vars eigenvalues[PAIRS];             // Eigenvalues from PCA
vars eigenvectors[PAIRS][PAIRS];     // Eigenvectors from PCA
int lookback = 50;                   // Lookback period for volatility calculation
int NeuralModelThreshold;            // Handle for neural network predicting thresholds
int NeuralModelSigma;                // Handle for neural network predicting kernel width

var sigma = 0.5;                     // Default kernel width parameter
var dynamicThreshold;                // Dynamic trading threshold

// Function to calculate volatilities for all pairs
function calculateVolatilities() {
    for (int i = 0; i < PAIRS; i++) {
        volatilities[i] = StdDev(series(price(CurrencyPairs[i]), lookback));
    }
}

// Function to calculate the kernel matrix using a Gaussian kernel
function calculateKernelMatrix(vars volatilities[PAIRS], vars kernelMatrix[PAIRS][PAIRS], var sigma) {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            kernelMatrix[i][j] = exp(-pow(volatilities[i] - volatilities[j], 2) / (2 * pow(sigma, 2))); // Gaussian kernel
        }
    }
}

// Perform Kernel PCA: Decompose the kernel matrix into eigenvalues and eigenvectors
function performKernelPCA(vars kernelMatrix[PAIRS][PAIRS], vars eigenvalues, vars eigenvectors) {
    eigenDecomposition(kernelMatrix, eigenvalues, eigenvectors); // Decompose the kernel matrix
}

// Reduce data using the top principal components
function reduceKernelData(vars kernelMatrix[PAIRS][PAIRS], vars eigenvectors[PAIRS][PAIRS], vars ReducedMatrix[PAIRS][PAIRS], int numComponents) {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < numComponents; j++) {
            ReducedMatrix[i][j] = dotProduct(kernelMatrix[i], eigenvectors[j]);
        }
    }
}

// Neural network training function for dynamic threshold prediction
function trainNeuralNetworks() {
    // Train for thresholds
    LayerPerceptron(10); // 10 nodes in hidden layer
    LayerNormalize();
    LayerPerceptron(1);  // Output layer for threshold prediction
    NeuralModelThreshold = Train(
        "threshold_model", // Model name
        Features,          // Input features (kernel matrix and volatilities)
        Targets,           // Target outputs (thresholds from historical data)
        NumSamples         // Number of samples
    );

    // Train for sigma adjustment
    LayerPerceptron(10); // 10 nodes in hidden layer
    LayerNormalize();
    LayerPerceptron(1);  // Output layer for kernel width (sigma) prediction
    NeuralModelSigma = Train(
        "sigma_model",    // Model name
        Features,         // Input features (historical volatilities and returns)
        Targets,          // Target outputs (optimal sigma values)
        NumSamples        // Number of samples
    );
}

// Predict dynamic thresholds using the neural network
function predictThresholds(vars kernelMatrix[PAIRS][PAIRS], vars Thresholds[PAIRS]) {
    for (int i = 0; i < PAIRS; i++) {
        Thresholds[i] = Predict(NeuralModelThreshold, kernelMatrix[i]); // Predict for each row in kernel matrix
    }
}

// Predict dynamic sigma using the neural network
function predictSigma(vars volatilities[PAIRS]) {
    return Predict(NeuralModelSigma, volatilities); // Predict sigma dynamically
}

// Calculate a dynamic threshold based on reduced signals
function calculateDynamicThreshold(int topComponents) {
    var sumSquares = 0;
    int count = 0;

    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < topComponents; j++) {
            sumSquares += ReducedMatrix[i][j] * ReducedMatrix[i][j];
            count++;
        }
    }
    return sqrt(sumSquares / count); // Standard deviation as threshold
}

// Smooth signals to reduce noise
function smoothSignals(vars Predictions[PAIRS], vars smoothedSignals[PAIRS]) {
    for (int i = 0; i < PAIRS; i++) {
        smoothedSignals[i] = SMA(series(Predictions[i]), lookback);
    }
}

// Trade logic with neural network-predicted thresholds
function tradeWithNeuralNetwork(vars smoothedSignals[PAIRS], vars Thresholds[PAIRS]) {
    for (int i = 0; i < PAIRS; i++) {
        if (smoothedSignals[i] > Thresholds[i]) {
            enterLong(CurrencyPairs[i]);
        } else if (smoothedSignals[i] < -Thresholds[i]) {
            enterShort(CurrencyPairs[i]);
        }
    }
}

// Main trading function
function run() {
    set(PLOTNOW);

    // Step 1: Calculate volatilities
    calculateVolatilities();

    // Step 2: Predict sigma using the neural network
    sigma = predictSigma(volatilities);

    // Step 3: Compute kernel matrix
    calculateKernelMatrix(volatilities, kernelMatrix, sigma);

    // Step 4: Perform Kernel PCA
    performKernelPCA(kernelMatrix, eigenvalues, eigenvectors);

    // Step 5: Optimize the number of components based on variance explained
    int optimalComponents = optimizeComponents(eigenvalues, PAIRS, 0.90);

    // Step 6: Reduce data using the top principal components
    reduceKernelData(kernelMatrix, eigenvectors, ReducedMatrix, optimalComponents);

    // Step 7: Predict thresholds using the neural network
    predictThresholds(kernelMatrix, Thresholds);

    // Step 8: Generate predictions (e.g., signal strength)
    for (int i = 0; i < PAIRS; i++) {
        Predictions[i] = dotProduct(kernelMatrix[i], Thresholds);
    }

    // Step 9: Smooth predictions for stable signals
    smoothSignals(Predictions, smoothedSignals);

    // Step 10: Execute trades based on predictions and thresholds
    tradeWithNeuralNetwork(smoothedSignals, Thresholds);
}

#define PAIRS 28 // Number of currency pairs

string CurrencyPairs[PAIRS] = {
    "EURUSD", "GBPUSD", "USDJPY", "GBPJPY", "USDCAD", "EURAUD", "EURJPY",
    "AUDCAD", "AUDJPY", "AUDNZD", "AUDUSD", "CADJPY", "EURCAD", "EURCHF",
    "EURGBP", "EURNZD", "GBPCAD", "GBPCHF", "NZDCAD", "NZDJPY", "NZDUSD",
    "USDCHF", "CHFJPY", "AUDCHF", "GBPNZD", "NZDCHF", "CADCHF", "GBPAUD"
};

vars volatilities[PAIRS];             // Volatility for each pair
vars correlations[PAIRS];             // Correlations for each pair
vars kernelMatrix1[PAIRS][PAIRS];     // Kernel matrix for PCA-1
vars kernelMatrix2[PAIRS][PAIRS];     // Kernel matrix for PCA-2
vars ReducedMatrix1[PAIRS][PAIRS];    // Reduced matrix for PCA-1
vars ReducedMatrix2[PAIRS][PAIRS];    // Reduced matrix for PCA-2
vars FeedbackMatrix1[PAIRS];          // Feedback-influenced matrix for PCA-1
vars FeedbackMatrix2[PAIRS];          // Feedback-influenced matrix for PCA-2
vars Threshold1[PAIRS];               // Thresholds from NN-1
vars Threshold2[PAIRS];               // Thresholds from NN-2
vars MetaFeatures[PAIRS];             // Meta-features for the meta neural network
vars FinalSignals[PAIRS];             // Final signals from the meta neural network
int lookback = 50;                    // Lookback period
int NN1, NN2, MetaNN;                 // Neural network handles
var lambda = 0.5;                     // Cross-influence weight
var sigma1 = 0.5;                     // Initial kernel width for PCA-1
var sigma2 = 0.5;                     // Initial kernel width for PCA-2

// Step 1: Calculate volatilities and correlations
function calculateFeatures() {
    for (int i = 0; i < PAIRS; i++) {
        volatilities[i] = StdDev(series(price(CurrencyPairs[i])), lookback);
        correlations[i] = priceClose(CurrencyPairs[i]) - priceOpen(CurrencyPairs[i]); // Correlation proxy
    }
}

// Step 2: Calculate kernel matrices with initial parameters
function calculateKernelMatrices() {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            kernelMatrix1[i][j] = exp(-(pow(volatilities[i] - volatilities[j], 2)) / (2 * pow(sigma1, 2)));
            kernelMatrix2[i][j] = exp(-(pow(correlations[i] - correlations[j], 2)) / (2 * pow(sigma2, 2)));
        }
    }
}

// Step 3: Perform Kernel PCA
function performKernelPCA(vars kernelMatrix[PAIRS][PAIRS], vars eigenvalues, vars eigenvectors) {
    eigenDecomposition(kernelMatrix, eigenvalues, eigenvectors);
}

// Step 4: Reduce kernel data
function reduceKernelData(vars kernelMatrix[PAIRS][PAIRS], vars eigenvectors[PAIRS][PAIRS], vars ReducedMatrix[PAIRS][PAIRS], int components) {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < components; j++) {
            ReducedMatrix[i][j] = dotProduct(kernelMatrix[i], eigenvectors[j]);
        }
    }
}

// Step 5: Apply feedback adjustments
function applyFeedbackAdjustments() {
    for (int i = 0; i < PAIRS; i++) {
        FeedbackMatrix1[i] = dotProduct(ReducedMatrix2[i], ReducedMatrix1[i]); // PCA-1 influenced by PCA-2
        FeedbackMatrix2[i] = dotProduct(ReducedMatrix1[i], ReducedMatrix2[i]); // PCA-2 influenced by PCA-1
    }
}

// Step 6: Train and predict neural networks
function trainNeuralNetworks() {
    // Train NN-1
    LayerPerceptron(10);
    LayerNormalize();
    LayerPerceptron(1);
    NN1 = Train("NN1", ReducedMatrix1, Threshold1, PAIRS);

    // Train NN-2
    LayerPerceptron(10);
    LayerNormalize();
    LayerPerceptron(1);
    NN2 = Train("NN2", ReducedMatrix2, Threshold2, PAIRS);

    // Train Meta Neural Network
    LayerPerceptron(5);
    LayerNormalize();
    LayerPerceptron(1);
    MetaNN = Train("MetaNN", [Threshold1, Threshold2, FeedbackMatrix1, FeedbackMatrix2], FinalSignals, PAIRS);
}

function predictSignalsAndThresholds() {
    for (int i = 0; i < PAIRS; i++) {
        Threshold1[i] = Predict(NN1, FeedbackMatrix1[i]);
        Threshold2[i] = Predict(NN2, FeedbackMatrix2[i]);

        // Meta Neural Network combines predictions
        MetaFeatures[i] = [Threshold1[i], Threshold2[i], FeedbackMatrix1[i], FeedbackMatrix2[i]];
        FinalSignals[i] = Predict(MetaNN, MetaFeatures[i]);
    }
}

// Step 7: Execute trades
function executeTrades() {
    for (int i = 0; i < PAIRS; i++) {
        if (FinalSignals[i] > 0.5) {
            enterLong(CurrencyPairs[i]);
        } else if (FinalSignals[i] < -0.5) {
            enterShort(CurrencyPairs[i]);
        }
    }
}

// Main function
function run() {
    set(PLOTNOW);

    // Step 1: Calculate features
    calculateFeatures();

    // Step 2: Compute initial kernel matrices
    calculateKernelMatrices();

    // Step 3: Perform Kernel PCA
    vars eigenvalues1, eigenvectors1;
    vars eigenvalues2, eigenvectors2;
    performKernelPCA(kernelMatrix1, eigenvalues1, eigenvectors1);
    performKernelPCA(kernelMatrix2, eigenvalues2, eigenvectors2);

    // Step 4: Reduce data
    reduceKernelData(kernelMatrix1, eigenvectors1, ReducedMatrix1, 3); // Top 3 components
    reduceKernelData(kernelMatrix2, eigenvectors2, ReducedMatrix2, 3);

    for (int iter = 0; iter < 5; iter++) { // Recursive iterations
        // Step 5: Apply feedback adjustments
        applyFeedbackAdjustments();

        // Step 6: Recompute kernel matrices with feedback
        calculateKernelMatrices();

        // Step 7: Perform Kernel PCA again
        performKernelPCA(kernelMatrix1, eigenvalues1, eigenvectors1);
        performKernelPCA(kernelMatrix2, eigenvalues2, eigenvectors2);

        // Step 8: Predict thresholds and signals
        predictSignalsAndThresholds();

        // Step 9: Execute trades
        executeTrades();
    }
}

#define PAIRS 28 // Number of currency pairs
#define COMBINATIONS 378 // Total number of unique pair combinations

string CurrencyPairs[PAIRS] = {
    "EURUSD", "GBPUSD", "USDJPY", "GBPJPY", "USDCAD", "EURAUD", "EURJPY",
    "AUDCAD", "AUDJPY", "AUDNZD", "AUDUSD", "CADJPY", "EURCAD", "EURCHF",
    "EURGBP", "EURNZD", "GBPCAD", "GBPCHF", "NZDCAD", "NZDJPY", "NZDUSD",
    "USDCHF", "CHFJPY", "AUDCHF", "GBPNZD", "NZDCHF", "CADCHF", "GBPAUD"
};

vars volatilities[PAIRS];             // Volatility for each pair
vars volatilityRatios[COMBINATIONS]; // Volatility ratios for pair combinations
vars kernelMatrix1[COMBINATIONS][COMBINATIONS]; // Kernel matrix for PCA-1
vars kernelMatrix2[COMBINATIONS][COMBINATIONS]; // Kernel matrix for PCA-2
vars ReducedMatrix1[COMBINATIONS][COMBINATIONS]; // Reduced matrix for PCA-1
vars ReducedMatrix2[COMBINATIONS][COMBINATIONS]; // Reduced matrix for PCA-2
vars profitabilityMatrix[COMBINATIONS]; // Profitability matrix for pair combinations
vars Threshold1[COMBINATIONS];        // Thresholds from NN-1
vars Threshold2[COMBINATIONS];        // Thresholds from NN-2
vars MetaFeatures[COMBINATIONS];      // Meta-features for MetaNN
vars FinalSignals[COMBINATIONS];      // Final trade signals
int combinationIndex[COMBINATIONS][2]; // Index mapping for combinations
int NN1, NN2, MetaNN;                 // Neural network handles
int lookback = 50;                    // Lookback period

// Step 1: Calculate volatilities for all currency pairs
function calculateVolatilities() {
    for (int i = 0; i < PAIRS; i++) {
        volatilities[i] = StdDev(series(price(CurrencyPairs[i])), lookback);
    }
}

// Step 2: Generate all pair combinations
function generateCombinations() {
    int index = 0;
    for (int i = 0; i < PAIRS - 1; i++) {
        for (int j = i + 1; j < PAIRS; j++) {
            combinationIndex[index][0] = i; // First pair in the combination
            combinationIndex[index][1] = j; // Second pair in the combination
            index++;
        }
    }
}

// Step 3: Calculate volatility ratios for all combinations
function calculateVolatilityRatios() {
    for (int k = 0; k < COMBINATIONS; k++) {
        int i = combinationIndex[k][0];
        int j = combinationIndex[k][1];
        volatilityRatios[k] = abs(volatilities[i] - volatilities[j]); // Volatility difference
    }
}

// Step 4: Compute kernel matrices
function calculateKernelMatrices(var sigma1, var sigma2) {
    for (int i = 0; i < COMBINATIONS; i++) {
        for (int j = 0; j < COMBINATIONS; j++) {
            kernelMatrix1[i][j] = exp(-pow(volatilityRatios[i] - volatilityRatios[j], 2) / (2 * pow(sigma1, 2)));
            kernelMatrix2[i][j] = exp(-pow(profitabilityMatrix[i] - profitabilityMatrix[j], 2) / (2 * pow(sigma2, 2)));
        }
    }
}

// Step 5: Perform Kernel PCA
function performKernelPCA(vars kernelMatrix[COMBINATIONS][COMBINATIONS], vars eigenvalues, vars eigenvectors) {
    eigenDecomposition(kernelMatrix, eigenvalues, eigenvectors);
}

// Step 6: Reduce kernel data
function reduceKernelData(vars kernelMatrix[COMBINATIONS][COMBINATIONS], vars eigenvectors[COMBINATIONS][COMBINATIONS], vars ReducedMatrix[COMBINATIONS][COMBINATIONS], int components) {
    for (int i = 0; i < COMBINATIONS; i++) {
        for (int j = 0; j < components; j++) {
            ReducedMatrix[i][j] = dotProduct(kernelMatrix[i], eigenvectors[j]);
        }
    }
}

// Step 7: Train neural networks
function trainNeuralNetworks() {
    // Train NN-1
    LayerPerceptron(10);
    LayerNormalize();
    LayerPerceptron(1);
    NN1 = Train("NN1", ReducedMatrix1, Threshold1, COMBINATIONS);

    // Train NN-2
    LayerPerceptron(10);
    LayerNormalize();
    LayerPerceptron(1);
    NN2 = Train("NN2", ReducedMatrix2, Threshold2, COMBINATIONS);

    // Train Meta Neural Network
    LayerPerceptron(5);
    LayerNormalize();
    LayerPerceptron(1);
    MetaNN = Train("MetaNN", [Threshold1, Threshold2], FinalSignals, COMBINATIONS);
}

// Step 8: Predict thresholds and signals
function predictThresholdsAndSignals() {
    for (int i = 0; i < COMBINATIONS; i++) {
        Threshold1[i] = Predict(NN1, ReducedMatrix1[i]);
        Threshold2[i] = Predict(NN2, ReducedMatrix2[i]);

        // Meta Neural Network combines predictions
        MetaFeatures[i] = [Threshold1[i], Threshold2[i]];
        FinalSignals[i] = Predict(MetaNN, MetaFeatures[i]);
    }
}

// Step 9: Execute trades
function executeTrades() {
    for (int i = 0; i < COMBINATIONS; i++) {
        int pair1 = combinationIndex[i][0];
        int pair2 = combinationIndex[i][1];

        // Example trade logic based on meta signal
        if (FinalSignals[i] > 0.5) {
            enterLong(CurrencyPairs[pair1]);
            enterShort(CurrencyPairs[pair2]);
        } else if (FinalSignals[i] < -0.5) {
            enterShort(CurrencyPairs[pair1]);
            enterLong(CurrencyPairs[pair2]);
        }
    }
}

// Main function
function run() {
    set(PLOTNOW);

    // Step 1: Calculate volatilities
    calculateVolatilities();

    // Step 2: Generate pair combinations
    generateCombinations();

    // Step 3: Calculate volatility ratios
    calculateVolatilityRatios();

    // Step 4: Compute kernel matrices
    calculateKernelMatrices(0.5, 0.5); // Example sigma values

    // Step 5: Perform Kernel PCA
    vars eigenvalues1, eigenvectors1;
    vars eigenvalues2, eigenvectors2;
    performKernelPCA(kernelMatrix1, eigenvalues1, eigenvectors1);
    performKernelPCA(kernelMatrix2, eigenvalues2, eigenvectors2);

    // Step 6: Reduce kernel data
    reduceKernelData(kernelMatrix1, eigenvectors1, ReducedMatrix1, 3); // Top 3 components
    reduceKernelData(kernelMatrix2, eigenvectors2, ReducedMatrix2, 3);

    // Step 7: Train neural networks
    trainNeuralNetworks();

    // Step 8: Predict thresholds and signals
    predictThresholdsAndSignals();

    // Step 9: Execute trades
    executeTrades();
}

#define PAIRS 28
#define COMBINATIONS 378

string CurrencyPairs[PAIRS] = {
    "EURUSD", "GBPUSD", "USDJPY", "GBPJPY", "USDCAD", "EURAUD", "EURJPY",
    "AUDCAD", "AUDJPY", "AUDNZD", "AUDUSD", "CADJPY", "EURCAD", "EURCHF",
    "EURGBP", "EURNZD", "GBPCAD", "GBPCHF", "NZDCAD", "NZDJPY", "NZDUSD",
    "USDCHF", "CHFJPY", "AUDCHF", "GBPNZD", "NZDCHF", "CADCHF", "GBPAUD"
};

vars volatilities[PAIRS];             // Volatility for each pair
vars profitability[COMBINATIONS];    // Profitability for each pair combination
vars adjacencyMatrix[PAIRS][PAIRS];  // GNN adjacency matrix
vars nodeEmbeddings[PAIRS][5];       // Node embeddings from GNN
vars kernelMatrix1[PAIRS][PAIRS];    // Kernel matrix for PCA-1 (volatility)
vars kernelMatrix2[PAIRS][PAIRS];    // Kernel matrix for PCA-2 (profitability)
vars ReducedMatrix1[PAIRS][PAIRS];   // Reduced components from PCA-1
vars ReducedMatrix2[PAIRS][PAIRS];   // Reduced components from PCA-2
vars Threshold1[PAIRS];              // Thresholds from NN-1
vars Threshold2[PAIRS];              // Thresholds from NN-2
vars MetaFeatures[PAIRS];            // Meta-features for MetaNN
vars FinalSignals[PAIRS];            // Final trade signals
int NN1, NN2, MetaNN;                // Neural network handles
int lookback = 50;                   // Lookback period

// Step 1: Calculate volatility and profitability
function calculateMetrics() {
    for (int i = 0; i < PAIRS; i++) {
        volatilities[i] = StdDev(series(price(CurrencyPairs[i])), lookback);
    }
    for (int k = 0; k < COMBINATIONS; k++) {
        int i = k / PAIRS;
        int j = k % PAIRS;
        profitability[k] = abs(priceClose(CurrencyPairs[i]) - priceClose(CurrencyPairs[j]));
    }
}

// Step 2: Construct adjacency matrix
function constructAdjacencyMatrix() {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            if (i != j) {
                adjacencyMatrix[i][j] = exp(-pow(volatilities[i] - volatilities[j], 2)); // Gaussian kernel
            } else {
                adjacencyMatrix[i][j] = 0;
            }
        }
    }
}

// Step 3: Propagate GNN embeddings
function propagateEmbeddings() {
    vars newEmbeddings[PAIRS][5];
    for (int t = 0; t < 3; t++) { // 3 propagation steps
        for (int i = 0; i < PAIRS; i++) {
            for (int k = 0; k < 5; k++) {
                newEmbeddings[i][k] = 0;
                for (int j = 0; j < PAIRS; j++) {
                    newEmbeddings[i][k] += adjacencyMatrix[i][j] * nodeEmbeddings[j][k];
                }
                newEmbeddings[i][k] = ReLU(newEmbeddings[i][k]);
            }
        }
        for (int i = 0; i < PAIRS; i++) {
            for (int k = 0; k < 5; k++) {
                nodeEmbeddings[i][k] = newEmbeddings[i][k];
            }
        }
    }
}

// Step 4: Update kernel matrices using GNN embeddings
function updateKernelMatrices() {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            kernelMatrix1[i][j] = exp(-dotProduct(nodeEmbeddings[i], nodeEmbeddings[j]) / 2); // Volatility kernel
            kernelMatrix2[i][j] = exp(-profitability[i * PAIRS + j] / 2);                     // Profitability kernel
        }
    }
}

// Step 5: Perform Kernel PCA
function performKernelPCA(vars kernelMatrix[PAIRS][PAIRS], vars ReducedMatrix[PAIRS][PAIRS]) {
    vars eigenvalues, eigenvectors;
    eigenDecomposition(kernelMatrix, eigenvalues, eigenvectors);
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < 3; j++) { // Top 3 components
            ReducedMatrix[i][j] = dotProduct(kernelMatrix[i], eigenvectors[j]);
        }
    }
}

// Step 6: Train neural networks
function trainNeuralNetworks() {
    // NN-1: Thresholds from PCA-1
    LayerPerceptron(10);
    LayerNormalize();
    LayerPerceptron(1);
    NN1 = Train("NN1", ReducedMatrix1, Threshold1, PAIRS);

    // NN-2: Thresholds from PCA-2
    LayerPerceptron(10);
    LayerNormalize();
    LayerPerceptron(1);
    NN2 = Train("NN2", ReducedMatrix2, Threshold2, PAIRS);

    // Meta Neural Network
    LayerPerceptron(5);
    LayerNormalize();
    LayerPerceptron(1);
    MetaNN = Train("MetaNN", [Threshold1, Threshold2], FinalSignals, PAIRS);
}

// Step 7: Execute trades
function executeTrades() {
    for (int i = 0; i < PAIRS; i++) {
        if (FinalSignals[i] > 0.5) {
            enterLong(CurrencyPairs[i]);
        } else if (FinalSignals[i] < -0.5) {
            enterShort(CurrencyPairs[i]);
        }
    }
}

// Main function
function run() {
    set(PLOTNOW);

    // Step 1: Calculate metrics
    calculateMetrics();

    // Step 2: Construct adjacency matrix
    constructAdjacencyMatrix();

    // Step 3: Propagate embeddings
    propagateEmbeddings();

    // Step 4: Update kernel matrices
    updateKernelMatrices();

    // Step 5: Perform Kernel PCA
    performKernelPCA(kernelMatrix1, ReducedMatrix1);
    performKernelPCA(kernelMatrix2, ReducedMatrix2);

    // Step 6: Train neural networks
    trainNeuralNetworks();

    // Step 7: Execute trades
    executeTrades();
}

#define PAIRS 28

string CurrencyPairs[PAIRS] = {
    "EURUSD", "GBPUSD", "USDJPY", "GBPJPY", "USDCAD", "EURAUD", "EURJPY",
    "AUDCAD", "AUDJPY", "AUDNZD", "AUDUSD", "CADJPY", "EURCAD", "EURCHF",
    "EURGBP", "EURNZD", "GBPCAD", "GBPCHF", "NZDCAD", "NZDJPY", "NZDUSD",
    "USDCHF", "CHFJPY", "AUDCHF", "GBPNZD", "NZDCHF", "CADCHF", "GBPAUD"
};

vars volatilities[PAIRS];             // Volatility for each pair
vars adjacencyMatrices[PAIRS][PAIRS][28];  // Adjacency matrices for 28 GNNs
vars nodeEmbeddings[PAIRS][5][28];    // Node embeddings for 28 GNNs
vars updatedEmbeddings[PAIRS][5];     // Final node embeddings after aggregation
vars kernelMatrix[PAIRS][PAIRS];      // Kernel matrix for PCA
vars eigenvalues[PAIRS];              // Eigenvalues from PCA
vars eigenvectors[PAIRS][PAIRS];      // Eigenvectors from PCA
vars reducedMatrix[PAIRS][3];         // Reduced components from PCA
vars thresholds[PAIRS];               // Thresholds for trade execution
vars signals[PAIRS];                  // Final trading signals
int lookback = 50;
int NN;                               // Neural network handle for threshold prediction
int propagationDepth = 3;             // GNN propagation depth

// Step 1: Calculate volatilities for all pairs
function calculateVolatilities() {
    for (int i = 0; i < PAIRS; i++) {
        volatilities[i] = StdDev(series(price(CurrencyPairs[i])), lookback);
    }
}

// Step 2: Construct adjacency matrices for 28 GNNs
function constructAdjacencyMatrices() {
    for (int l = 0; l < 28; l++) { // For each GNN layer
        for (int i = 0; i < PAIRS; i++) {
            for (int j = 0; j < PAIRS; j++) {
                if (i != j) {
                    adjacencyMatrices[i][j][l] = exp(-pow(volatilities[i] - volatilities[j], 2) / (2 * 0.5^2)); // Gaussian kernel
                } else {
                    adjacencyMatrices[i][j][l] = 0; // No self-loops
                }
            }
        }
    }
}

// Step 3: Propagate embeddings for each GNN
function propagateEmbeddings() {
    for (int l = 0; l < 28; l++) { // For each GNN
        for (int t = 0; t < propagationDepth; t++) { // Propagation steps
            vars newEmbeddings[PAIRS][5];
            for (int i = 0; i < PAIRS; i++) {
                for (int k = 0; k < 5; k++) {
                    newEmbeddings[i][k] = 0;
                    for (int j = 0; j < PAIRS; j++) {
                        newEmbeddings[i][k] += adjacencyMatrices[i][j][l] * nodeEmbeddings[j][k][l];
                    }
                    newEmbeddings[i][k] = ReLU(newEmbeddings[i][k]);
                }
            }
            // Update embeddings
            for (int i = 0; i < PAIRS; i++) {
                for (int k = 0; k < 5; k++) {
                    nodeEmbeddings[i][k][l] = newEmbeddings[i][k];
                }
            }
        }
    }
}

// Step 4: Aggregate embeddings across all GNNs
function aggregateEmbeddings() {
    for (int i = 0; i < PAIRS; i++) {
        for (int k = 0; k < 5; k++) {
            updatedEmbeddings[i][k] = 0;
            for (int l = 0; l < 28; l++) {
                updatedEmbeddings[i][k] += nodeEmbeddings[i][k][l];
            }
            updatedEmbeddings[i][k] /= 28; // Average across GNNs
        }
    }
}

// Step 5: Update kernel matrix using aggregated embeddings
function updateKernelMatrix() {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            kernelMatrix[i][j] = exp(-dotProduct(updatedEmbeddings[i], updatedEmbeddings[j]) / (2 * 0.5^2)); // Gaussian kernel
        }
    }
}

// Step 6: Perform Kernel PCA
function performKernelPCA() {
    eigenDecomposition(kernelMatrix, eigenvalues, eigenvectors);
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < 3; j++) { // Top 3 components
            reducedMatrix[i][j] = dotProduct(kernelMatrix[i], eigenvectors[j]);
        }
    }
}

// Step 7: Train neural network for threshold prediction
function trainNeuralNetwork() {
    LayerPerceptron(10);  // Hidden layer
    LayerNormalize();
    LayerPerceptron(1);   // Output layer
    NN = Train("ThresholdNN", reducedMatrix, thresholds, PAIRS);
}

// Step 8: Generate trade signals
function generateSignals() {
    for (int i = 0; i < PAIRS; i++) {
        signals[i] = Predict(NN, reducedMatrix[i]);
    }
}

// Step 9: Execute trades
function executeTrades() {
    for (int i = 0; i < PAIRS; i++) {
        if (signals[i] > 0.5) {
            enterLong(CurrencyPairs[i]);
        } else if (signals[i] < -0.5) {
            enterShort(CurrencyPairs[i]);
        }
    }
}

// Main function
function run() {
    set(PLOTNOW);

    // Step 1: Calculate volatilities
    calculateVolatilities();

    // Step 2: Construct adjacency matrices
    constructAdjacencyMatrices();

    // Step 3: Propagate embeddings for each GNN
    propagateEmbeddings();

    // Step 4: Aggregate embeddings
    aggregateEmbeddings();

    // Step 5: Update kernel matrix
    updateKernelMatrix();

    // Step 6: Perform Kernel PCA
    performKernelPCA();

    // Step 7: Train neural network for thresholds
    trainNeuralNetwork();

    // Step 8: Generate trade signals
    generateSignals();

    // Step 9: Execute trades
    executeTrades();
}

#define PAIRS 28
#define CHUNK_SIZE 5
#define LATENT_DIM 3

// Currency pairs
string CurrencyPairs[PAIRS] = {
    "EURUSD", "GBPUSD", "USDJPY", "GBPJPY", "USDCAD", "EURAUD", "EURJPY",
    "AUDCAD", "AUDJPY", "AUDNZD", "AUDUSD", "CADJPY", "EURCAD", "EURCHF",
    "EURGBP", "EURNZD", "GBPCAD", "GBPCHF", "NZDCAD", "NZDJPY", "NZDUSD",
    "USDCHF", "CHFJPY", "AUDCHF", "GBPNZD", "NZDCHF", "CADCHF", "GBPAUD"
};

// Variables
vars volatilities[PAIRS];
vars adjacencyMatrices[PAIRS][PAIRS];
vars nodeEmbeddings[PAIRS][5];
vars kernelMatrix[PAIRS][PAIRS];
vars eigenvalues[PAIRS];
vars eigenvectors[PAIRS][PAIRS];
vars reducedMatrix[PAIRS][3];
vars cumulativeCovariance[5][5];
vars encoderWeights[5][LATENT_DIM];
vars decoderWeights[LATENT_DIM][5];
vars signals[PAIRS];
double kernelSigma = 0.5;
double thresholdMultiplier = 1.0;
double learningRate = 0.01;
int lookback = 50;
int totalSamples = 0;

// Step 1: Calculate volatilities
function calculateVolatilities() {
    for (int i = 0; i < PAIRS; i++) {
        volatilities[i] = StdDev(series(price(CurrencyPairs[i])), lookback);
    }
}

// Step 2: Construct adjacency matrix for GNN
function constructAdjacencyMatrix() {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            if (i != j) {
                adjacencyMatrices[i][j] = exp(-pow(volatilities[i] - volatilities[j], 2) / (2 * pow(kernelSigma, 2)));
            } else {
                adjacencyMatrices[i][j] = 0;
            }
        }
    }
}

// Step 3: Propagate embeddings for GNN
function propagateEmbeddings() {
    vars newEmbeddings[PAIRS][5];
    for (int i = 0; i < PAIRS; i++) {
        for (int k = 0; k < 5; k++) {
            newEmbeddings[i][k] = 0;
            for (int j = 0; j < PAIRS; j++) {
                newEmbeddings[i][k] += adjacencyMatrices[i][j] * nodeEmbeddings[j][k];
            }
        }
    }
    for (int i = 0; i < PAIRS; i++) {
        for (int k = 0; k < 5; k++) {
            nodeEmbeddings[i][k] = ReLU(newEmbeddings[i][k]);
        }
    }
}

// Step 4: Incremental PCA
function updateIncrementalPCA(vars embeddings[PAIRS][5]) {
    for (int i = 0; i < PAIRS; i += CHUNK_SIZE) {
        for (int a = 0; a < 5; a++) {
            for (int b = 0; b < 5; b++) {
                cumulativeCovariance[a][b] = 0;
                for (int j = i; j < i + CHUNK_SIZE && j < PAIRS; j++) {
                    cumulativeCovariance[a][b] += embeddings[j][a] * embeddings[j][b];
                }
            }
        }
        totalSamples += CHUNK_SIZE;
    }
    for (int a = 0; a < 5; a++) {
        for (int b = 0; b < 5; b++) {
            cumulativeCovariance[a][b] /= totalSamples;
        }
    }
}

// Step 5: Autoencoder PCA
function initializeAutoencoder() {
    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < LATENT_DIM; j++) {
            encoderWeights[i][j] = random() * 0.1;
            decoderWeights[j][i] = random() * 0.1;
        }
    }
}

function forwardPass(vars input[5], vars latent[LATENT_DIM], vars output[5]) {
    for (int j = 0; j < LATENT_DIM; j++) {
        latent[j] = 0;
        for (int i = 0; i < 5; i++) {
            latent[j] += input[i] * encoderWeights[i][j];
        }
    }
    for (int i = 0; i < 5; i++) {
        output[i] = 0;
        for (int j = 0; j < LATENT_DIM; j++) {
            output[i] += latent[j] * decoderWeights[j][i];
        }
    }
}

function backpropagate(vars input[5], vars output[5], vars latent[LATENT_DIM]) {
    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < LATENT_DIM; j++) {
            double gradEncoder = (input[i] - output[i]) * decoderWeights[j][i];
            double gradDecoder = (input[i] - output[i]) * latent[j];
            encoderWeights[i][j] += learningRate * gradEncoder;
            decoderWeights[j][i] += learningRate * gradDecoder;
        }
    }
}

function trainAutoencoder(vars embeddings[PAIRS][5]) {
    for (int epoch = 0; epoch < 50; epoch++) {
        for (int i = 0; i < PAIRS; i++) {
            vars latent[LATENT_DIM];
            vars output[5];
            forwardPass(embeddings[i], latent, output);
            backpropagate(embeddings[i], output, latent);
        }
    }
}

// Step 6: Generate trading signals
function generateSignals() {
    for (int i = 0; i < PAIRS; i++) {
        double mean = 0, stddev = 0;
        for (int j = 0; j < 3; j++) {
            mean += reducedMatrix[i][j];
            stddev += pow(reducedMatrix[i][j] - mean, 2);
        }
        stddev = sqrt(stddev / 3);
        double threshold = mean + thresholdMultiplier * stddev;
        if (reducedMatrix[i][0] > threshold) signals[i] = 1;
        else if (reducedMatrix[i][0] < -threshold) signals[i] = -1;
        else signals[i] = 0;
    }
}

// Step 7: Execute trades
function executeTrades() {
    for (int i = 0; i < PAIRS; i++) {
        if (signals[i] > 0) enterLong(CurrencyPairs[i]);
        else if (signals[i] < 0) enterShort(CurrencyPairs[i]);
    }
}

// Main function
function run() {
    set(PLOTNOW);
    calculateVolatilities();
    constructAdjacencyMatrix();
    propagateEmbeddings();
    updateIncrementalPCA(nodeEmbeddings);
    trainAutoencoder(nodeEmbeddings);
    generateSignals();
    executeTrades();
}

#define PAIRS 28
#define COMPONENTS 3 // Number of principal components from PCA
#define GNN_LAYERS 2 // Number of GNN layers per GNN

string CurrencyPairs[PAIRS] = {
    "EURUSD", "GBPUSD", "USDJPY", "GBPJPY", "USDCAD", "EURAUD", "EURJPY",
    "AUDCAD", "AUDJPY", "AUDNZD", "AUDUSD", "CADJPY", "EURCAD", "EURCHF",
    "EURGBP", "EURNZD", "GBPCAD", "GBPCHF", "NZDCAD", "NZDJPY", "NZDUSD",
    "USDCHF", "CHFJPY", "AUDCHF", "GBPNZD", "NZDCHF", "CADCHF", "GBPAUD"
};

// Variables
vars volatilities[PAIRS];             // Volatility for each pair
vars adjacencyMatrices[PAIRS][PAIRS][28];  // Adjacency matrices for 28 GNNs
vars pcaReducedFeatures[PAIRS][COMPONENTS]; // PCA-reduced features
vars gnnWeights[28][GNN_LAYERS][COMPONENTS][COMPONENTS]; // GNN weights for each GNN
vars gnnRefinedFeatures[PAIRS][COMPONENTS]; // Refined features from GNNs
vars kernelMatrix[PAIRS][PAIRS];      // Kernel matrix for PCA
vars eigenvalues[PAIRS];              // Eigenvalues from PCA
vars eigenvectors[PAIRS][PAIRS];      // Eigenvectors from PCA
vars reducedMatrix[PAIRS][COMPONENTS]; // Final reduced components
vars signals[PAIRS];                  // Final trading signals
int lookback = 50;
int propagationDepth = 3;             // GNN propagation depth

// Step 1: Calculate volatilities for all pairs
function calculateVolatilities() {
    for (int i = 0; i < PAIRS; i++) {
        volatilities[i] = StdDev(series(price(CurrencyPairs[i])), lookback);
    }
}

// Step 2: Construct adjacency matrices for each GNN
function constructAdjacencyMatrices(vars features[PAIRS][COMPONENTS]) {
    for (int gnn = 0; gnn < 28; gnn++) { // Each GNN has its own adjacency matrix
        for (int i = 0; i < PAIRS; i++) {
            for (int j = 0; j < PAIRS; j++) {
                double distance = 0;
                for (int k = 0; k < COMPONENTS; k++) {
                    distance += pow(features[i][k] - features[j][k], 2);
                }
                adjacencyMatrices[i][j][gnn] = exp(-distance / (2 * pow(0.5, 2))); // Gaussian kernel
            }
        }
    }
}

// Step 3: Initialize GNN weights
function initializeGNNWeights() {
    for (int gnn = 0; gnn < 28; gnn++) {
        for (int l = 0; l < GNN_LAYERS; l++) {
            for (int i = 0; i < COMPONENTS; i++) {
                for (int j = 0; j < COMPONENTS; j++) {
                    gnnWeights[gnn][l][i][j] = random() * 0.1; // Small random initialization
                }
            }
        }
    }
}

// Step 4: Propagate features through each GNN
function propagateGNN(vars features[PAIRS][COMPONENTS]) {
    vars tempFeatures[PAIRS][COMPONENTS];
    for (int gnn = 0; gnn < 28; gnn++) { // Process each GNN
        for (int t = 0; t < propagationDepth; t++) { // Propagation steps
            for (int i = 0; i < PAIRS; i++) {
                for (int k = 0; k < COMPONENTS; k++) {
                    tempFeatures[i][k] = 0;
                    for (int j = 0; j < PAIRS; j++) {
                        for (int m = 0; m < COMPONENTS; m++) {
                            tempFeatures[i][k] += adjacencyMatrices[i][j][gnn] * features[j][m] * gnnWeights[gnn][t][m][k];
                        }
                    }
                    tempFeatures[i][k] = max(0, tempFeatures[i][k]); // ReLU activation
                }
            }
            // Update features for the next layer
            for (int i = 0; i < PAIRS; i++) {
                for (int k = 0; k < COMPONENTS; k++) {
                    features[i][k] = tempFeatures[i][k];
                }
            }
        }
    }
    // Copy the refined features
    for (int i = 0; i < PAIRS; i++) {
        for (int k = 0; k < COMPONENTS; k++) {
            gnnRefinedFeatures[i][k] = features[i][k];
        }
    }
}

// Step 5: Perform Kernel PCA
function performKernelPCA() {
    eigenDecomposition(kernelMatrix, eigenvalues, eigenvectors);
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < COMPONENTS; j++) { // Use top COMPONENTS
            reducedMatrix[i][j] = dotProduct(kernelMatrix[i], eigenvectors[j]);
        }
    }
}

// Step 6: Generate trading signals
function generateSignals() {
    double mean = 0, stddev = 0;
    for (int i = 0; i < PAIRS; i++) {
        mean += reducedMatrix[i][0];
    }
    mean /= PAIRS;
    for (int i = 0; i < PAIRS; i++) {
        stddev += pow(reducedMatrix[i][0] - mean, 2);
    }
    stddev = sqrt(stddev / PAIRS);
    double threshold = mean + 1.0 * stddev;

    for (int i = 0; i < PAIRS; i++) {
        if (reducedMatrix[i][0] > threshold) signals[i] = 1; // Buy
        else if (reducedMatrix[i][0] < -threshold) signals[i] = -1; // Sell
        else signals[i] = 0; // Hold
    }
}

// Main function
function run() {
    set(PLOTNOW);

    // Step 1: Calculate volatilities
    calculateVolatilities();

    // Step 2: Perform Kernel PCA to reduce features
    performKernelPCA();

    // Step 3: Construct adjacency matrices for GNNs
    constructAdjacencyMatrices(reducedMatrix);

    // Step 4: Initialize GNN weights
    initializeGNNWeights();

    // Step 5: Apply GNN propagation
    propagateGNN(reducedMatrix);

    // Step 6: Generate trading signals
    generateSignals();

    // Step 7: Execute trades
    for (int i = 0; i < PAIRS; i++) {
        if (signals[i] > 0) enterLong(CurrencyPairs[i]);
        else if (signals[i] < 0) enterShort(CurrencyPairs[i]);
    }
}

#define PAIRS 28
#define COMPONENTS 3  // Number of PCA components
#define GNN_LAYERS 2  // Number of GNN layers
#define ACTIONS 3     // Buy, Sell, Hold

// Variables
string CurrencyPairs[PAIRS] = {
    "EURUSD", "GBPUSD", "USDJPY", "GBPJPY", "USDCAD", "EURAUD", "EURJPY",
    "AUDCAD", "AUDJPY", "AUDNZD", "AUDUSD", "CADJPY", "EURCAD", "EURCHF",
    "EURGBP", "EURNZD", "GBPCAD", "GBPCHF", "NZDCAD", "NZDJPY", "NZDUSD",
    "USDCHF", "CHFJPY", "AUDCHF", "GBPNZD", "NZDCHF", "CADCHF", "GBPAUD"
};

// Enhanced PCA, GNN, and Signal Variables
vars kernelMatrix[PAIRS][PAIRS];            // Kernel matrix for PCA
vars pcaReducedFeatures[PAIRS][COMPONENTS]; // PCA-reduced features for each pair
vars adjacencyMatrices[PAIRS][PAIRS];       // Adjacency matrices for GNNs
vars gnnWeights[GNN_LAYERS][COMPONENTS][COMPONENTS]; // GNN weights
vars gnnOutputs[PAIRS][ACTIONS];            // GNN probabilities for Buy/Sell/Hold
vars similarityMatrix[PAIRS][PAIRS];        // Cross-Entropy similarity matrix
vars refinedOutputs[PAIRS][ACTIONS];        // Refined GNN probabilities
vars signals[PAIRS];                        // Final trading signals

// Step 1: Perform Kernel PCA
function performKernelPCA() {
    eigenDecomposition(kernelMatrix, eigenvalues, eigenvectors);
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < COMPONENTS; j++) { // Use top COMPONENTS
            pcaReducedFeatures[i][j] = dotProduct(kernelMatrix[i], eigenvectors[j]);
        }
    }
}

// Step 2: Initialize GNN Weights
function initializeGNNWeights() {
    for (int l = 0; l < GNN_LAYERS; l++) {
        for (int i = 0; i < COMPONENTS; i++) {
            for (int j = 0; j < COMPONENTS; j++) {
                gnnWeights[l][i][j] = random() * 0.1; // Small random initialization
            }
        }
    }
}

// Step 3: GNN Propagation
function propagateGNN() {
    vars tempFeatures[PAIRS][COMPONENTS];
    for (int l = 0; l < GNN_LAYERS; l++) { // GNN propagation layers
        for (int i = 0; i < PAIRS; i++) {
            for (int k = 0; k < COMPONENTS; k++) {
                tempFeatures[i][k] = 0;
                for (int j = 0; j < PAIRS; j++) {
                    for (int m = 0; m < COMPONENTS; m++) {
                        tempFeatures[i][k] += adjacencyMatrices[i][j] * pcaReducedFeatures[j][m] * gnnWeights[l][m][k];
                    }
                }
                tempFeatures[i][k] = max(0, tempFeatures[i][k]); // ReLU activation
            }
        }
        // Update PCA features for the next layer
        for (int i = 0; i < PAIRS; i++) {
            for (int k = 0; k < COMPONENTS; k++) {
                pcaReducedFeatures[i][k] = tempFeatures[i][k];
            }
        }
    }
    // Generate probabilities (Buy/Sell/Hold) based on final GNN outputs
    for (int i = 0; i < PAIRS; i++) {
        for (int k = 0; k < ACTIONS; k++) {
            gnnOutputs[i][k] = random() * 0.1; // Placeholder for GNN probability outputs
        }
    }
}

// Step 4: Compute Cross-Entropy Similarity
function computeCrossEntropySimilarity() {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            similarityMatrix[i][j] = 0;
            for (int k = 0; k < ACTIONS; k++) {
                similarityMatrix[i][j] -= gnnOutputs[i][k] * log(gnnOutputs[j][k] + 1e-8);
            }
        }
    }
}

// Step 5: Refine GNN Outputs Using Similarity
function refineGNNOutputs() {
    for (int i = 0; i < PAIRS; i++) {
        for (int k = 0; k < ACTIONS; k++) {
            refinedOutputs[i][k] = 0;
            double weightSum = 0;
            for (int j = 0; j < PAIRS; j++) {
                refinedOutputs[i][k] += similarityMatrix[i][j] * gnnOutputs[j][k];
                weightSum += similarityMatrix[i][j];
            }
            refinedOutputs[i][k] /= (weightSum + 1e-8); // Normalize
        }
    }
}

// Step 6: Generate Trading Signals
function generateSignals() {
    for (int i = 0; i < PAIRS; i++) {
        signals[i] = refinedOutputs[i][0] - refinedOutputs[i][1]; // Buy-Sell difference
    }
}

// Step 7: Execute Trades
function executeTrades() {
    for (int i = 0; i < PAIRS; i++) {
        if (signals[i] > 0) enterLong(CurrencyPairs[i]);
        else if (signals[i] < 0) enterShort(CurrencyPairs[i]);
    }
}

// Main Function
function run() {
    set(PLOTNOW);

    // Step 1: Perform Kernel PCA
    performKernelPCA();

    // Step 2: Initialize GNN weights
    initializeGNNWeights();

    // Step 3: Propagate GNN
    propagateGNN();

    // Step 4: Compute Cross-Entropy Similarity
    computeCrossEntropySimilarity();

    // Step 5: Refine GNN outputs
    refineGNNOutputs();

    // Step 6: Generate trading signals
    generateSignals();

    // Step 7: Execute trades
    executeTrades();
}

#define PAIRS 28
#define COMPONENTS 3  // Number of PCA components
#define GNN_LAYERS 2  // Number of GNN layers
#define ACTIONS 3     // Buy, Sell, Hold

// Variables
string CurrencyPairs[PAIRS] = {
    "EURUSD", "GBPUSD", "USDJPY", "GBPJPY", "USDCAD", "EURAUD", "EURJPY",
    "AUDCAD", "AUDJPY", "AUDNZD", "AUDUSD", "CADJPY", "EURCAD", "EURCHF",
    "EURGBP", "EURNZD", "GBPCAD", "GBPCHF", "NZDCAD", "NZDJPY", "NZDUSD",
    "USDCHF", "CHFJPY", "AUDCHF", "GBPNZD", "NZDCHF", "CADCHF", "GBPAUD"
};

// Kernel PCA, GNN, and Signal Variables
vars kernelMatrix[PAIRS][PAIRS];            // Kernel matrix for PCA
vars pcaReducedFeatures[PAIRS][COMPONENTS]; // PCA-reduced features for each pair
vars adjacencyMatrices[PAIRS][PAIRS];       // Adjacency matrices for GNNs
vars gnnWeights[GNN_LAYERS][COMPONENTS][COMPONENTS]; // GNN weights
vars gnnOutputs[PAIRS][ACTIONS];            // GNN probabilities for Buy/Sell/Hold
vars similarityMatrix[PAIRS][PAIRS];        // Cross-Entropy similarity matrix
vars refinedOutputs[PAIRS][ACTIONS];        // Refined GNN probabilities
vars signals[PAIRS];                        // Final trading signals

// Step 1: Perform Kernel PCA
function performKernelPCA() {
    eigenDecomposition(kernelMatrix, eigenvalues, eigenvectors);
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < COMPONENTS; j++) { // Use top COMPONENTS
            pcaReducedFeatures[i][j] = dotProduct(kernelMatrix[i], eigenvectors[j]);
        }
    }
}

// Step 2: Initialize GNN Weights
function initializeGNNWeights() {
    for (int l = 0; l < GNN_LAYERS; l++) {
        for (int i = 0; i < COMPONENTS; i++) {
            for (int j = 0; j < COMPONENTS; j++) {
                gnnWeights[l][i][j] = random() * 0.1; // Small random initialization
            }
        }
    }
}

// Step 3: GNN Propagation
function propagateGNN() {
    vars tempFeatures[PAIRS][COMPONENTS];
    for (int l = 0; l < GNN_LAYERS; l++) { // GNN propagation layers
        for (int i = 0; i < PAIRS; i++) {
            for (int k = 0; k < COMPONENTS; k++) {
                tempFeatures[i][k] = 0;
                for (int j = 0; j < PAIRS; j++) {
                    for (int m = 0; m < COMPONENTS; m++) {
                        tempFeatures[i][k] += adjacencyMatrices[i][j] * pcaReducedFeatures[j][m] * gnnWeights[l][m][k];
                    }
                }
                tempFeatures[i][k] = max(0, tempFeatures[i][k]); // ReLU activation
            }
        }
        // Update PCA features for the next layer
        for (int i = 0; i < PAIRS; i++) {
            for (int k = 0; k < COMPONENTS; k++) {
                pcaReducedFeatures[i][k] = tempFeatures[i][k];
            }
        }
    }
    // Generate probabilities (Buy/Sell/Hold) based on final GNN outputs
    for (int i = 0; i < PAIRS; i++) {
        for (int k = 0; k < ACTIONS; k++) {
            gnnOutputs[i][k] = random() * 0.1; // Placeholder for GNN probability outputs
        }
    }
}

// Step 4: Compute Cross-Entropy Similarity
function computeCrossEntropySimilarity() {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            similarityMatrix[i][j] = 0;
            for (int k = 0; k < ACTIONS; k++) {
                similarityMatrix[i][j] -= gnnOutputs[i][k] * log(gnnOutputs[j][k] + 1e-8);
            }
        }
    }
}

// Step 5: Refine GNN Outputs Using Similarity
function refineGNNOutputs() {
    for (int i = 0; i < PAIRS; i++) {
        for (int k = 0; k < ACTIONS; k++) {
            refinedOutputs[i][k] = 0;
            double weightSum = 0;
            for (int j = 0; j < PAIRS; j++) {
                refinedOutputs[i][k] += similarityMatrix[i][j] * gnnOutputs[j][k];
                weightSum += similarityMatrix[i][j];
            }
            refinedOutputs[i][k] /= (weightSum + 1e-8); // Normalize
        }
    }
}

// Step 6: Generate Trading Signals
function generateSignals() {
    for (int i = 0; i < PAIRS; i++) {
        signals[i] = refinedOutputs[i][0] - refinedOutputs[i][1]; // Buy-Sell difference
    }
}

// Step 7: Execute Trades
function executeTrades() {
    for (int i = 0; i < PAIRS; i++) {
        if (signals[i] > 0) enterLong(CurrencyPairs[i]);
        else if (signals[i] < 0) enterShort(CurrencyPairs[i]);
    }
}

// Main Function
function run() {
    set(PLOTNOW);

    // Step 1: Perform Kernel PCA
    performKernelPCA();

    // Step 2: Initialize GNN weights
    initializeGNNWeights();

    // Step 3: Propagate GNN
    propagateGNN();

    // Step 4: Compute Cross-Entropy Similarity
    computeCrossEntropySimilarity();

    // Step 5: Refine GNN outputs
    refineGNNOutputs();

    // Step 6: Generate trading signals
    generateSignals();

    // Step 7: Execute trades
    executeTrades();
}

#define PAIRS 28
#define COMPONENTS 3     // Number of PCA components
#define GNN_LAYERS 2     // Number of GNN layers
#define ACTIONS 3        // Buy, Sell, Hold
#define LOOKBACK 100     // Lookback period for volatility calculation
#define VOL_KERNEL_WIDTH 0.5 // Width for Gaussian kernel
#define SIMILARITY_ALPHA 0.1 // Smoothing factor for similarity updates

// Declare currency pairs
string CurrencyPairs[PAIRS] = {
    "EURUSD", "GBPUSD", "USDJPY", "GBPJPY", "USDCAD", "EURAUD", "EURJPY",
    "AUDCAD", "AUDJPY", "AUDNZD", "AUDUSD", "CADJPY", "EURCAD", "EURCHF",
    "EURGBP", "EURNZD", "GBPCAD", "GBPCHF", "NZDCAD", "NZDJPY", "NZDUSD",
    "USDCHF", "CHFJPY", "AUDCHF", "GBPNZD", "NZDCHF", "CADCHF", "GBPAUD"
};

// Global Variables
vars kernelMatrix[PAIRS][PAIRS];            // Kernel matrix for PCA
vars pcaReducedFeatures[PAIRS][COMPONENTS]; // PCA-reduced features for each pair
vars adjacencyMatrices[PAIRS][PAIRS];       // Adjacency matrices for GNNs
vars gnnWeights[GNN_LAYERS][COMPONENTS][COMPONENTS]; // GNN weights
vars gnnOutputs[PAIRS][ACTIONS];            // GNN probabilities for Buy/Sell/Hold
vars similarityMatrix[PAIRS][PAIRS];        // Cross-Entropy similarity matrix
vars refinedOutputs[PAIRS][ACTIONS];        // Refined GNN probabilities
vars signals[PAIRS];                        // Final trading signals

// Utility Function: Calculate Rolling Volatility
function calcVolatility(string pair) {
    asset(pair);
    vars returns = series(log(priceClose() / priceClose(1)));
    return StdDev(returns, LOOKBACK);
}

// Step 1: Compute Kernel Matrix
function computeKernelMatrix() {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            vars sigma_i = series(calcVolatility(CurrencyPairs[i]));
            vars sigma_j = series(calcVolatility(CurrencyPairs[j]));
            vars volatilitySpread = series(abs(sigma_i[0] - sigma_j[0]));
            kernelMatrix[i][j] = exp(-volatilitySpread[0]^2 / (2 * VOL_KERNEL_WIDTH^2));
        }
    }
}

// Step 2: Perform Enhanced PCA
function performEnhancedPCA() {
    eigenDecomposition(kernelMatrix, eigenvalues, eigenvectors);
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < COMPONENTS; j++) {
            pcaReducedFeatures[i][j] = dotProduct(kernelMatrix[i], eigenvectors[j]);
        }
    }
}

// Step 3: Initialize GNN Weights
function initializeGNNWeights() {
    for (int l = 0; l < GNN_LAYERS; l++) {
        for (int i = 0; i < COMPONENTS; i++) {
            for (int j = 0; j < COMPONENTS; j++) {
                gnnWeights[l][i][j] = random() * 0.1; // Small random initialization
            }
        }
    }
}

// Step 4: GNN Propagation
function propagateGNN() {
    vars tempFeatures[PAIRS][COMPONENTS];
    for (int l = 0; l < GNN_LAYERS; l++) {
        for (int i = 0; i < PAIRS; i++) {
            for (int k = 0; k < COMPONENTS; k++) {
                tempFeatures[i][k] = 0;
                for (int j = 0; j < PAIRS; j++) {
                    for (int m = 0; m < COMPONENTS; m++) {
                        tempFeatures[i][k] += adjacencyMatrices[i][j] * pcaReducedFeatures[j][m] * gnnWeights[l][m][k];
                    }
                }
                tempFeatures[i][k] = max(0, tempFeatures[i][k]); // ReLU activation
            }
        }
        // Update PCA features for the next layer
        for (int i = 0; i < PAIRS; i++) {
            for (int k = 0; k < COMPONENTS; k++) {
                pcaReducedFeatures[i][k] = tempFeatures[i][k];
            }
        }
    }
    // Generate probabilities (Buy/Sell/Hold) based on final GNN outputs
    for (int i = 0; i < PAIRS; i++) {
        for (int k = 0; k < ACTIONS; k++) {
            gnnOutputs[i][k] = random() * 0.1; // Placeholder for GNN probability outputs
        }
    }
}

// Step 5: Compute Cross-Entropy Similarity
function computeCrossEntropySimilarity() {
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            similarityMatrix[i][j] = 0;
            for (int k = 0; k < ACTIONS; k++) {
                similarityMatrix[i][j] -= gnnOutputs[i][k] * log(gnnOutputs[j][k] + 1e-8);
            }
        }
    }
}

// Step 6: Refine GNN Outputs Using Similarity
function refineGNNOutputs() {
    for (int i = 0; i < PAIRS; i++) {
        for (int k = 0; k < ACTIONS; k++) {
            refinedOutputs[i][k] = 0;
            double weightSum = 0;
            for (int j = 0; j < PAIRS; j++) {
                refinedOutputs[i][k] += similarityMatrix[i][j] * gnnOutputs[j][k];
                weightSum += similarityMatrix[i][j];
            }
            refinedOutputs[i][k] /= (weightSum + 1e-8); // Normalize
        }
    }
}

// Step 7: Generate Trading Signals
function generateSignals() {
    for (int i = 0; i < PAIRS; i++) {
        signals[i] = refinedOutputs[i][0] - refinedOutputs[i][1]; // Buy-Sell difference
    }
}

// Step 8: Execute Trades
function executeTrades() {
    for (int i = 0; i < PAIRS; i++) {
        if (signals[i] > 0) enterLong(CurrencyPairs[i]);
        else if (signals[i] < 0) enterShort(CurrencyPairs[i]);
    }
}

// Main Function
function run() {
    set(PLOTNOW);

    // Step 1: Compute Kernel Matrix
    computeKernelMatrix();

    // Step 2: Perform Enhanced PCA
    performEnhancedPCA();

    // Step 3: Initialize GNN weights
    initializeGNNWeights();

    // Step 4: Propagate GNN
    propagateGNN();

    // Step 5: Compute Cross-Entropy Similarity
    computeCrossEntropySimilarity();

    // Step 6: Refine GNN outputs
    refineGNNOutputs();

    // Step 7: Generate trading signals
    generateSignals();

    // Step 8: Execute trades
    executeTrades();
}

#define PAIRS 28
#define COMPONENTS 3   // Number of PCA components
#define GNN_LAYERS 2   // Number of GNN layers
#define ACTIONS 3      // Buy, Sell, Hold

// Define currency pairs
string CurrencyPairs[PAIRS] = {
    "EURUSD", "GBPUSD", "USDJPY", "GBPJPY", "USDCAD", "EURAUD", "EURJPY",
    "AUDCAD", "AUDJPY", "AUDNZD", "AUDUSD", "CADJPY", "EURCAD", "EURCHF",
    "EURGBP", "EURNZD", "GBPCAD", "GBPCHF", "NZDCAD", "NZDJPY", "NZDUSD",
    "USDCHF", "CHFJPY", "AUDCHF", "GBPNZD", "NZDCHF", "CADCHF", "GBPAUD"
};

// Variables for PCA, GNN, and signals
vars volatilities[PAIRS];                   // Current volatilities
vars volChangeRate[PAIRS];                  // Volatility change rate
vars kernelMatrix[PAIRS][PAIRS];            // Kernel matrix for PCA
vars pcaReducedFeatures[PAIRS][COMPONENTS]; // PCA-reduced features
vars adjacencyMatrices[PAIRS][PAIRS];       // GNN adjacency matrices
vars gnnWeights[GNN_LAYERS][COMPONENTS][COMPONENTS]; // GNN weights
vars gnnOutputs[PAIRS][ACTIONS];            // GNN probabilities (Buy/Sell/Hold)
vars signals[PAIRS];                        // Final trading signals
vars eigenvalues[COMPONENTS];               // Eigenvalues from PCA

// Step 1: Calculate Volatility and Change Rate
function calculateVolatility() {
    for (int i = 0; i < PAIRS; i++) {
        asset(CurrencyPairs[i]);
        vars logReturns = series(priceClose(0) / priceClose(1) - 1); // Log returns
        volatilities[i] = sqrt(SMA(pow(logReturns, 2), 20));        // 20-bar rolling std dev
        volChangeRate[i] = volatilities[i] - volatilities[i+1];     // Change rate
    }
}

// Step 2: Perform Kernel PCA
function performKernelPCA() {
    // Construct Kernel Matrix
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            kernelMatrix[i][j] = exp(-pow(volatilities[i] - volatilities[j], 2) / (2 * 0.1 * 0.1)); // Gaussian kernel
        }
    }

    // Perform eigen decomposition (simplified example)
    vars eigenvectors;
    eigenDecomposition(kernelMatrix, eigenvalues, eigenvectors);
    
    // Reduce dimensions using top COMPONENTS
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < COMPONENTS; j++) {
            pcaReducedFeatures[i][j] = dotProduct(kernelMatrix[i], eigenvectors[j]);
        }
    }
}

// Step 3: Initialize GNN Weights
function initializeGNNWeights() {
    for (int l = 0; l < GNN_LAYERS; l++) {
        for (int i = 0; i < COMPONENTS; i++) {
            for (int j = 0; j < COMPONENTS; j++) {
                gnnWeights[l][i][j] = random() * 0.1; // Small random initialization
            }
        }
    }
}

// Step 4: GNN Propagation
function propagateGNN() {
    vars tempFeatures[PAIRS][COMPONENTS];
    for (int l = 0; l < GNN_LAYERS; l++) {
        for (int i = 0; i < PAIRS; i++) {
            for (int k = 0; k < COMPONENTS; k++) {
                tempFeatures[i][k] = 0;
                for (int j = 0; j < PAIRS; j++) {
                    for (int m = 0; m < COMPONENTS; m++) {
                        tempFeatures[i][k] += adjacencyMatrices[i][j] * pcaReducedFeatures[j][m] * gnnWeights[l][m][k];
                    }
                }
                tempFeatures[i][k] = max(0, tempFeatures[i][k]); // ReLU activation
            }
        }
        // Update PCA features for the next layer
        for (int i = 0; i < PAIRS; i++) {
            for (int k = 0; k < COMPONENTS; k++) {
                pcaReducedFeatures[i][k] = tempFeatures[i][k];
            }
        }
    }
    // Final probabilities for Buy, Sell, Hold
    for (int i = 0; i < PAIRS; i++) {
        for (int k = 0; k < ACTIONS; k++) {
            gnnOutputs[i][k] = softmax(tempFeatures[i][k]); // Example output
        }
    }
}

// Step 5: Generate Trading Signals with PCA and GNN Thresholds
function generateSignals() {
    // Calculate PCA Variance Contribution
    var totalVariance = 0;
    for (int k = 0; k < COMPONENTS; k++) {
        totalVariance += eigenvalues[k];
    }
    var pcaContribution = eigenvalues[0] / totalVariance; // Contribution of the top component

    // Calculate GNN Entropy for each pair
    vars gnnEntropy[PAIRS];
    for (int i = 0; i < PAIRS; i++) {
        gnnEntropy[i] = 0;
        for (int k = 0; k < ACTIONS; k++) {
            gnnEntropy[i] -= gnnOutputs[i][k] * log(gnnOutputs[i][k] + 1e-8);
        }
    }

    // Calculate Dynamic Thresholds with PCA and GNN
    vars dynamicThresholdBuy[PAIRS];
    vars dynamicThresholdSell[PAIRS];
    for (int i = 0; i < PAIRS; i++) {
        var meanVolChangeRate = SMA(volChangeRate, PAIRS);
        var stddevVolChangeRate = StdDev(volChangeRate, PAIRS);

        // Adjust thresholds with PCA and GNN contributions
        dynamicThresholdBuy[i] = meanVolChangeRate + 0.5 * stddevVolChangeRate * pcaContribution * (1 - gnnEntropy[i]);
        dynamicThresholdSell[i] = meanVolChangeRate - 0.5 * stddevVolChangeRate * pcaContribution * (1 - gnnEntropy[i]);
    }

    // Generate Trading Signals
    for (int i = 0; i < PAIRS; i++) {
        var gnnBuyProb = gnnOutputs[i][0];
        var gnnSellProb = gnnOutputs[i][1];

        signals[i] = gnnBuyProb - gnnSellProb; // Base signal

        // Incorporate dynamic thresholds
        if (signals[i] > dynamicThresholdBuy[i]) signals[i] = 1; // Strong Buy
        else if (signals[i] < dynamicThresholdSell[i]) signals[i] = -1; // Strong Sell
        else signals[i] = 0; // Hold
    }
}

// Step 6: Execute Trades
function executeTrades() {
    for (int i = 0; i < PAIRS; i++) {
        if (signals[i] == 1) enterLong(CurrencyPairs[i]); // Strong Buy
        else if (signals[i] == -1) enterShort(CurrencyPairs[i]); // Strong Sell
    }
}

// Main Strategy Function
function run() {
    set(PLOTNOW);

    // Calculate volatility and change rate
    calculateVolatility();

    // Perform kernel PCA
    performKernelPCA();

    // Initialize GNN weights (once)
    if (is(INITRUN)) initializeGNNWeights();

    // Propagate GNN
    propagateGNN();

    // Generate signals
    generateSignals();

    // Execute trades
    executeTrades();
}

#define PAIRS 28
#define COMPONENTS 3   // Number of PCA components
#define GNN_LAYERS 2   // Number of GNN layers
#define ACTIONS 3      // Buy, Sell, Hold

// Define currency pairs
string CurrencyPairs[PAIRS] = {
    "EURUSD", "GBPUSD", "USDJPY", "GBPJPY", "USDCAD", "EURAUD", "EURJPY",
    "AUDCAD", "AUDJPY", "AUDNZD", "AUDUSD", "CADJPY", "EURCAD", "EURCHF",
    "EURGBP", "EURNZD", "GBPCAD", "GBPCHF", "NZDCAD", "NZDJPY", "NZDUSD",
    "USDCHF", "CHFJPY", "AUDCHF", "GBPNZD", "NZDCHF", "CADCHF", "GBPAUD"
};

// Variables for PCA, GNN, and signals
vars volatilities[PAIRS];                   // Current volatilities
vars volClustering[PAIRS];                  // Volatility clustering scores
vars kernelMatrix[PAIRS][PAIRS];            // Kernel matrix for PCA
vars pcaReducedFeatures[PAIRS][COMPONENTS]; // PCA-reduced features
vars timeSeriesFeatures[PAIRS];             // Time-series features (e.g., autocorrelation)
vars timeDependentFeatures[PAIRS];          // Time-dependent features (e.g., volatility lag)
vars adjacencyMatrices[PAIRS][PAIRS];       // GNN adjacency matrices
vars gnnWeights[GNN_LAYERS][COMPONENTS][COMPONENTS]; // GNN weights
vars gnnOutputs[PAIRS][ACTIONS];            // GNN probabilities (Buy/Sell/Hold)
vars signals[PAIRS];                        // Final trading signals
vars eigenvalues[COMPONENTS];               // Eigenvalues from PCA

// Softmax function
var softmax(vars logits[], int index, int size) {
    var sum = 0;
    for (int i = 0; i < size; i++) {
        sum += exp(logits[i]); // Exponentiate each value
    }
    return exp(logits[index]) / (sum + 1e-8); // Normalize by the sum, avoiding division by zero
}

// Step 1: Calculate Volatility and Clustering Scores
function calculateVolatilityAndClustering() {
    for (int i = 0; i < PAIRS; i++) {
        asset(CurrencyPairs[i]);
        vars logReturns = series(log(priceClose(0) / priceClose(1))); // Log returns
        volatilities[i] = sqrt(SMA(pow(logReturns, 2), 20));          // 20-bar rolling std dev
        
        // Calculate clustering using past volatilities
        vars pastVolatilities = series(volatilities[i]);              // Volatility series
        volClustering[i] = SMA(pastVolatilities, 10) / stddev(pastVolatilities, 10); // Example metric
    }
}

// Step 2: Extract Time-Series Features
function extractTimeSeriesFeatures() {
    for (int i = 0; i < PAIRS; i++) {
        asset(CurrencyPairs[i]);
        vars logReturns = series(log(priceClose(0) / priceClose(1))); // Log returns
        
        // Autocorrelation as a feature
        timeSeriesFeatures[i] = autocorrelation(logReturns, 5);       // 5-lag autocorrelation
        
        // Time-dependent feature: Volatility lag
        timeDependentFeatures[i] = volatilities[i - 1];               // Previous volatility
    }
}

// Step 3: Perform Enhanced PCA
function performEnhancedPCA() {
    // Construct Kernel Matrix
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < PAIRS; j++) {
            double distance = pow(volatilities[i] - volatilities[j], 2) +
                              pow(volClustering[i] - volClustering[j], 2) +
                              pow(timeSeriesFeatures[i] - timeSeriesFeatures[j], 2);
            kernelMatrix[i][j] = exp(-distance / (2 * 0.1 * 0.1)); // Gaussian kernel
        }
    }

    // Perform eigen decomposition
    vars eigenvectors;
    eigenDecomposition(kernelMatrix, eigenvalues, eigenvectors);

    // Reduce dimensions using top COMPONENTS
    for (int i = 0; i < PAIRS; i++) {
        for (int j = 0; j < COMPONENTS; j++) {
            pcaReducedFeatures[i][j] = dotProduct(kernelMatrix[i], eigenvectors[j]);
        }
    }
}

// Step 4: Initialize GNN Weights
function initializeGNNWeights() {
    for (int l = 0; l < GNN_LAYERS; l++) {
        for (int i = 0; i < COMPONENTS; i++) {
            for (int j = 0; j < COMPONENTS; j++) {
                gnnWeights[l][i][j] = random() * 0.1; // Small random initialization
            }
        }
    }
}

// Step 5: GNN Propagation
function propagateGNN() {
    vars tempFeatures[PAIRS][COMPONENTS];
    for (int l = 0; l < GNN_LAYERS; l++) {
        for (int i = 0; i < PAIRS; i++) {
            for (int k = 0; k < COMPONENTS; k++) {
                tempFeatures[i][k] = 0;
                for (int j = 0; j < PAIRS; j++) {
                    for (int m = 0; m < COMPONENTS; m++) {
                        tempFeatures[i][k] += adjacencyMatrices[i][j] * pcaReducedFeatures[j][m] * gnnWeights[l][m][k];
                    }
                }
                tempFeatures[i][k] = max(0, tempFeatures[i][k]); // ReLU activation
            }
        }
    }

    // Final probabilities for Buy, Sell, Hold using softmax
    for (int i = 0; i < PAIRS; i++) {
        vars logits[ACTIONS]; // Placeholder for raw GNN output logits
        for (int k = 0; k < ACTIONS; k++) {
            logits[k] = tempFeatures[i][k]; // Assign the logits (raw outputs)
        }

        // Apply softmax to calculate probabilities
        for (int k = 0; k < ACTIONS; k++) {
            gnnOutputs[i][k] = softmax(logits, k, ACTIONS);
        }
    }
}

// Step 6: Generate Trading Signals
function generateSignals() {
    for (int i = 0; i < PAIRS; i++) {
        var gnnBuyProb = gnnOutputs[i][0];
        var gnnSellProb = gnnOutputs[i][1];

        signals[i] = gnnBuyProb - gnnSellProb; // Base signal

        // Threshold decision
        if (signals[i] > 0.5) signals[i] = 1;  // Strong Buy
        else if (signals[i] < -0.5) signals[i] = -1; // Strong Sell
        else signals[i] = 0; // Hold
    }
}

// Step 7: Execute Trades
function executeTrades() {
    for (int i = 0; i < PAIRS; i++) {
        if (signals[i] == 1) enterLong(CurrencyPairs[i]); // Strong Buy
        else if (signals[i] == -1) enterShort(CurrencyPairs[i]); // Strong Sell
    }
}

// Main Strategy Function
function run() {
    set(PLOTNOW);

    // Step 1: Calculate volatility and clustering
    calculateVolatilityAndClustering();

    // Step 2: Extract time-series features
    extractTimeSeriesFeatures();

    // Step 3: Perform enhanced PCA
    performEnhancedPCA();

    // Step 4: Initialize GNN weights (once)
    if (is(INITRUN)) initializeGNNWeights();

    // Step 5: Propagate GNN
    propagateGNN();

    // Step 6: Generate trading signals
    generateSignals();

    // Step 7: Execute trades
    executeTrades();
}

// Declare variables
var a, s, x;             // Scalars used in calculations
int i;                   // Index variable
vars f[10];              // Array for coefficients or signal values

// Ensure the array 'f' has values before computation
f[0] = 1; f[1] = 2; f[2] = 3; f[3] = 4; f[4] = 5; 
f[5] = 6; f[6] = 7; f[7] = 8; f[8] = 9; f[9] = 10; // Example initialization

// Compute 'filt' using ifelse() instead of ternary operators
var filt = pow(a, i) * s 
    + ifelse(i >= 1, i * x * f[1], 0) 
    - ifelse(i >= 2, 36 * pow(x, 2) * f[2], 0) 
    + ifelse(i >= 3, 84 * pow(x, 3) * f[3], 0)
    - ifelse(i >= 4, 126 * pow(x, 4) * f[4], 0) 
    + ifelse(i >= 5, 126 * pow(x, 5) * f[5], 0) 
    - ifelse(i >= 6, 84 * pow(x, 6) * f[6], 0)
    + ifelse(i >= 7, 36 * pow(x, 7) * f[7], 0) 
    - ifelse(i >= 8, 9 * pow(x, 8) * f[8], 0) 
    + ifelse(i == 9, pow(x, 9) * f[9], 0);

// Output result
printf("The value of filt is: %f", filt);

(* Helper function to check if a queen can be placed at (row, col) *)
isSafe[board_, row_, col_] := 
  And @@ (And[# != row, # + board[[#]] != row + col, # - board[[#]] != row - col] & /@ Range[col - 1]);

(* Recursive function to solve the 9-queens problem *)
solveQueens[board_, col_] := 
  If[col > 9, (* If all queens are placed, return the solution *)
     Print[board];,
     (* Else, try placing the queen in each row of the current column *)
     Do[
       If[isSafe[board, row, col],
          solveQueens[ReplacePart[board, col -> row], col + 1]; (* Recur for the next column *)
       ],
       {row, 1, 9}
     ]
  ];

#include <stdio.h>

#define N 9  // Board size for the 9-queens problem

// Function to check if a queen can be placed at board[row][col]
int isSafe(int board[N], int row, int col) {
    int i;
    for(i = 0; i < col; i++) {
        if(board[i] == row || 
           board[i] - i == row - col || 
           board[i] + i == row + col)
            return 0;  // Not safe
    }
    return 1;  // Safe position
}

// Recursive function to solve the 9-queens problem
void solveQueens(int board[N], int col) {
    if(col >= N) {  // If all queens are placed, print the solution
        printf("\nSolution: ");
        int i;
        for(i = 0; i < N; i++) 
            printf("%d ", board[i] + 1);  // Convert 0-based to 1-based
        printf("\n");
        return;
    }

    // Try placing a queen in each row of the current column
    int row;
    for(row = 0; row < N; row++) {
        if(isSafe(board, row, col)) {
            board[col] = row;  // Place queen
            solveQueens(board, col + 1);  // Recur for the next column
            board[col] = 0;  // Backtrack
        }
    }
}

// Main function to initialize the board and start solving
void main() {
    int board[N] = {0};  // Initialize board with all zeroes
    solveQueens(board, 0);  // Start recursion from column 0
}

#include <stdio.h>

#define N 9  // Board size for the 9-queens problem

// Function to check if a queen can be placed at board[row][col]
int isSafe(int board[N], int row, int col) {
    int i;
    for (i = 0; i < col; i++) {
        if (board[i] == row || 
            board[i] - i == row - col || 
            board[i] + i == row + col) 
            return 0;  // Not safe
    }
    return 1;  // Safe position
}

// Function in `f(x) = f(x - 1)` form
int solveQueens(int board[N], int col) {
    if (col == 0) return 1;  // Base case: when col reaches 0, return success

    int prev = solveQueens(board, col - 1);  // Recursive call f(x) = f(x - 1)
    
    if (prev == 0) return 0;  // If previous step failed, return failure

    int row;
    for (row = 0; row < N; row++) {
        if (isSafe(board, row, col - 1)) {  // Check previous column
            board[col - 1] = row;
            return 1;  // Solution found
        }
    }

    return 0;  // No solution found, return failure
}

// Main function to initialize the board and start solving
void main() {
    int board[N] = {0};  // Initialize board with all zeroes
    solveQueens(board, N);  // Start recursion from column N (reverse order)
}

(=!BA#9]7<"`z2Vxwv4Ts+Oqponm.-j*,)(/&%cba`_^] , (=!BA#9]7<"`z2Vxwv4Ts+Oqponm.-j*,)(/&%cba`_^]

import matplotlib.pyplot as plt
import networkx as nx

# Create a directed graph
G = nx.DiGraph()

# Recursive function to generate the war recursion tree with unique labels
def add_war_nodes(graph, parent, depth, max_depth):
    if depth > max_depth:
        return

    # Generate unique battle names
    left_battle = f"Battle-{depth}L"
    right_battle = f"Battle-{depth}R"

    # Add edges to represent battles branching from strategic decisions
    graph.add_edge(parent, left_battle)
    graph.add_edge(parent, right_battle)

    # Recursively create deeper battle strategies
    add_war_nodes(graph, left_battle, depth + 1, max_depth)
    add_war_nodes(graph, right_battle, depth + 1, max_depth)

# Root node representing the beginning of war decisions
G.add_node("War Begins")

# Generate recursive war strategy tree
add_war_nodes(G, "War Begins", 1, 5)  # Depth of recursion is 5

# Set up figure size
plt.figure(figsize=(14, 10))

# Recalculate positions for better label visibility
pos = nx.spring_layout(G, seed=42)  

# Draw nodes and edges without labels to prevent overlap
nx.draw(G, pos, with_labels=False, node_color="black", edge_color="gray", node_size=200)

# Draw labels separately in red with a white background for clarity
for node, (x, y) in pos.items():
    plt.text(x, y + 0.03, node, fontsize=9, ha='center', color="red", 
             bbox=dict(facecolor="white", edgecolor="none", boxstyle="round,pad=0.2"))

# Set the title of the plot
plt.title("The War of Shifting Fronts - Hidden Recursion Tree with Clear Labels")

# Show the final visualization
plt.show()

// Structure representing a war decision node
typedef struct {
    char name[50];  // Fixed-size character array for name
    int strength;   // Hidden game-theoretic influence
    int risk;       // Determines adaptability to opposition
} BattleNode;

// Global statistics variables
int battleCount = 0;
var totalStrength = 0;
var totalRisk = 0;
int maxStrength = 0;
int minRisk = 100;  // Start with a high value to track lowest risk

// Function to generate a pseudo-random number in a range (Zorro's method)
int randomInt(int min, int max) {
    return min + (int)((max - min) * random()); 
}

// Recursive function to simulate war strategies with game-theoretic decisions
void simulateBattle(BattleNode* battle, int depth, int maxDepth) {
    if (depth > maxDepth) return;  // Base case: stop recursion

    // Generate random strategy values using Zorro's `random()` function
    battle->strength = randomInt(1, 100);
    battle->risk = randomInt(1, 100); // Ensuring no negative values

    // Update statistics
    battleCount++;
    totalStrength += battle->strength;
    totalRisk += battle->risk;
    
    if (battle->strength > maxStrength) maxStrength = battle->strength;
    if (battle->risk < minRisk) minRisk = battle->risk;

    // Debugging: Print battle details to log
    printf("\n[Battle %d] %s | Strength: %d | Risk: %d", 
           battleCount, battle->name, battle->strength, battle->risk);

    // Hidden recursive expansion influenced by game theory
    if (battle->strength > battle->risk) {
        battle->strength += randomInt(1, 50);
        battle->risk -= randomInt(1, 20);
    } else {
        battle->strength -= randomInt(1, 30);
        battle->risk += randomInt(1, 10);
    }

    // Ensure risk does not go negative
    if (battle->risk < 0) battle->risk = 0;

    // Recursively simulate further battles
    if (depth + 1 <= maxDepth) {
        BattleNode nextBattle;
        sprintf(nextBattle.name, "%s-%d", battle->name, depth);
        simulateBattle(&nextBattle, depth + 1, maxDepth);
    }
}

// Function to display final statistics
void displayStatistics() {
    printf("\n--- War Simulation Statistics ---");
    printf("\nTotal Battles Simulated: %d", battleCount);

    if (battleCount > 0) {
        printf("\nAverage Strength: %.2f", totalStrength / (var)battleCount);
        printf("\nAverage Risk: %.2f", totalRisk / (var)battleCount);
    }
    printf("\nMax Strength Encountered: %d", maxStrength);
    printf("\nMin Risk Encountered: %d", minRisk);
    printf("\n--------------------------------\n");
}

// Main function to trigger the war simulation in Zorro
void run() {  
    if (is(INITRUN)) {  // Run only once at the start
        BattleNode root;
        strcpy(root.name, "War Begins");
        simulateBattle(&root, 1, 5);  // Start recursive war simulation
        
        // Display statistics at the end
        displayStatistics();
    }
}

[Battle 4] War Begins-1-2-3 | Strength: 82 | Risk: -13
[Battle 5] War Begins-1-2-3-4 | Strength: 77 | Risk: 17
--- War Simulation Statistics ---
Total Battles Simulated: 5
Average Strength: -2.00
Average Risk: -1.80
Max Strength Encountered: 82
Min Risk Encountered: -79
--------------------------------

typedef struct Order {
    double price;
    int size;
    double spread;  
    int parentIndex;  
} Order;

void addOrder(Order* orderBook, int index, double price, int size, int totalOrders) {
    if (index >= totalOrders) return;  

    price = randomizePrice(price + random() * 5, VOLATILITY * (0.8 + random() * 0.6));  
    size = generateOrderSize(MAX_ORDER_SIZE);
    double spread = clamp(0.007 + random() * 0.025, 0.007, 0.04);  //  Spread cannot be negative

    orderBook[index].price = price;
    orderBook[index].size = size;
    orderBook[index].spread = spread;

    if (index > 0)
        orderBook[index].parentIndex = index - 1;  
    else
        orderBook[index].parentIndex = -1;  

    print(TO_LOG, " Order Added: Index %d | Price: %.4f | Size: %d | Spread: %.5f", index, price, size, spread);

    if (random() < 0.75 && index + 1 < totalOrders) {  
        int newSize = generateOrderSize(size * (0.8 + random() * 0.3));
        addOrder(orderBook, index + 1, price - 0.01 * randomInt(1, 12), newSize, totalOrders);
    }
}

double calculateSpread(Order* orderBook, int index) {
    if (index < 0 || index >= MAX_ORDERS) return 0.007;  //  Prevent invalid indices

    double baseSpread = clamp(0.007 + random() * 0.02, 0.007, 0.04);  
    double hftPressure = ifelse(random() < 0.5, 0.002 + (random() - 0.5) * 0.005, 0.001);  
    double volatilityFactor = (random() - 0.5) * 0.03;  

    double spread = baseSpread + (0.025 - orderBook[index].price * 0.0003) - hftPressure + volatilityFactor;
    return clamp(spread, 0.007, 0.04);  
}

void addOrder(Order* orderBook, int index, double price, int size, int totalOrders) {
    if (index >= totalOrders) return;  

    price = randomizePrice(price + random() * 5, VOLATILITY * (0.8 + random() * 0.6));  
    size = generateOrderSize(MAX_ORDER_SIZE);
    double spread = clamp(0.007 + random() * 0.025, 0.007, 0.04);  //  Spread cannot be negative

    orderBook[index].price = price;
    orderBook[index].size = size;
    orderBook[index].spread = spread;

    if (index > 0)
        orderBook[index].parentIndex = index - 1;  
    else
        orderBook[index].parentIndex = -1;  

    print(TO_LOG, " Order Added: Index %d | Price: %.4f | Size: %d | Spread: %.5f", index, price, size, spread);

    if (random() < 0.75 && index + 1 < totalOrders) {  
        int newSize = generateOrderSize(size * (0.8 + random() * 0.3));
        addOrder(orderBook, index + 1, price - 0.01 * randomInt(1, 12), newSize, totalOrders);
    }
}

#define MIN_ORDERS 5  
#define MAX_ORDERS 15  
#define MIN_ORDER_SIZE 5  
#define MAX_ORDER_SIZE 100  
#define VOLATILITY 0.09  //  Slightly increased to ensure better price fluctuations
#define MAX_DEPTH 10  

void initializeRandomSeed() {
    seed(random() * timer());
}

int randomInt(int min, int max) {
    return clamp(min + (int)((max - min + 1) * random()), min, max);
}

double clamp(double x, double min, double max) {
    return ifelse(x < min, min, ifelse(x > max, max, x));
}

//  Ensures Order Sizes Are Always in a Valid Range
int generateOrderSize(int maxSize) {
    double randFactor = random();
    int size = MIN_ORDER_SIZE + (int)((randFactor * randFactor * (maxSize - MIN_ORDER_SIZE)) * (0.9 + random() * 0.5));  
    return clamp(size, MIN_ORDER_SIZE, MAX_ORDER_SIZE);
}

//  Fully Randomized Order Prices Within a Safe Range
double randomizePrice(double baseValue, double volatility) {
    double direction = ifelse(random() < 0.5, -1, 1);  
    double priceChange = direction * (random() * volatility * 18 + random() * 12);  
    double newPrice = baseValue + priceChange;
    return clamp(newPrice, 50, 200);
}

typedef struct Order {
    double price;
    int size;
    double spread;  
    int parentIndex;  
} Order;

//  Ensures Safe Order Creation with Valid Values
void addOrder(Order* orderBook, int index, double price, int size, int totalOrders) {
    if (index >= totalOrders) return;  

    price = randomizePrice(price + random() * 5, VOLATILITY * (0.8 + random() * 0.6));  
    size = generateOrderSize(MAX_ORDER_SIZE);
    double spread = clamp(0.007 + random() * 0.025, 0.007, 0.04);  //  Spread cannot be negative

    orderBook[index].price = price;
    orderBook[index].size = size;
    orderBook[index].spread = spread;

    if (index > 0)
        orderBook[index].parentIndex = index - 1;  
    else
        orderBook[index].parentIndex = -1;  

    print(TO_LOG, " Order Added: Index %d | Price: %.4f | Size: %d | Spread: %.5f", index, price, size, spread);

    if (random() < 0.75 && index + 1 < totalOrders) {  
        int newSize = generateOrderSize(size * (0.8 + random() * 0.3));
        addOrder(orderBook, index + 1, price - 0.01 * randomInt(1, 12), newSize, totalOrders);
    }
}

//  Ensures Safe and Realistic Spread Calculation
double calculateSpread(Order* orderBook, int index) {
    if (index < 0 || index >= MAX_ORDERS) return 0.007;  //  Prevent invalid indices

    double baseSpread = clamp(0.007 + random() * 0.02, 0.007, 0.04);  
    double hftPressure = ifelse(random() < 0.5, 0.002 + (random() - 0.5) * 0.005, 0.001);  
    double volatilityFactor = (random() - 0.5) * 0.03;  

    double spread = baseSpread + (0.025 - orderBook[index].price * 0.0003) - hftPressure + volatilityFactor;
    return clamp(spread, 0.007, 0.04);  
}

//  Main Trading Simulation Function
void run() {
    set(LOGFILE);  
    Verbose = 2;

    initializeRandomSeed();

    int totalOrders = randomInt(MIN_ORDERS, MAX_ORDERS);  //  Ensures a dynamic number of orders

    static Order orderBook[MAX_ORDERS];  

    int i;
    for (i = 0; i < totalOrders; i++) {  
        orderBook[i].price = clamp(100.0 + random() * 8, 50, 200);  
        orderBook[i].size = generateOrderSize(MAX_ORDER_SIZE);  
        orderBook[i].spread = clamp(0.007 + random() * 0.02, 0.007, 0.04);  
        orderBook[i].parentIndex = -1;  
    }

    addOrder(orderBook, 0, 100.00 + random() * 6, generateOrderSize(85), totalOrders);

    vars SpreadSeries = series(0);
    vars PriceSeries = series(0);

    for (i = 1; i <= MAX_DEPTH; i++) { 
        int orderIndex = randomInt(0, totalOrders - 1);  //  Ensures valid index selection
        double spread = calculateSpread(orderBook, orderIndex);  
        SpreadSeries[0] = spread;
        PriceSeries[0] = orderBook[orderIndex].price;

        plotBar("Spreads", i, spread * 10000, 1, SUM + BARS, RED);
        plot("Price", PriceSeries[0], LINE, BLUE);
        plotBar("Order Sizes", i, orderBook[orderIndex].size, 1, SUM + BARS, GREEN);

        print(TO_LOG, " Depth %d: Order Index = %d | Spread = %.5f | Price = %.4f | Order Size = %d",
              i, orderIndex, spread, PriceSeries[0], orderBook[orderIndex].size);
    }
}

#define INT_BITS 32
#define MAX_ASSETS 1000  

typedef struct TrieNode {
    struct TrieNode* bit[2];
} TrieNode;

// Dynamically Allocate Trie Nodes
TrieNode* newTrieNode() {
    TrieNode* newNode = (TrieNode*)malloc(sizeof(TrieNode));  
    if (!newNode) {
        printf("\n Memory allocation failed in newTrieNode()");
        return NULL;
    }
    newNode->bit[0] = NULL;
    newNode->bit[1] = NULL;
    return newNode;
}

// Free Trie Memory After Use
void freeTrie(TrieNode* root) {
    if (!root) return;
    freeTrie(root->bit[0]);
    freeTrie(root->bit[1]);
    free(root);
}

// Find the Highest Bit Position in the Dataset
int findHighestBit(int* numbers, int size) {
    int highestBit = 0;
    int i;
    for (i = 0; i < size; i++) {
        int num = numbers[i];
        int bitPos = 0;
        while (num) {
            bitPos++;
            num >>= 1;
        }
        if (bitPos > highestBit) highestBit = bitPos;
    }
    return highestBit - 1;  // Only use as many bits as needed
}

// Insert a Number into the Trie
void insert(TrieNode* root, int number, int highestBit) {
    if (!root) {
        printf("\n Error: Root is NULL in insert()! Skipping...\n");
        return;
    }

    TrieNode* current = root;
    int i;
    for (i = highestBit; i >= 0; i--) {
        int bit = (number >> i) & 1;
        if (!current->bit[bit]) {
            current->bit[bit] = newTrieNode();
            if (!current->bit[bit]) {
                printf("\n Error: Trie Node Creation Failed at Bit %d! Skipping...\n", i);
                return;
            }
        }
        current = current->bit[bit];
    }
}

// Find the Maximum XOR for a Given Number
int findMaxXOR(TrieNode* root, int number, int highestBit) {
    TrieNode* current = root;
    int maxXOR = 0;
    int i;
    for (i = highestBit; i >= 0; i--) {
        int bit = (number >> i) & 1;
        if (current->bit[1 - bit]) {
            maxXOR |= (1 << i);
            current = current->bit[1 - bit];
        } else {
            current = current->bit[bit];
        }
    }
    return maxXOR;
}

// Brute Force XOR Calculation
void maxXorBruteForce(int* assetReturns, int size) {
    int maxXOR = 0, best1 = 0, best2 = 0;
    int i, j;
    var start = timer();  // Start Timing

    for (i = 0; i < size; i++) {
        for (j = i + 1; j < size; j++) {
            int currentXOR = assetReturns[i] ^ assetReturns[j];
            if (currentXOR > maxXOR) {
                maxXOR = currentXOR;
                best1 = assetReturns[i];
                best2 = assetReturns[j];
            }
        }
    }

    var execTime = (timer() - start) * 1000;  // End Timing
    printf("\n Brute Force XOR: (%d, %d) -> XOR: %d | Time: %.3f ms", best1, best2, maxXOR, execTime);
}

// Optimized Max XOR Function (Trie)
void maxXorOptimized(int* assetReturns, int size) {
    TrieNode* root = newTrieNode();
    if (!root) return;

    int highestBit = findHighestBit(assetReturns, size);
    insert(root, assetReturns[0], highestBit);

    int maxXOR = 0, best1 = 0, best2 = 0;
    int i;
    var start = timer();  // Start Timing

    for (i = 1; i < size; i++) {
        int currentXOR = findMaxXOR(root, assetReturns[i], highestBit);
        if (currentXOR > maxXOR) {
            maxXOR = currentXOR;
            best1 = assetReturns[i];
            best2 = best1 ^ maxXOR;
        }
        insert(root, assetReturns[i], highestBit);
    }

    var execTime = (timer() - start) * 1000;  // End Timing
    printf("\n Optimized Trie XOR: (%d, %d) -> XOR: %d | Time: %.3f ms", best1, best2, maxXOR, execTime);

    freeTrie(root);  // Free Memory
}

// Generate Proper Random Asset Returns
void generateRandomAssetReturns(var* assetReturns, int numAssets, int numBars) {
    int i, j;
    printf("\n Debugging Random Values Before Conversion:\n");

    for (i = 0; i < numAssets; i++) {
        vars RandomSeries = series(0);  // Create a series to maintain randomness
        
        printf("Asset %d: ", i + 1);
        
        for (j = 0; j < numBars; j++) {
            if (j == 0)
                RandomSeries[j] = random();  // First value is random
            else
                RandomSeries[j] = RandomSeries[j - 1] + random() - 0.5;  //  Follow series logic
            
            assetReturns[i * numBars + j] = RandomSeries[j];  //  Store random values
            printf("%.5f ", assetReturns[i * numBars + j]);  //  Print values for debugging
        }
        printf("\n");
    }
}

// Convert Asset Returns to Binary Representation
int convertReturnsToBinary(var* returns, int length) {
    int binaryValue = 0;
    int i;

    for (i = 0; i < length; i++) {
        if (returns[i] > 0.05) binaryValue |= (1 << i);  
        else if (returns[i] < -0.05) binaryValue |= (1 << (i + length));  
    }

    return binaryValue;
}

// Lite-C Main Function
function run() {
    if (is(INITRUN)) {
        int numAssets = 1000;
        int numBars = 5;
        int i;
        int assetBinaryReturns[MAX_ASSETS];
        var* assetReturns = (var*)malloc(numAssets * numBars * sizeof(var));

        if (!assetReturns) {
            printf("\n Memory Allocation Failed for assetReturns! Exiting...\n");
            return;
        }

        generateRandomAssetReturns(assetReturns, numAssets, numBars);

        printf("\n Debugging Binary Conversions:\n");

        for (i = 0; i < numAssets; i++) {
            assetBinaryReturns[i] = convertReturnsToBinary(&assetReturns[i * numBars], numBars);
            printf("Asset %d Binary: %d\n", i + 1, assetBinaryReturns[i]);  //  Print binary values
        }

        //  Compare Brute Force and Optimized Trie Method
        maxXorBruteForce(assetBinaryReturns, numAssets);
        maxXorOptimized(assetBinaryReturns, numAssets);

        free(assetReturns);
    }
}

Asset 994 Binary: 775
Asset 995 Binary: 992
Asset 996 Binary: 992
Asset 997 Binary: 961
Asset 998 Binary: 961
Asset 999 Binary: 961
Asset 1000 Binary: 992
Brute Force XOR: (31, 992) -> XOR: 1023 | Time: 4095.300 ms
Optimized Trie XOR: (992, 31) -> XOR: 1023 | Time: 488.400 ms

#define MIN_ORDERS 5  
#define MAX_ORDERS 15  
#define MIN_ORDER_SIZE 5  
#define MAX_ORDER_SIZE 100  
#define BASE_VOLATILITY 0.09  
#define MAX_DEPTH 10  
#define MAX_RETURNS 10  //  Track the last 10 returns

double eurusd_returns[MAX_RETURNS];  //  Store past returns
int return_index = 0;                //  Index for updating returns

//  Function to Calculate Variance of EUR/USD Returns
double calculate_variance(double* returns, int n) {
    double mean = 0.0;
    int i;
    for (i = 0; i < n; i++) {  
        mean += returns[i];
    }
    mean /= n;
    
    double variance = 0.0;
    for (i = 0; i < n; i++) {  
        variance += pow(returns[i] - mean, 2);
    }
    return variance / n;
}

//  Compute Inverse-Variance Portfolio Weight
double compute_inverse_variance_weight(double variance) {
    return ifelse(variance > 0, 1.0 / variance, 1.0);  // Prevent division by zero
}

//  Initialize Random Seed
void initializeRandomSeed() {
    seed(random() * timer());
}

//  Generate Random Integer
int randomInt(int min, int max) {
    return clamp(min + (int)((max - min + 1) * random()), min, max);
}

//  Clamp Values to a Range
double clamp(double x, double min, double max) {
    return ifelse(x < min, min, ifelse(x > max, max, x));
}

//  Generate Order Size as a Random Value between MIN_ORDER_SIZE and MAX_ORDER_SIZE
int generateOrderSize(int maxSize) {
    return randomInt(MIN_ORDER_SIZE, maxSize);
}

//  Generate a Random Spread between 0.002 and 0.009
double updateSpread(double baseSpread, int orderIndex) {
    // Directly generate a random spread within the prescribed limits.
    double newSpread = 0.002 + random() * (0.009 - 0.002);
    return clamp(newSpread, 0.002, 0.009);
}

//  Struct for Order Book
typedef struct Order {
    double price;
    int size;
    double spread;  
    int parentIndex;  
} Order;

//  Ensure Unique Spread by Adjusting Until Different from Previous Order
void addOrder(Order* orderBook, int index, double price, int totalOrders) {
    if (index >= totalOrders)
        return;  

    price = price + (random() * 5);  
    int size = generateOrderSize(MAX_ORDER_SIZE);
    // Generate a random spread within 0.002 to 0.009.
    double spread = 0.002 + random() * (0.009 - 0.002);
    spread = clamp(spread, 0.002, 0.009);

    // If there's a previous order, regenerate the spread until it differs.
    if (index > 0) {
        while (spread == orderBook[index - 1].spread) {
            spread = 0.002 + random() * (0.009 - 0.002);
            spread = clamp(spread, 0.002, 0.009);
        }
    }

    orderBook[index].price = price;
    orderBook[index].size = size;
    orderBook[index].spread = spread;
    orderBook[index].parentIndex = ifelse(index > 0, index - 1, -1);

    print(TO_LOG, " Order Added: Index %d | Price: %.4f | Size: %d | Spread: %.5f", 
          index, price, size, spread);

    if (random() < 0.75 && index + 1 < totalOrders) {  
        addOrder(orderBook, index + 1, price - 0.01 * randomInt(1, 12), totalOrders);
    }
}

//  Update Returns for Variance Calculation (Simulating Market Returns)
void updateReturns(double new_return) {
    double randomFactor = 1 + (random() - 0.5) * 1.5;  // Introduce more randomness
    eurusd_returns[return_index] = new_return * randomFactor;  
    return_index = (return_index + 1) % MAX_RETURNS;
}

//  Smart Order Selection for Market Depth
int selectRandomOrder(int totalOrders) {
    int index = randomInt(0, totalOrders - 1);
    return ifelse(random() < 0.3 && index > 0, index - 1, index);
}

//  Main Trading Simulation with Updates to All Order Parameters
void run() {
    set(LOGFILE | PLOTNOW);  
    Verbose = 2;
    initializeRandomSeed();

    int totalOrders = randomInt(MIN_ORDERS, MAX_ORDERS);  
    static Order orderBook[MAX_ORDERS];  

    int i;
    // Initialize the order book with random values.
    for (i = 0; i < totalOrders; i++) {  
        orderBook[i].price = clamp(100.0 + random() * 8, 50, 200);  
        orderBook[i].size = generateOrderSize(MAX_ORDER_SIZE);  
        orderBook[i].spread = updateSpread(0.002 + random() * 0.007, i);  
        orderBook[i].parentIndex = -1;  
    }

    // Create a recursive series of orders.
    addOrder(orderBook, 0, 100.00 + random() * 6, totalOrders);

    vars SpreadSeries = series(0);
    vars PriceSeries = series(0);
    vars OrderSizeSeries = series(0);

    // Update loop: re-randomize price, size, and spread for a randomly selected order.
    for (i = 1; i <= MAX_DEPTH; i++) { 
        int orderIndex = selectRandomOrder(totalOrders);  

        // Update price and size randomly.
        orderBook[orderIndex].price = clamp(100.0 + random() * 8, 50, 200);
        orderBook[orderIndex].size = generateOrderSize(MAX_ORDER_SIZE);

        // Update spread while ensuring it is different from the previous spread.
        double newSpread = updateSpread(orderBook[orderIndex].spread, orderIndex);
        orderBook[orderIndex].spread = newSpread;  

        SpreadSeries[0] = newSpread;
        PriceSeries[0] = orderBook[orderIndex].price;
        OrderSizeSeries[0] = orderBook[orderIndex].size;

        plotBar("Spreads", i, newSpread * 10000, 1, SUM + BARS, RED);
        plot("Price", PriceSeries[0], LINE, BLUE);
        plotBar("Order Sizes", i, OrderSizeSeries[0], 1, SUM + BARS, GREEN);

        updateReturns((random() - 0.5) * 0.005);
    }
}

// AlgoVars for component-specific parameters
#define dist AlgoVar[0]
#define component_weight AlgoVar[1]

// Global variables accessible by all components
var Total_Dist = 0;
var Max_Weight = 0.3;

void updateDist()
{
    /* Calculate distance metric from equity curve */
    var old_dist = dist; // Store component's previous dist value
    vars EquityCurve = series(EquityLong + EquityShort); // Create component equity curve
    vars EquityFilt = series(LowPass(EquityCurve, 100)); // Create component filtered equity curve
    dist = (EquityCurve[0] - EquityFilt[0]) * PIP; // Calculate new dist value

    if (dist <= 0)
    {
        if (old_dist > 0) Total_Dist = Total_Dist - old_dist; 
    }
    else if (dist > 0)
    {
        if (old_dist <= 0) Total_Dist = Total_Dist + dist; 
        if (old_dist > 0) Total_Dist = Total_Dist - old_dist + dist; 
    }

    // Plots
    plot("Component_Eq", EquityCurve, NEW, BLUE);
    plot("Filtered_Eq", EquityFilt, 0, RED);
}

void componentWeight()
{
    if (dist <= 0) 
    {
        Lots = 0.01; // Set the lot size to 0.01
        Margin = 0.025 * Max_Weight * Capital;
        component_weight = 0; 
    }
    else if (dist > 0)
    {
        component_weight = ifelse(Total_Dist > 0, dist / Total_Dist, 0); // Prevent division by zero
        if (component_weight > Max_Weight) component_weight = Max_Weight; // Limit max weight
        Lots = 0.01; // Turn off phantom trading
        Margin = 0.025 * component_weight * Capital; // Set margin according to weight
    }

    // Plots
    plot("dist", dist, NEW | BARS, BLUE);
    plot("Total_Dist", Total_Dist, NEW, RED);
    plot("wgt", component_weight, NEW, BLACK);
}

void tradeRSI()
{
    TimeFrame = 4;
    vars PriceH4 = series(price());
    vars Filter = series(LowPass(PriceH4, 200));

    TimeFrame = 1;
    vars PriceH1 = series(price());
    vars rsi = series(RSI(PriceH1, 14));

    int overbought = optimize(70, 60, 90, 5);
    int oversold = optimize(30, 10, 40, 5);

    Stop = 4 * ATR(100);
    Trail = Stop;
    TakeProfit = optimize(4, 1, 12, 1) * ATR(100);

    if (crossOver(rsi, overbought) && PriceH1[0] < Filter[0] && NumOpenShort == 0)
    {
        enterShort();
    }
    if (crossUnder(rsi, oversold) && PriceH1[0] > Filter[0] && NumOpenLong == 0)
    {
        enterLong();
    }
}

void tradeDigi()
{
    vars Price = series(price());
    vars filter = series(Roof(Price, 50, 100));

    Stop = optimize(3, 1, 6, 0.5) * ATR(100);
    Trail = 0.5 * Stop;
    TrailLock = 10;
    TrailSpeed = 200;

    if (valley(filter)) 
    {
        MaxLong = 1;
        enterLong();
    }
    if (peak(filter))
    {
        MaxShort = 1;
        enterShort();
    }
}

function run()
{
    set(TESTNOW | PLOTNOW | PARAMETERS);
    StartDate = 20231231;
    EndDate = 2025;
    NumWFOCycles = 10;
    BarPeriod = 60;
    LookBack = 150;
    Capital = 1000;

    // Full Asset List
    string My_Assets[28]; 
    My_Assets[0] = "EUR/USD"; My_Assets[1] = "GBP/USD"; My_Assets[2] = "USD/JPY"; 
    My_Assets[3] = "USD/CHF"; My_Assets[4] = "USD/CAD"; My_Assets[5] = "AUD/USD"; 
    My_Assets[6] = "NZD/USD"; My_Assets[7] = "EUR/GBP"; My_Assets[8] = "EUR/JPY"; 
    My_Assets[9] = "EUR/CHF"; My_Assets[10] = "GBP/JPY"; My_Assets[11] = "GBP/CHF";
    My_Assets[12] = "AUD/JPY"; My_Assets[13] = "AUD/CHF"; My_Assets[14] = "NZD/JPY";
    My_Assets[15] = "NZD/CHF"; My_Assets[16] = "CAD/JPY"; My_Assets[17] = "CAD/CHF";
    My_Assets[18] = "CHF/JPY";
    My_Assets[19] = "EUR/AUD"; My_Assets[20] = "EUR/NZD"; My_Assets[21] = "EUR/CAD";
    My_Assets[22] = "GBP/AUD"; My_Assets[23] = "GBP/NZD"; My_Assets[24] = "GBP/CAD";
    My_Assets[25] = "AUD/NZD"; My_Assets[26] = "GBP/CHF"; My_Assets[27] ="NZD/CAD";

    string My_Algos[2]; 
    My_Algos[0] = "rsi"; 
    My_Algos[1] = "digi";

    // Update dist metric and Total_Dist for all components
    int i, j;
    for (i = 0; i < 28; i++) 
    {
        for (j = 0; j < 2; j++) 
        {
            asset(My_Assets[i]); 
            algo(My_Algos[j]);
            updateDist();
        }
    }

    // Update component weights and trade
    while (asset(loop(
        "EUR/USD", "GBP/USD", "USD/JPY", "USD/CHF", "USD/CAD", "AUD/USD", "NZD/USD",
        "EUR/GBP", "EUR/JPY", "EUR/CHF", "GBP/JPY", "GBP/CHF", "AUD/JPY", "AUD/CHF", "GBP/CHF", "NZD/CAD",
        "NZD/JPY", "NZD/CHF", "CAD/JPY", "CAD/CHF", "CHF/JPY",
        "EUR/AUD", "EUR/NZD", "EUR/CAD", "GBP/AUD", "GBP/NZD", "GBP/CAD", "AUD/NZD")))
    {
        while (algo(loop("rsi", "digi")))
        {
            componentWeight();
            if (Algo == "rsi") tradeRSI();
            else if (Algo == "digi") tradeDigi();
        }
    }

    PlotWidth = 600;
    PlotHeight1 = 400;
}

#define dist AlgoVar[0]
#define component_weight AlgoVar[1]  // Each pair-algo has its own weight stored in AlgoVar

var Total_Dist = 0;
var Max_Weight = 0.3;
var MLsignals[8];

#define condition1 MLsignals[0]
#define condition2 MLsignals[1]
#define condition3 MLsignals[2]
#define condition4 MLsignals[3]
#define condition5 MLsignals[4]
#define component_weight_signal MLsignals[5]
#define dynamicThreshold_RSI MLsignals[6]     
#define dynamicThreshold_Digi MLsignals[7]    

var totalWeight = 0;  // Global to store total weights

void updateDist() {
    vars EquityCurve = series(EquityLong + EquityShort);
    vars EquityFilt = series(LowPass(EquityCurve, 100));
    dist = (EquityCurve[0] - EquityFilt[0]) * PIP;

    vars rsiSeries = series(RSI(series(price()), 14));
    vars atrSeries = series(ATR(100));
    condition1 = rsiSeries[0];
    condition2 = atrSeries[0];
    condition3 = EquityCurve[0];
    condition4 = EquityFilt[0];
    condition5 = dist;
    component_weight_signal = component_weight;

    if (dist > 0) Total_Dist += dist;
}

void componentWeight() {
    if (dist <= 0) {
        component_weight = 0;
    } else {
        component_weight = ifelse(Total_Dist > 0, dist / Total_Dist, 0);
        if (component_weight > Max_Weight) component_weight = Max_Weight;

        var perceptronOutput = adviseLong(PERCEPTRON+RETURNS, 2, MLsignals, 8);  
        if (perceptronOutput > 0) {
            Margin = 0.025 * component_weight * Capital * (1 + perceptronOutput / 100);
        } else {
            Margin = 0.025 * component_weight * Capital * (1 + perceptronOutput / 200);
        }
    }
    totalWeight += component_weight;  // Accumulate total weight during the loop
    plot("dist", dist, NEW | BARS, BLUE);
    plot("wgt", component_weight, NEW, BLACK);
}

void tradeRSI() {
    vars PriceH4 = series(price());
    vars Filter = series(LowPass(PriceH4, 200));
    vars PriceH1 = series(price());
    vars rsi = series(RSI(PriceH1, 14));
    var Objective = priceClose(0) - priceClose(5);

    if (adviseLong(DTREE+RETURNS, Objective, MLsignals, 5) > dynamicThreshold_RSI && PriceH1[0] > Filter[0]) 
        enterLong();
    if (adviseShort(DTREE+RETURNS, Objective, MLsignals, 5) > dynamicThreshold_RSI && PriceH1[0] < Filter[0]) 
        enterShort();
}

void tradeDigi() {
    vars Price = series(price());
    vars filter = series(Roof(Price, 50, 100));
    var Objective = priceClose(0) - priceClose(5);

    if (valley(filter) && adviseLong(PATTERN+RETURNS, Objective, MLsignals, 5) > dynamicThreshold_Digi) 
        enterLong();
    if (peak(filter) && adviseShort(PATTERN+RETURNS, Objective, MLsignals, 5) > dynamicThreshold_Digi) 
        enterShort();
}

function run() {
    set(PARAMETERS | RULES | PLOTNOW | TESTNOW);  
    StartDate = 20231231;
    EndDate = 2025;
    NumWFOCycles = 10;
    BarPeriod = 60;
    LookBack = 150;
    Capital = 1000;

    while (asset(loop(
        "EUR/USD", "GBP/USD", "USD/JPY", "USD/CHF", "USD/CAD", "AUD/USD", "NZD/USD",
        "EUR/GBP", "EUR/JPY", "EUR/CHF", "GBP/JPY", "GBP/CHF", "AUD/JPY", "AUD/CHF", "GBP/CHF", "NZD/CAD",
        "NZD/JPY", "NZD/CHF", "CAD/JPY", "CAD/CHF", "CHF/JPY",
        "EUR/AUD", "EUR/NZD", "EUR/CAD", "GBP/AUD", "GBP/NZD", "GBP/CAD", "AUD/NZD")))
    {
         while (algo(loop("rsi","digi"))) {
            updateDist();
            componentWeight();
            if (Algo == "rsi") tradeRSI();
            else if (Algo == "digi") tradeDigi();
        }
    }

    // Normalize weights after all pairs and algos are processed
    while (asset(loop(
        "EUR/USD", "GBP/USD", "USD/JPY", "USD/CHF", "USD/CAD", "AUD/USD", "NZD/USD",
        "EUR/GBP", "EUR/JPY", "EUR/CHF", "GBP/JPY", "GBP/CHF", "AUD/JPY", "AUD/CHF", "GBP/CHF", "NZD/CAD",
        "NZD/JPY", "NZD/CHF", "CAD/JPY", "CAD/CHF", "CHF/JPY",
        "EUR/AUD", "EUR/NZD", "EUR/CAD", "GBP/AUD", "GBP/NZD", "GBP/CAD", "AUD/NZD")))
    {
         while (algo(loop("rsi","digi"))) {
            component_weight = component_weight / totalWeight;  // Normalize
            plot(strf("Weight_%s_%s", Asset, Algo), component_weight, NEW, RED);
        }
    }

    PlotWidth = 600;
    PlotHeight1 = 400;
}

var MLsignals[7];  // Additional signal for threshold learning

#define condition1 MLsignals[0]
#define condition2 MLsignals[1]
#define condition3 MLsignals[2]
#define condition4 MLsignals[3]
#define condition5 MLsignals[4]
#define threshold MLsignals[5]  // Dynamic threshold
#define finalOutput MLsignals[6]  // Final Perceptron output

var MLp[5];  // Individual Perceptron outputs

function run() 
{
    set(PARAMETERS|RULES);  // Enable parameter optimization, training, and rule generation

    StartDate = 20220101;          // Start date for training
    EndDate = 20250101;            // End date for training
    NumWFOCycles = 10;             // Walk-Forward Optimization cycles
    BarPeriod = 5;                // Bar timeframe in minutes
    LookBack = 200;                // Lookback period for indicators
    Capital = 1000;                // Initial capital

    vars MedianPrice = series((priceHigh() + priceLow()) / 2);
    vars AO = series(SMA(MedianPrice, 5) - SMA(MedianPrice, 34));  // Awesome Oscillator
    vars RSI = series(RSI(series(priceClose()), 14));              // RSI Indicator

    while (asset(loop(
        "EUR/USD", "GBP/USD", "USD/JPY", "USD/CHF", "USD/CAD", "AUD/USD", "NZD/USD",
        "EUR/GBP", "EUR/JPY", "EUR/CHF", "GBP/JPY", "GBP/CHF", "AUD/JPY", "AUD/CHF", "GBP/CHF", "NZD/CAD",
        "NZD/JPY", "NZD/CHF", "CAD/JPY", "CAD/CHF", "CHF/JPY", "EUR/AUD", "EUR/NZD",
        "EUR/CAD", "GBP/AUD", "GBP/NZD", "GBP/CAD", "AUD/NZD")))
    {
        // Define machine learning input conditions
        condition1 = ifelse(AO[2] < AO[1] && AO[1] < AO[0], 1, 0);
        condition2 = ifelse(crossOver(AO, 0), 1, 0);
        condition3 = ifelse(valley(AO), 1, 0);
        condition4 = ifelse(priceClose(1) > priceClose(2) && AO[1] < AO[2], 1, 0);
        condition5 = ifelse(AO[0] > 0 && RSI[0] > 50, 1, 0);

        // Train individual Perceptrons for each condition
        MLp[0] = adviseLong(PERCEPTRON+RETURNS, 0, &condition1, 1);
        MLp[1] = adviseLong(PERCEPTRON+RETURNS, 0, &condition2, 1);
        MLp[2] = adviseLong(PERCEPTRON+RETURNS, 0, &condition3, 1);
        MLp[3] = adviseLong(PERCEPTRON+RETURNS, 0, &condition4, 1);
        MLp[4] = adviseLong(PERCEPTRON+RETURNS, 0, &condition5, 1);

        // Train Perceptron to find the optimal threshold dynamically
        threshold = adviseLong(PERCEPTRON+RETURNS, 0, MLp, 5);  

        // Final Perceptron for the trading decision
        finalOutput = adviseLong(PERCEPTRON+RETURNS, 0, MLp, 5);

        // Trading logic with dynamically learned threshold
        if (finalOutput > threshold) {
            enterLong();
        } else if (finalOutput < -threshold) {
            enterShort();
        }
    }

    // Plot indicators and results
    plot("AO", AO, NEW, BLUE);
    plot("RSI", RSI, NEW, RED);
    plot("Threshold", threshold, NEW, GREEN);
    plot("FinalOutput", finalOutput, NEW, BLACK);
}