#include <iostream>
#include <vector>
#include <stdlib.h>
#include <time.h>

// Вычисление дисперсии
float Disp(int* data, size_t size)
{
	typedef std::vector<int> TIntCollection;
	TIntCollection voidLengths;

	bool inVoidPrev = (data[0] == 0);
	int voidLength = inVoidPrev ? 1 : 0;

	// Находим длины пустот
	for (int i=1; i<size; i++)
	{
		bool inVoid = (data[i] == 0);

	        if (inVoid && !inVoidPrev)
        	{
	            inVoidPrev = true;
		    voidLength = 1;
        	}
	        else
        	if (!inVoid && inVoidPrev)
	        {
		    voidLengths.push_back(voidLength);
        	    inVoidPrev = false;
	        }
        	else
	        if (inVoid && inVoidPrev)
        	{
	            voidLength++;
        	}
	}

	if (inVoidPrev) voidLengths.push_back(voidLength);

	// Определяем мат. ожидание 
	size_t N = voidLengths.size();
	float mean = 0.f;
	for (TIntCollection::iterator it = voidLengths.begin(); it != voidLengths.end(); ++it)
	{
	    mean += *it;
	}
	mean /= N;

	// Теперь дисперсия
	float disp = 0.f;
	for (TIntCollection::iterator it = voidLengths.begin(); it != voidLengths.end(); ++it)
	{
	    disp += (float(*it) - mean) * (float(*it) - mean);
	}
	disp /= N;

	return disp;
}


int main()
{
	const int SZ = 10000;
	int* data1 = new int[SZ];
	int* data2 = new int[SZ];
	int* data3 = new int[SZ];

	memset(data1, 0, sizeof(int) * SZ);
	memset(data2, 0, sizeof(int) * SZ);
	memset(data3, 0, sizeof(int) * SZ);

	// Случай 1: равномерное заполнение
	for (int i=0; i<SZ; i+= 50)
	{
	    data1[i] = 1;
	}
	std::cout << Disp(data1, SZ) << std::endl;   // 0

	// Случай 2: случайное заполнение 200 значениями
	srand(time(NULL));

	for (int n=0; n < 2000; n++)
	{
	    data2[rand() % SZ] = 1;
	}
	std::cout << Disp(data2, SZ) << std::endl;   // ~25


	// Случай 3: случайное заполнение 500значениями

	for (int n=0; n < 5000; n++)
	{
	    data3[rand() % SZ] = 1;
	}
	std::cout << Disp(data3, SZ) << std::endl;   // ~5


	delete[] data1;
	delete[] data2;
	delete[] data3;

	return 0;
}

	int data1[] = {0, 0, 1, 0, 0, 1, 0, 1, 0};
	int data2[] = {0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0};
	
	std::cout << Disp(data1, sizeof(data1) / sizeof(data1[0])) << std::endl;   // 0.25
	std::cout << Disp(data2, sizeof(data2) / sizeof(data2[0])) << std::endl;   // 1

int[] x1 = {0, 0, 1, 0};
int[] x2 = {0, 0, 0, 0, 1, 0, 0};

bool isTheSameSignalStruct = Math.Abs( f(x1) == f(x2) );

...
double f (int[] data)
{
   вот тут должно быть что-то хитрое
}

bool isTheSameSignalStruct = Math.Abs( f(x1) - f(x2) ) < epsilon;