ms_p1.cpp

It s an entire application that uses knowdledge of probabilistic and statistical math to generate an

		(iarg!=12)
	       )
	    {
		sprintf(str,"Requested value is %d",iarg2);
	    }
	    else
	    {
		sprintf(str,"Requested value is %.3f",farg);
	    }
	    csLineTextColor[_PushConsoleText(str)]=_CS_REPLY_COLOR;
	}
	break;

	case 3:
	if (!strcmp(strupr(csCmdTokens[0]),"SET"))
	{
	    flag=1;

	    sscanf(csCmdTokens[1],"%d",&iarg);

	    if (
		(iarg!=11)&&
		(iarg!=12)
	       )
	    {
		sscanf(csCmdTokens[2],"%d",&iarg2);
	    }
	    else
	    {
		sscanf(csCmdTokens[2],"%f",&farg);
	    }

	    switch (iarg)
	    {
		case 0:
		SelView=iarg2&0x3;
		break;

		case 1:
		if (!iarg2)
		{
		    Views[SelView].seed=rand();
		}
		else
		{
		    Views[SelView].seed=iarg2;
		}
		break;

		case 2:
		Views[SelView].N=iarg2;
		break;

		case 3:
		Views[SelView].n=iarg2;
		break;

		case 4:
		SwitchFScreen=iarg2&0x1;
		_FullScreenView(SelView);
		break;

		case 5:
		Views[SelView].SwitchBubble=iarg2&0x1;
		break;

		case 6:
		Views[SelView].SwitchBar=iarg2&0x1;
		break;

		case 7:
		Views[SelView].color=iarg2;
		break;

		case 8:
		Views[SelView].backcolor=iarg2;
		break;

		case 9:
		Views[SelView].SwitchRuler=iarg2&0x1;
		break;

		case 10:
		Views[SelView].SwitchGrid=iarg2&0x1;
		break;

		case 11:
		Views[SelView].RulerResX=farg;
		break;

		case 12:
		Views[SelView].RulerResY=farg;
		break;

		case 13:
		Views[SelView].rulercolor=iarg2;
		break;

		case 14:
		Views[SelView].SwitchInterp=iarg2&0x1;
		break;

		case 15:
		Views[SelView].interpcolor=iarg2;
		break;
	    }
	}
	else
	if (!strcmp(strupr(csCmdTokens[0]),"PRINT"))
	{
	    flag=1;

	    sscanf(csCmdTokens[1],"%d",&iarg);
	    sscanf(csCmdTokens[2],"%d",&iarg2);

	    switch (iarg)
	    {
		case 0:
		if (strcmp(strupr(csCmdTokens[2]),"ALL"))
		{
		    sprintf(str,"Requested value is %d",Views[SelView].X[iarg2]);
		    csLineTextColor[_PushConsoleText(str)]=_CS_REPLY_COLOR;
		}
		else
		{
		    _ClearConsole();

		    sprintf(str,"Requested values:");
		    iarg2=_PushConsoleText(str);
		    csLineTextColor[iarg2]=_CS_REPLY_COLOR;

		    count=iarg2+1;

		    for (i=0; i<Views[SelView].n; i++)
		    {
			sprintf(str,"X[%d]: %d",i,Views[SelView].X[i]);
			iarg2=_PushConsoleText(str);
			csLineTextColor[iarg2]=_CS_REPLY_COLOR;

			count++;

			if (count>=_CS_CH_HEIGHT)
			{
			    count=1;

			    sprintf(str,"Press any key to go next page...");
			    _PushConsoleText(str);
			    _DrawConsole();
			    getch();
			    _ClearConsole();
			}
		    }
		}
		break;

		case 1:
		if (strcmp(strupr(csCmdTokens[2]),"ALL"))
		{
		    sprintf(str,"Requested value is %.3f",Views[SelView].P[iarg2]);
		    csLineTextColor[_PushConsoleText(str)]=_CS_REPLY_COLOR;
		}
		else
		{
		    _ClearConsole();

		    sprintf(str,"Requested values:");
		    iarg2=_PushConsoleText(str);
		    csLineTextColor[iarg2]=_CS_REPLY_COLOR;

		    count=iarg2+1;

		    for (i=0; i<Views[SelView].n; i++)
		    {
			sprintf(str,"P[%d]: %.3f",i,Views[SelView].P[i]);
			iarg2=_PushConsoleText(str);
			csLineTextColor[iarg2]=_CS_REPLY_COLOR;

			count++;

			if (count>=_CS_CH_HEIGHT)
			{
			    count=1;

			    sprintf(str,"Press any key to go next page...");
			    _PushConsoleText(str);
			    _DrawConsole();
			    getch();
			    _ClearConsole();
			}
		    }
		}
		break;

		case 2:
		if (strcmp(strupr(csCmdTokens[2]),"ALL"))
		{
		    sprintf(str,"Requested value is %.3f",Views[SelView].F[iarg2]);
		    csLineTextColor[_PushConsoleText(str)]=_CS_REPLY_COLOR;
		}
		else
		{
		    _ClearConsole();

		    sprintf(str,"Requested values:");
		    iarg2=_PushConsoleText(str);
		    csLineTextColor[iarg2]=_CS_REPLY_COLOR;

		    count=iarg2+1;

		    for (i=0; i<Views[SelView].n; i++)
		    {
			sprintf(str,"F[%d]: %.3f",i,Views[SelView].F[i]);
			iarg2=_PushConsoleText(str);
			csLineTextColor[iarg2]=_CS_REPLY_COLOR;

			count++;

			if (count>=_CS_CH_HEIGHT)
			{
			    count=1;

			    sprintf(str,"Press any key to go next page...");
			    _PushConsoleText(str);
			    _DrawConsole();
			    getch();
			    _ClearConsole();
			}
		    }
		}
		break;

		case 3:
		if (strcmp(strupr(csCmdTokens[2]),"ALL"))
		{
		    sprintf(str,"Requested value is %d",Views[SelView].nr[iarg2]);
		    csLineTextColor[_PushConsoleText(str)]=_CS_REPLY_COLOR;
		}
		else
		{
		    _ClearConsole();

		    sprintf(str,"Requested values:");
		    iarg2=_PushConsoleText(str);
		    csLineTextColor[iarg2]=_CS_REPLY_COLOR;

		    count=iarg2+1;

		    for (i=0; i<Views[SelView].n; i++)
		    {
			sprintf(str,"Nr[%d]: %d",i,Views[SelView].nr[i]);
			iarg2=_PushConsoleText(str);
			csLineTextColor[iarg2]=_CS_REPLY_COLOR;

			count++;

			if (count>=_CS_CH_HEIGHT)
			{
			    count=1;

			    sprintf(str,"Press any key to go next page...");
			    _PushConsoleText(str);
			    _DrawConsole();
			    getch();
			    _ClearConsole();
			}
		    }
		}
		break;
	    }
	}
	break;
    }

    if (!flag)
    {
	csLineTextColor[_PushConsoleText("Unrecognized command")]=_CS_REPLY_COLOR;
    }
}



/***************************************************************************/
/***************************************************************************/
/***                 Afiseaza tot textul din consola                     ***/
/***************************************************************************/
/***************************************************************************/

void _PrintConsoleText
   (
   )

{
    unsigned int i;
    unsigned short betweenText;


    betweenText=(cstHeight-_CS_CH_HEIGHT*textheight("A"))/_CS_CH_HEIGHT;


    for (i=0; i<csNextLine; i++)
    {
	setcolor(csLineTextColor[i]);
	outtextxy(csX+_CS_SCR_DXY,cstY+_CS_SCR_DXY+i*(betweenText+textheight("A")),csTextLines[i]);
    }
}



/***************************************************************************/
/***************************************************************************/
/***               Afiseaza textul din linia de comanda                  ***/
/***************************************************************************/
/***************************************************************************/

void _PrintConsoleCmdText
   (
   )

{
    setcolor(_CS_CMDLINE_COLOR);
    outtextxy(csX+_CS_SCR_DXY,csbY+_CS_SCR_DXY,csCmdLine);
}



/***************************************************************************/
/***************************************************************************/
/***                        Deseneaza consola                            ***/
/***************************************************************************/
/***************************************************************************/

void _DrawConsole
   (
   )

{
    setcolor(_CS_SIDE_COLOR1);
    setfillstyle(9,_CS_FILL_COLOR);
    setlinestyle(0,0,3);

    bar(
	csX,
	cstY,
	csX+csWidth,
	cstY+cstHeight
       );
    rectangle(
	      csX-_CS_SCR_DXY,
	      cstY-_CS_SCR_DXY,
	      csX+csWidth+_CS_SCR_DXY,
	      cstY+cstHeight+_CS_SCR_DXY
	     );

    bar(
	csX,
	csbY,
	csX+csWidth,
	csbY+csbHeight
       );
    rectangle(
	      csX-_CS_SCR_DXY,
	      csbY-_CS_SCR_DXY,
	      csX+csWidth+_CS_SCR_DXY,
	      csbY+csbHeight+_CS_SCR_DXY
	     );

    _PrintConsoleText   ();
    _PrintConsoleCmdText();


    setlinestyle(0,0,0);
}



/***************************************************************************/
/***************************************************************************/
/***                     Coboara/urca consola                            ***/
/***************************************************************************/
/***************************************************************************/

void _DropConsole
   (
   )

{
    SwitchConsole=1-SwitchConsole;

    if (SwitchConsole)
    {
	cstY=_CS_SCR_DXY;
	csbY=cstY+cstHeight+_CS_SCR_DXY+_CS_SCR_DXY;
    }
    else
    {
	cstY=-(cstHeight+(_CS_SCR_DXY<<1))-_CS_TEXT_SCR_HEIGHT-(_CS_TEXT_RSPACE_SCR<<1);
	csbY=cstY+cstHeight+_CS_SCR_DXY+_CS_SCR_DXY;
    }
}



/***************************************************************************/
/***************************************************************************/
/***         Suma de i de la 1 la n din 1/i (pentru calculul             ***/
/***                  distributiei de probabilitate                      ***/
/***************************************************************************/
/***************************************************************************/

double HN
   (
    unsigned int n
   )

{
    unsigned int i;
    double hn=0;


    for (i=1; i<=n; i++)
    {
	hn+=(double)1/i;
    }


    return(hn);
}



/***************************************************************************/
/***************************************************************************/
/***             Cautare binara ce cauta cel mai mic interval            ***/
/***       discretizat de functia de repartitie "F", in care apare "u"   ***/
/***************************************************************************/
/***************************************************************************/

int BinSearch
   (
    double far *F,
    unsigned int n,
    double u
   )

{
    unsigned int li,ls,m;


    li=0; ls=n-1;

    if (u<F[0])
    {
	return(0);
    }
    else
    {
	do
	{
	    m=(li+ls)>>1;

	    if (ls==1)
	    {
		return(ls);
	    }

	    if (
		(u>F[m-1])&&
		(u<=F[m])
	       )
	    {
		return(m);
	    }
	    else
	    if (u<F[m-1])
	    {
		ls=m-1;
	    }
	    else
	    if (u>F[m])
	    {
		li=m+1;
	    }

	}
	while(li<=ls);
   }


   return(-1);
}



/***************************************************************************/
/***************************************************************************/
/***         Construieste:                                               ***/
/***	       - X    - variabila aleatoare discreta                     ***/
/***           - P    - distributia sa de probabilitate                  ***/
/***           - F    - functia de repartitie (suma de probabilitati)    ***/
/***           - Nr[i]- indica de cate ori s-a generat variabila i din X ***/
/***************************************************************************/
/***************************************************************************/

void _DiscreteSimulation
   (
    unsigned int view
   )

{
    int i,j,k,index;
    double s,u,hn=HN(Views[view].n);


    Views[view].X=(int *)malloc(Views[view].n*sizeof(int));

    for (i=0; i<Views[view].n; i++)
    {
	Views[view].X[i]=i+1;
    }

    Views[view].P=(double *)malloc(Views[view].n*sizeof(double));

    for (i=1; i<=Views[view].n; i++)
    {
	Views[view].P[i-1]=(double)1/(i*hn);
    }

    Views[view].F=(double *)malloc(Views[view].n*sizeof(double));

    Views[view].nr=(int *)malloc(Views[view].n*sizeof(int));

    for (k=0; k<Views[view].n; k++)
    {
	s=0;

	for (i=0; i<=k; i++)
	{
	    s+=Views[view].P[i];
	}

	Views[view].F[k]=s;
    }

    for(i=0; i<Views[view].n; i++)
    {
	Views[view].nr[i]=0;
    }

    init_genrand(Views[view].seed);

    for (j=0; j<Views[view].N; j++)
    {
	u= genrand_real2();
	index=Views[view].X[BinSearch(Views[view].F,Views[view].n,u)];
	Views[view].nr[index-1]++;
    }
}



/***************************************************************************/
/***************************************************************************/
/***                   Initializeaza viewporturile                       ***/
/***************************************************************************/
/***************************************************************************/

void _GenerateViews
   (
   )

{
    Views[0].x=0;
    Views[0].y=0;
    Views[0].width =getmaxx()>>1;
    Views[0].height=getmaxy()>>1;
    Views[0].csx0=Views[0].x+_COORD_SYS_DXY;
    Views[0].csy0=Views[0].y+_COORD_SYS_DXY;
    Views[0].csx1=Views[0].x+Views[0].width -_COORD_SYS_DXY;
    Views[0].csy1=Views[0].y+Views[0].height-_COORD_SYS_DXY;

    Views[1].x=(getmaxx()>>1)+1;
    Views[1].y=0;
    Views[1].width =getmaxx()>>1;
    Views[1].height=getmaxy()>>1;
    Views[1].csx0=Views[1].x+_COORD_SYS_DXY;
    Views[1].csy0=Views[1].y+_COORD_SYS_DXY;
    Views[1].csx1=Views[1].x+Views[1].width -_COORD_SYS_DXY;
    Views[1].csy1=Views[1].y+Views[1].height-_COORD_SYS_DXY;

    Views[2].x=0;
    Views[2].y=(getmaxy()>>1)+1;
    Views[2].width =getmaxx()>>1;
    Views[2].height=getmaxy()>>1;
    Views[2].csx0=Views[2].x+_COORD_SYS_DXY;
    Views[2].csy0=Views[2].y+_COORD_SYS_DXY;
    Views[2].csx1=Views[2].x+Views[2].width -_COORD_SYS_DXY;
    Views[2].csy1=Views[2].y+Views[2].height-_COORD_SYS_DXY;

    Views[3].x=(getmaxx()>>1)+1;
    Views[3].y=(getmaxy()>>1)+1;
    Views[3].width =getmaxx()>>1;
    Views[3].height=getmaxy()>>1;
    Views[3].csx0=Views[3].x+_COORD_SYS_DXY;
    Views[3].csy0=Views[3].y+_COORD_SYS_DXY;
    Views[3].csx1=Views[3].x+Views[3].width -_COORD_SYS_DXY;
    Views[3].csy1=Views[3].y+Views[3].height-_COORD_SYS_DXY;
}



/***************************************************************************/
/***************************************************************************/
/***                      Deseneaza viewporturile                        ***/
/***************************************************************************/
/***************************************************************************/

void _DrawViews
   (
   )

{
    unsigned char i;