// Old MMI version
var MMI_old(vars Data,int TimePeriod)
{
    TimePeriod = Min(TimePeriod,1000);
    checkLookBack(TimePeriod);
    TimePeriod = Min(TimePeriod,g->nBar-1);

    if(TimePeriod < 2)
        return 75;

    var m = Median(Data,TimePeriod);

    int i, nh = 0, nl = 0;

    for(i = 1; i < TimePeriod; i++)
    {
        if(Data[i] > m && Data[i] > Data[i-1])
            nl++;
        else if(Data[i] < m && Data[i] < Data[i-1])
            nh++;
    }

    return 100.*(nl+nh)/(TimePeriod-1);
}


// New MMI version
var MMI_new(vars Data,int TimePeriod)
{
    TimePeriod = Min(TimePeriod,1000);
    checkLookBack(TimePeriod);
    TimePeriod = Min(TimePeriod,g->nBar-2);

    if(TimePeriod < 2)
        return 75;

    var m = Median(Data,TimePeriod|1);

    int i, nh = 0, nl = 0;

    for(i = 1; i < TimePeriod; i++)
    {
        if(Data[i] > m && Data[i] > Data[i-1])
            nl++;
        else if(Data[i] < m && Data[i] < Data[i-1])
            nh++;
    }

    return 100.*(nl+nh)/(TimePeriod-1);
}


function run()
{
    BarPeriod = 60;
    LookBack = 300;

    asset("EUR/USD");

    vars Price = series(priceClose());

    int Period = 100;

    var OldMMI = MMI_old(Price,Period);
    var NewMMI = MMI_new(Price,Period);

    plot("Old MMI",OldMMI,NEW,BLUE);
    plot("New MMI",NewMMI,0,RED);
    plot("Difference",NewMMI-OldMMI,NEW,GREEN);

    static int ValueDiffs = 0;
    static int SignalDiffs = 0;

    if(!is(LOOKBACK))
    {
        if(abs(NewMMI-OldMMI) > 0.0001)
            ValueDiffs++;

        int OldSignal = OldMMI > 75;
        int NewSignal = NewMMI > 75;

        if(OldSignal != NewSignal)
        {
            SignalDiffs++;
            printf("\nBar %i: Old MMI %.2f, New MMI %.2f",Bar,OldMMI,NewMMI);
        }
    }

    if(is(EXITRUN))
    {
        printf("\nMMI value differences: %i",ValueDiffs);
        printf("\nMMI signal differences: %i",SignalDiffs);
    }
}

if(MMI(Price,Period) > 75)
if(MMI(Price,Period) < 50)
if(crossOver(MMI_Series,Threshold))

// Zorro's Market Meanness Index
var MMI(var* Data,int TimePeriod)
{
// clip time period to history length
	TimePeriod = Min(TimePeriod,1000);
	checkLookBack(TimePeriod);
	TimePeriod = Min((uint)TimePeriod,g->nBar-1);
	if(TimePeriod < 2) return 75;
// calculate MMI statistics
	var m = Median(Data,TimePeriod); 
	int i, nh=0, nl=0;
	for(i=1; i<TimePeriod; i++) {
		if(Data[i] > m && Data[i] > Data[i-1])
			nl++;
		else if(Data[i] < m && Data[i] < Data[i-1])
			nh++;
	}
	return 100.*(nl+nh)/(TimePeriod-1);
}

// Zorro's Market Meanness Index
var MMI(var* Data,int TimePeriod)
{
	checkLookBack(TimePeriod);
// clip time period to history length
	TimePeriod = Min((uint)TimePeriod,g->nBar-2);
	if(TimePeriod < 2) return 75;
// calculate MMI statistics
	var m = Median(Data,TimePeriod|1); 
	int i, nh=0, nl=0;
	for(i=1; i<TimePeriod; i++) {
		if(Data[i] > m && Data[i] > Data[i-1])
			nl++;
		else if(Data[i] < m && Data[i] < Data[i-1])
			nh++;
	}
	return 100.*(nl+nh)/(TimePeriod-1);
}

// Arima01.c
// EUR/USD SMA + ARIMA forecast
// Requires AutoAri32.dll in the same folder as this script.

// Minimal copy of AUTO_ARIMA_RESULT from aa_arima_types.h.
// Field names can be local; order and types must match the DLL.
typedef struct
{
    int p;
    int d;
    int q;
    int converged;

    var sse;
    var aicc;
    var forecast;

    var* ar;
    var* ma;

    int arCap;
    int maCap;

} AUTO_ARIMA_RESULT;

#define PRAGMA_API init_auto_arima_result;AutoAri32!init_auto_arima_result
#define PRAGMA_API free_auto_arima_result;AutoAri32!free_auto_arima_result
#define PRAGMA_API auto_arima_forecast;AutoAri32!auto_arima_forecast
#define PRAGMA_API aa_validate_price_series;AutoAri32!aa_validate_price_series

void init_auto_arima_result(AUTO_ARIMA_RESULT* R);
void free_auto_arima_result(AUTO_ARIMA_RESULT* R);
int auto_arima_forecast(vars Close,int N,var TickSize,int MaxP,int MaxQ,AUTO_ARIMA_RESULT* Result);
int aa_validate_price_series(vars Close,int N);

#define ARIMA_WINDOW 120

function run()
{
    set(PLOTNOW,LOGFILE);

    BarPeriod = 1440;
    LookBack = ARIMA_WINDOW + 50;
    MaxBars = 800;

    PlotWidth = 1200;
    PlotHeight1 = 600;
    PlotBars = 300;

    asset("EUR/USD");

    vars Price = series(priceClose());

    var SMA20 = SMA(Price,20);

    if(is(LOOKBACK))
        return;

    var Forecast = Price[1]; // safe fallback
    int Status = 0;

    AUTO_ARIMA_RESULT R;
    init_auto_arima_result(&R);

    // The library documents price-series validation before model use.
    // It checks positive prices, invalid values, and enough samples.
    if(aa_validate_price_series(Price+1,ARIMA_WINDOW))
    {
        Status = auto_arima_forecast(Price+1,ARIMA_WINDOW,PIP,3,3,&R);

        if(Status and R.converged and !invalid(R.forecast))
        {
            if(R.forecast > 0.5 and R.forecast < 2.0)
                Forecast = R.forecast;
        }
    }

    var ErrorPips = (Price[0] - Forecast) / PIP;

    plot("Close",Price[0],MAIN|LINE,BLUE);
    plot("SMA20",SMA20,MAIN|LINE,RED);
    plot("ARIMA",Forecast,MAIN|LINE,GREEN);
    plot("ErrPips",ErrorPips,NEW|LINE,BLACK);

    printf(
        "\nBar %i Close %.5f SMA20 %.5f ARIMA %.5f Err %.2f pips Status %i p=%i d=%i q=%i AICc %.4f",
        Bar,
        Price[0],
        SMA20,
        Forecast,
        ErrorPips,
        Status,
        R.p,
        R.d,
        R.q,
        R.aicc
    );

    free_auto_arima_result(&R);
}