C / C++ / MFC

double CalculateMSE( std::vector< complex<double> > inputv)
{
    int N = inputv.size();
    int M = 2*N+int(0.1*double(N) + 0.5);

    //%K is the time bandwidth product.

    int K = 100;

    int T = M;


    std::vector<double> m = mylinspace(0, M-1, M);
    std::vector<double> k = mylinspace( -1 * ceil(K/2), K/2, K+1);
    std::vector<double> freq_samples;

    for( int i=0; i < k.size(); i++)
        freq_samples.push_back( k[i] / T );
  
    std::vector<double> sinc_pulse( freq_samples.size() );
    sinc_pulse = mysinc(freq_samples);

    std::vector< std::vector< double > > sinc_pulse2;

    for(int i=0; i < m.size(); i++)
    {
        sinc_pulse2.push_back( sinc_pulse );
    }

    std::vector< matrix< std::complex<double> > > B;
    matrix< std::complex<double> > exp_freq_samples;

    std::complex<double> cplx_j(0,1);

    matrix< double > mx_freq_samples( 1, freq_samples.size() );

    for( int i=0; i < freq_samples.size(); i++)
    {
        mx_freq_samples(0,i) = freq_samples[i];
    }

    matrix< double > mx_m(1, m.size());

    for( int i=0; i < m.size(); i++)
    {
        mx_m(0,i) = m[i];
    }

    matrix< double > mx_sinc_pulse( sinc_pulse2.size(), sinc_pulse2[0].size() );

    for( int i=0; i<mx_sinc_pulse.size1(); i++)
    {
        for( int j=0; j<mx_sinc_pulse.size2(); j++)
        {
            mx_sinc_pulse(i, j) = sinc_pulse2[i][j];
        }
    }

    mx_sinc_pulse = trans(mx_sinc_pulse);

    matrix< double > mx_pp(1, m.size());
    matrix< double > trans_freq_samples( trans(mx_freq_samples) );
    complex< double > cplx_tmp  = -1.0 * cplx_j * 2.0 * PI;

    for( int i=0; i<N; i++)
    {
        matrix< std::complex<double> > Bmat;


        for (unsigned j = 0; j <mx_pp.size1 (); j++)
            for (unsigned jj = 0; jj <mx_pp.size2 (); jj++)
                mx_pp (j, jj) = i + m[jj];



        Bmat = prod(trans_freq_samples, mx_pp);
        Bmat *= cplx_tmp;


        for( int j=0; j < Bmat.size1(); j++)
        {
            for( int jj=0; jj < Bmat.size2(); jj++)
            {
                Bmat(j, jj) = mx_sinc_pulse(j, jj) * exp(Bmat(j, jj));

            }
        }

        B.push_back( Bmat );
    }


    matrix< complex<double> > P(K+1,M);


    for (int i=0; i < inputv.size(); i++)
    {
        P = inputv[i] * B[i] + P;
    }


    matrix< double > Kg(M, 1);

    for( int i=0; i<Kg.size1(); i++)
        Kg(i, 0) = 1;

    matrix< complex<double> > transP;

    matrix< complex<double> > tmpP = prod(herm(P) , P);

    matrix<double> mag_pi_sqrd(tmpP.size2(), 1);

    for( int i=0; i<mag_pi_sqrd.size1(); i++)
    {
        mag_pi_sqrd(i, 0) = real(tmpP(i,i));
    }

    matrix< double > MSE_tmp(M, 1);

    double sumtotal = 0;

    for( int i = 0; i < M; i++)
    {
        matrix< complex<double> > p_i(P.size1(), 1);
        matrix< complex<double> > p_j(P.size1(), M-1);
        for(int j=0; j < P.size1(); j++)
        {
            p_i(j, 0) = P(j, i);
        }

        for(int j=0; j < M-1; j++)
        {
            int ix = j;
            if( j >= i )
                ix++;
            for(int jj=0; jj < P.size1(); jj++)
                p_j(jj, j) = P(jj, ix);
        }
        matrix< complex<double> > hp_i = herm(p_i);
        matrix< complex<double> > prodhpi_pj = prod( hp_i, p_j );

        matrix< complex<double> > hermprodhpi_pj = herm(prodhpi_pj);



        matrix< double > mag_rhoij = real( prod( prodhpi_pj , hermprodhpi_pj ) );
        MSE_tmp(i, 0) = (Kg(i,0) * mag_rhoij(0,0)) / (mag_pi_sqrd(i,0)*mag_pi_sqrd(i,0));

        sumtotal += MSE_tmp(i, 0);
    }

    sumtotal = sumtotal/double(M);

    return sumtotal;
}

int WINAPI WinMain(HINSTANCE currentInst, 
				   HINSTANCE prevInst, 
				   LPSTR args, 
				   int showVar)
{
	////////////////////////////////
	//Initializing WinSock library//
	////////////////////////////////

	WSADATA wsaData;
    if(WSAStartup(0x0202, &wsaData))
    {
		MessageBox(NULL,"Call to WSAStartup() failed at line #", "Error!", MB_ICONEXCLAMATION | MB_OK);
        WSACleanup();
        return wsaFail;
    }
    else
    {
        if(wsaData.wVersion != 0x0202)
        {
			MessageBox(NULL,"Wrong socket version! at line #", "Error!", MB_ICONEXCLAMATION | MB_OK);
            WSACleanup();
            return wsaFail;
        }
    }

	////////////////////////////
	//Declaration of variables//
	////////////////////////////

	WNDCLASSEX windowClass;
	HWND handleToWindow;
	SOCKET serverSocket;
	sockaddr_in serverSockAddrIn;
	MSG Msg;

	///////////////////////////////////////////////////////////////
	//Registering the Window Class and creating an actuall window//
	///////////////////////////////////////////////////////////////

	windowClass.cbSize = sizeof(WNDCLASSEX);
	windowClass.style = CS_HREDRAW | CS_NOCLOSE | CS_VREDRAW;
	windowClass.lpfnWndProc = WndProc; //Window Procedure
	windowClass.lpszClassName = class_name;
	windowClass.cbClsExtra = 0;
	windowClass.cbWndExtra = 0;
	windowClass.hInstance = currentInst;
	windowClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
	windowClass.hCursor = LoadCursor(NULL, IDC_ARROW);
	windowClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 6);
	windowClass.lpszMenuName = NULL;
	windowClass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

	if(!RegisterClassEx(&windowClass))
	{
		MessageBox(NULL, "Window Registration Failed at EntryPoint.cpp line #", "Error!", MB_ICONEXCLAMATION | MB_OK);
		return windowRegistrationFail;
	}

	//Creating the window
	handleToWindow = CreateWindowEx(WS_EX_CLIENTEDGE | WS_EX_OVERLAPPEDWINDOW | WS_EX_TOPMOST, 
									class_name, 
									"Server Console",
									WS_OVERLAPPED| WS_VISIBLE, 
									400, 500, 800, 500, NULL, NULL, currentInst, NULL);
	
	if(handleToWindow == NULL)
	{
		MessageBox(NULL, "Window Creation Failed at line #", "Error!", MB_ICONEXCLAMATION | MB_OK);
		return windowCreationFail;
	}
	UpdateWindow(handleToWindow);
	////////////////////////
	//Seting up the scoket//
	////////////////////////

	//sockaddr_in struct
	memset(&serverSockAddrIn, 0, sizeof(serverSockAddrIn));
    serverSockAddrIn.sin_family = AF_INET;
    serverSockAddrIn.sin_port = htons(2567);
    serverSockAddrIn.sin_addr.s_addr = htonl(INADDR_ANY);
	
	//socket
	serverSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

	if(serverSocket == INVALID_SOCKET)
	{
		MessageBox(NULL, "Socket Creation Failed at EntryPoint.cpp line#", "Error!", MB_ICONEXCLAMATION | MB_OK);
		WSACleanup();
		return socketFail;
	}
	
	//Making it async//

	WSAAsyncSelect(serverSocket, handleToWindow, NetworkNotification, FD_ACCEPT | FD_READ | FD_WRITE | FD_CLOSE);
	//Binding it//
	if(bind(serverSocket, (sockaddr*)&serverSockAddrIn, sizeof(serverSockAddrIn)) == SOCKET_ERROR)
		return 0;
	
	while(GetMessage(&Msg, NULL, 0, 0) > 0)
	{
		TranslateMessage(&Msg);
		DispatchMessage(&Msg);
	}
	return 0;
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch(msg)
	{
	case NetworkNotification:
		{
			switch(WSAGETSELECTEVENT(lParam))
			{
			case FD_ACCEPT:
				{
					MessageBox(hwnd, "Success!", "Test", NULL);
					break;
				}
			case FD_READ:
				break;
			case FD_WRITE:
				break;
			case FD_CLOSE:
				break;
			}
		}
	case WM_COMMAND:
		{
                  //bla bla bla
		}
	case WM_CREATE:
		{
                  //creating controlls here
		}
	default: 
		return DefWindowProc(hwnd, msg, wParam, lParam);
	}
}

#define NetworkEvent (WM_USER + 5)