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);
}

#define NUM_PAIRS 28    // Number of currency pairs
#define NUM_TIMEFRAMES 2  // Number of timeframes to process

// Arrays to store the currency pairs and timeframes
string Pairs[NUM_PAIRS];
string Timeframes[NUM_TIMEFRAMES];

/*
 * Format string for parsing CSV data.
 * The '+' indicates the CSV file has a header line to skip.
 * %Y - Year (4 digits)
 * %m - Month (2 digits)
 * %d - Day (2 digits)
 * %H - Hour (2 digits, 24-hour format)
 * %M - Minute (2 digits)
 * %f3 - Open price (floating point with 3 decimals)
 * %f1 - High price (floating point with 1 decimal)
 * %f2 - Low price (floating point with 2 decimals)
 * %f4 - Close price (floating point with 4 decimals)
 * %f6 - Volume (floating point with 6 decimals)
 *
 * This must match the structure of your CSV files.
 */
string Format = "+%Y.%m.%d,%H:%M,%f3,%f1,%f2,%f4,%f6";

// Function to initialize currency pairs and timeframes
// Modify this to include/remove pairs or adjust timeframes as needed.
function initializePairsAndTimeframes() {
	// Currency pairs
	Pairs[0] = "EURUSD";
	Pairs[1] = "GBPUSD";
	Pairs[2] = "USDJPY";
	Pairs[3] = "USDCHF";
	Pairs[4] = "USDCAD";
	Pairs[5] = "AUDUSD";
	Pairs[6] = "NZDUSD";
	Pairs[7] = "EURGBP";
	Pairs[8] = "EURJPY";
	Pairs[9] = "EURCHF";
	Pairs[10] = "GBPJPY";
	Pairs[11] = "GBPCHF";
	Pairs[12] = "AUDJPY";
	Pairs[13] = "AUDCHF";
	Pairs[14] = "NZDCAD";
	Pairs[15] = "NZDJPY";
	Pairs[16] = "NZDCHF";
	Pairs[17] = "CADJPY";
	Pairs[18] = "CADCHF";
	Pairs[19] = "CHFJPY";
	Pairs[20] = "EURAUD";
	Pairs[21] = "EURNZD";
	Pairs[22] = "EURCAD";
	Pairs[23] = "GBPAUD";
	Pairs[24] = "GBPNZD";
	Pairs[25] = "GBPCAD";
	Pairs[26] = "AUDNZD";
	Pairs[27] = 0;  // End marker

	// Timeframes in minutes (e.g., 60 = 1 hour, 240 = 4 hours)
	Timeframes[0] = "60";
	Timeframes[1] = "240";
}

/*
 * Function to convert a CSV file to a .t6 file.
 * This version splits the CSV data by year and saves each year as a separate .t6 file.
 *
 * Parameters:
 * InName - The path and name of the input CSV file.
 * Pair - The currency pair string to include in the output filename.
 *
 * Outputs:
 * Files are saved as {CurrencyPair}_{Year}.t6, e.g., EURAUD_2025.t6
 */
function ConvertCSV(string InName, string Pair) {
	int Records = dataParse(1, Format, InName);  // Parse the CSV with the defined format
	printf("\n%d lines read from %s", Records, InName);  // Print the number of records read

	if(Records) {
		int i, Start = 0, Year, LastYear = 0;
		for(i = 0; i < Records; i++) {
			Year = ymd(dataVar(1, i, 0)) / 10000;  // Extract the year from the date
			if(!LastYear) LastYear = Year;  // Set the first encountered year

			// Handle the last record
			if(i == Records - 1) { 
				LastYear = Year; 
				Year = 0; 
				i++;
			}

			// When the year changes, save the data segment to a new .t6 file
			if(Year != LastYear) { 
				// Construct the output file name as {Pair}_{Year}.t6
				string OutName = strf("C:\\Users\\**username**\\Zorro\\History\\%s_%4i.t6", Pair, LastYear);
				printf("\nSaving file: %s", OutName);        
				dataSave(1, OutName, Start, i - Start);  // Save the data segment to .t6
				Start = i;  // Update the start index for the next segment
				LastYear = Year;  // Update the current year
			}
		}
	}
}

/*
 * Main function:
 * Loops through all specified currency pairs and timeframes,
 * checks for CSV files in the specified directory, and converts them to .t6 files.
 */
function main() {
	initializePairsAndTimeframes();  // Initialize pairs and timeframes
	int p, t;  // Loop counters for pairs and timeframes

	// Loop through each currency pair
	for(p = 0; Pairs[p]; p++) {
		// Loop through each timeframe
		for(t = 0; t < NUM_TIMEFRAMES; t++) {
			// Construct the CSV file path dynamically
			// Path: C:\Users\**username**\Zorro\History\{CurrencyPair}{Timeframe}.csv
			string FileName = strf("C:\\Users\\**user//name**\\Zorro\\History\\%s%s.csv", Pairs[p], Timeframes[t]);
			printf("\nChecking file: %s", FileName);  // Log the file being checked

			if(file_length(FileName)) {  // Check if the file exists
				printf("\nConverting %s...", FileName);  // Log the conversion process
				ConvertCSV(FileName, Pairs[p]);  // Call the conversion function with the pair name
			} else {
				printf("\nFile not found: %s", FileName);  // Log missing files
			}
		}
	}
	quit("Conversion done!");  // Exit the script when all files are processed
}

#define NUM_NODES 10
#define SELECTED_NODES 5  // Select only 5 nodes for DI+/DI-

var A[NUM_NODES][NUM_NODES];  // Adjacency matrix
var Signals[20];  // Max 20 elements for Perceptron

int selectedNodes[SELECTED_NODES] = {0, 2, 4, 6, 8};  // Selected nodes for DI+/DI-

void initialize_graph() {
    int i, j;

    // Manually define adjacency matrix
    A[0][1] = 1; A[0][4] = 1;
    A[1][0] = 1; A[1][2] = 1; A[1][5] = 1;
    A[2][1] = 1; A[2][3] = 1; A[2][6] = 1;
    A[3][2] = 1; A[3][4] = 1; A[3][7] = 1;
    A[4][0] = 1; A[4][3] = 1; A[4][8] = 1;
    A[5][1] = 1; A[5][6] = 1; A[5][9] = 1;
    A[6][2] = 1; A[6][5] = 1; A[6][7] = 1;
    A[7][3] = 1; A[7][6] = 1; A[7][8] = 1;
    A[8][4] = 1; A[8][7] = 1; A[8][9] = 1;
    A[9][5] = 1; A[9][8] = 1;
}

var aggregate_features(int node, vars FeatureSeries) {
    var sum = 0;
    int count = 0;
    int j;

    for (j = 0; j < NUM_NODES; j++) {
        if (A[node][j] == 1) {
            sum += FeatureSeries[j];
            count++;
        }
    }
    return ifelse(count > 0, sum / count, 0);
}

void run() {
    set(RULES | TESTNOW);

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

    vars ADX_Feature = series(ADX(14));
    vars DIPlus_Feature = series(PlusDI(14));
    vars DIMinus_Feature = series(MinusDI(14));

    vars Updated_ADX = series(0, NUM_NODES);
    vars Updated_DIPlus = series(0, NUM_NODES);
    vars Updated_DIMinus = series(0, NUM_NODES);

    int layer, i;
    for (layer = 0; layer < 2; layer++) {
        for (i = 0; i < NUM_NODES; i++) {
            Updated_ADX[i] = aggregate_features(i, ADX_Feature);
            Updated_DIPlus[i] = aggregate_features(i, DIPlus_Feature);
            Updated_DIMinus[i] = aggregate_features(i, DIMinus_Feature);
        }
        for (i = 0; i < NUM_NODES; i++) {
            ADX_Feature[i] = Updated_ADX[i];
            DIPlus_Feature[i] = Updated_DIPlus[i];
            DIMinus_Feature[i] = Updated_DIMinus[i];
        }
    }

    // Store ADX values from all 10 nodes
    for (i = 0; i < NUM_NODES; i++) {
        Signals[i] = ADX_Feature[i];
    }

    // Store DI+ and DI- from only SELECTED_NODES
    for (i = 0; i < SELECTED_NODES; i++) {
        Signals[NUM_NODES + i] = DIPlus_Feature[selectedNodes[i]];
        Signals[NUM_NODES + SELECTED_NODES + i] = DIMinus_Feature[selectedNodes[i]];
    }

    // Train Perceptron using only 20 elements
    if (adviseLong(PERCEPTRON, 0, Signals, 20) > 0)
        enterLong();
    if (adviseShort(PERCEPTRON, 0, Signals, 20) > 0)
        enterShort();
}

#include <default.c>

#define LOOKBACK 5  
#define FEATURES 5  
#define X_MAX 100   

// Define Perceptron weights and biases manually
var PerceptronWeights[3] = {0.5, -0.3, 0.2};  
var PerceptronBias = 0.1;  

// Sigmoid activation function
var sigmoid(var x) {
    return 1.0 / (1.0 + exp(-x));
}

// Custom Perceptron function to replace `adviseLong()`
var perceptronPredict(vars Features, int size) {
    var weightedSum = PerceptronBias;
    int i;
    for (i = 0; i < size; i++) {  
        weightedSum += PerceptronWeights[i] * Features[i];
    }
    return sigmoid(weightedSum) * 100.0;  
}

// Compute dynamic liquidity probability
var computePiT() {
    vars atr_series = series(ATR(20), LOOKBACK);
    vars spread_series = series(Spread, LOOKBACK);
    vars price_series = series(priceClose(), LOOKBACK);
    vars stddev_series = series(0, LOOKBACK);

    stddev_series[0] = StdDev(price_series, 20);

    vars Features = series(0, 15);
    int i;
    for (i = 0; i < LOOKBACK; i++) { 
        Features[i] = atr_series[i] / priceClose();  
        Features[i + LOOKBACK] = stddev_series[i] / priceClose(); 
        Features[i + 2 * LOOKBACK] = spread_series[i] / 0.001;
    }

    return perceptronPredict(Features, 15) / 100.0;  
}

// Compute dynamic threshold for last 5 candles
void computeThresholdSeries(vars threshold_series) {
    vars atr_series = series(ATR(20), LOOKBACK);
    vars pi_series = series(computePiT(), LOOKBACK);

    int i;
    for (i = 0; i < LOOKBACK; i++) { 
        threshold_series[i] = 40 + (atr_series[i] * 100) - (pi_series[i] * 10);
        threshold_series[i] = clamp(threshold_series[i], 30, 70);
    }
}

function run() {
    set(PARAMETERS);  
    
	 StartDate = 20231231;
    EndDate = 2025;
    NumWFOCycles = 10;
    BarPeriod = 1;
    LookBack = 150;
    Capital = 1000;
	 
    vars X = series(priceClose());
    vars X_diff = series(priceClose(1) - priceClose());
    var pi_t = computePiT(); 

    vars threshold_series = series(0, LOOKBACK);
    computeThresholdSeries(threshold_series);

    vars DTREE_Features = series(0, FEATURES);
    int i;
    for (i = 0; i < LOOKBACK; i++) { 
        DTREE_Features[i] = threshold_series[i];
    }

    var trade_threshold = perceptronPredict(DTREE_Features, FEATURES);
    trade_threshold = clamp(trade_threshold, 30, 70);

    vars TradeFeatures = series(0, 3);
    TradeFeatures[0] = X[0];
    TradeFeatures[1] = X_diff[0];
    TradeFeatures[2] = pi_t;

    var long_prob = perceptronPredict(TradeFeatures, 3);
    var short_prob = perceptronPredict(TradeFeatures, 3) - 10;  

    int trade_flag = ifelse(long_prob > trade_threshold || short_prob > trade_threshold, 1, 0);
    var trade_size = ifelse(is(PARAMETERS), perceptronPredict(TradeFeatures, 3) / 100.0 * X_MAX, 10);
    string order_type = ifelse(long_prob > trade_threshold, "Market", "Limit");

    if (trade_flag) {
        if (long_prob > short_prob) {
            if (strstr(order_type, "Market")) {
                enterLong(trade_size);
            } else {
                enterLong(trade_size);
                Entry = priceClose() * 1.001;  
            }
        } else {
            if (strstr(order_type, "Market")) {
                enterShort(trade_size);
            } else {
                enterShort(trade_size);
                Entry = priceClose() * 0.999;  
            }
        }
    }

    printf("\nTrade Decision: %s", ifelse(trade_flag, "Execute", "Hold"));
    printf("\nTrade Size: %.2f units", trade_size);
    printf("\nOrder Type: %s", order_type);
    printf("\nPredicted Liquidity Probability (pi_t): %.2f", pi_t);
    printf("\nDynamic Threshold (DTREE Replaced): %.2f", trade_threshold);
}

Bar 1023: Threshold = 0.00001
Bar 1024: FinalOutput = 0.00002 → Triggers Long Entry
Bar 1025: FinalOutput = -0.00003 → Triggers Short Entry

#ifndef MARKOVCHAINLIB_H
#define MARKOVCHAINLIB_H

#include <default.c> //  Ensures string functions are available

#define MAX_STATES 100

// Declare the Markov Chain transition matrix
int markovChain[MAX_STATES][MAX_STATES];

// Initialize the Markov Chain matrix with zeros manually
void initMarkovChain() {
    int i, j;
    for(i = 0; i < MAX_STATES; i++) {
        for(j = 0; j < MAX_STATES; j++) {
            markovChain[i][j] = 0;
        }
    }
}

//  Fixed: Use `strcmp()` or `==` for comparison
int findIndex(string* array, int size, string target) {
    int i;
    for (i = 0; i < size; i++) {
        if (array[i] == target) {  //  Simplified comparison
            return i; // Found, return index
        }
    }
    return -1; // Not found
}

// Function to get the index of an asset
int assetIdx(string asset) {
    static string assets[28];

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

    return findIndex(assets, 28, asset);
}

// Function to get the index of an algorithm
int algoIdx(string algo) {
    static string algos[2]; 
    algos[0] = "rsi";
    algos[1] = "digi";

    return findIndex(algos, 2, algo);
}

// Function to compute the state ID based on asset and algorithm
int getStateID(string asset, string algo) {
    int aIdx = assetIdx(asset);
    int algoIdxValue = algoIdx(algo);
    
    if (aIdx == -1 || algoIdxValue == -1) {
        return -1; // Return invalid state if either index is not found
    }
    
    return aIdx * 2 + algoIdxValue; // Multiply by 2 because we have 2 algorithms
}

// Update the Markov Chain transition count
void updateMarkovChain(int prev, int next) {
    if (prev >= 0 && prev < MAX_STATES && next >= 0 && next < MAX_STATES) {
        markovChain[prev][next]++;
    }
}

#endif // MARKOVCHAINLIB_H

#include "MarkovChainLib.h" // Include the Markov Chain logic

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

#define dist AlgoVar[0]
#define component_weight AlgoVar[1]

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));
    MLsignals[0] = rsiSeries[0];
    MLsignals[1] = atrSeries[0];
    MLsignals[2] = EquityCurve[0];
    MLsignals[3] = EquityFilt[0];
    MLsignals[4] = dist;
    MLsignals[5] = 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);
        Margin = 0.025 * component_weight * Capital * (1 + ifelse(perceptronOutput > 0, perceptronOutput / 100, perceptronOutput / 200));
    }
    totalWeight += component_weight;
}

//  Define the `tradeRSI()` function
void tradeRSI() {
    vars RSIs = series(RSI(series(price()), 14));

    if (crossOver(RSIs, 70)) {
        enterShort(); // RSI crosses above 70 ? Sell
    }
    else if (crossUnder(RSIs, 30)) {
        enterLong(); // RSI crosses below 30 ? Buy
    }
}

//  Define the `tradeDigi()` function
void tradeDigi() {
    if (price() > SMA(series(price()), 50)) {
        enterLong();  // If price is above SMA(50), enter a long trade
    } else {
        enterShort(); // Otherwise, enter a short trade
    }
}

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

    initMarkovChain();

    int prevState = -1;

    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();

            int currentStateID = getStateID(Asset, Algo);
            if (prevState != -1) updateMarkovChain(prevState, currentStateID);
            prevState = currentStateID;

            // FIXED: Replace `strxcmp()` with `strcmp()` or `==`
            if (Algo == "rsi") tradeRSI();
            else if (Algo == "digi") tradeDigi();
        }
    }

    // Normalize weights after all pairs and algos are processed
    while (algo(loop("rsi","digi"))) {
        component_weight /= totalWeight;
        plot(strf("Weight_%s_%s", Asset, Algo), component_weight, NEW, RED);
    }

    PlotWidth = 600;
    PlotHeight1 = 400;
}

// === Helper Functions (must be above run) ===

var vwapPrice(int offset, int type)
{
	switch (type) {
		case 0: return priceClose(offset);
		case 1: return priceOpen(offset);
		case 2: return priceHigh(offset);
		case 3: return priceLow(offset);
		case 4: return (priceHigh(offset) + priceLow(offset)) / 2;
		case 5: return (priceHigh(offset) + priceLow(offset) + priceClose(offset)) / 3;
		case 6: return (priceHigh(offset) + priceLow(offset) + 2*priceClose(offset)) / 4;
		default: return priceClose(offset);
	}
}

var stdDevVWAP(int N, int offset, int type, var vwapValue)
{
	var s = 0;
	int i;
	for (i = 0; i < N; i++) {
		var p = vwapPrice(offset + i, type);
		s += pow(p - vwapValue, 2);
	}
	return sqrt(s / N);
}

var VWAP_Z(int N, int offset, int type)
{
	var sumPV = 0, sumVol = 0;
	int i;
	for (i = 0; i < N; i++) {
		var price = vwapPrice(offset + i, type);
		var volume = marketVol(offset + i);
		sumPV += price * volume;
		sumVol += volume;
	}
	return ifelse(sumVol > 0, sumPV / sumVol, 0);
}

// === Main Strategy/Indicator Function ===

function run()
{
	set(PLOTNOW);

	int N = 20;
	int type = 0; // 0 = PRICE_CLOSE
	var dev1 = 1, dev2 = 2, dev3 = 2.5;

	var vwapVal = VWAP_Z(N, 0, type);
	var stdDev = stdDevVWAP(N, 0, type, vwapVal);

	plot("VWAP", vwapVal, LINE, BLACK);

	plot("UpperBand1", vwapVal + dev1 * stdDev, LINE, RED);
	plot("LowerBand1", vwapVal - dev1 * stdDev, LINE, RED);

	plot("UpperBand2", vwapVal + dev2 * stdDev, LINE, GREEN);
	plot("LowerBand2", vwapVal - dev2 * stdDev, LINE, GREEN);

	plot("UpperBand3", vwapVal + dev3 * stdDev, LINE, BLUE);
	plot("LowerBand3", vwapVal - dev3 * stdDev, LINE, BLUE);
}

function var ComplexIndicator()
{
    vars Price = series(price());
    vars FastMA = series(SMA(Price, 10));
    vars SlowMA = series(SMA(Price, 30));
    
    // Custom weighted oscillator
    var diff = (FastMA[0] - SlowMA[0]);
    var norm = (abs(FastMA[0]) + abs(SlowMA[0]))/2;
    var rawOsc = diff / (norm + 0.0001); // avoid div by 0
    
    // Non-linear scaling and signal enhancement
    var weight = pow(rawOsc, 3) * sin(4 * rawOsc); // enhanced non-linearity
    var smooth = EMA(series(weight), 14); // smooth the output

    return smooth[0];
}