/*************************************************************
*    Approximating a function F(x) By Maclaurin's Series     *
* ---------------------------------------------------------- *
* This is the general Maclaurin's formula:                   *
*                                                            *
*                f'(0)  f"(0)  f"'(0)        fn-1(0)         *
*  f(x) = f(0) + ---- + ---- + ----- + ... + ------- + ...   *
*                 1!     2!     3!           (n-1)!          *
*                                                            *
* In the case of sin(x) between x=0 and x=2*PI, the formula  *
* becomes:                                                   *
*                                                            *
*  sin(x) = x - x^3/3! + x^5/5! - x^7/7! + x^9/9! ...        *
*                                                            *
* This small program shows that with 9 terms, we have a fair *
* approximation of sin(x) between 0 and 2*PI.                *
*                                                            *
* With option 2, you can approximate exp(x).                 *
* ---------------------------------------------------------- *
* REFERENCE:                                                 *
*     "Graphisme dans le plan et dans l'espace avec Turbo    *
*      Pascal 4.0 By R. Dony - MASSON, Paris 1990".          *
*                                                            *
*            C++ Version in API style By J-P Moreau, Paris.  *
*************************************************************/
//Import with associated <macsin.mak> file.
//Link with Gr2d.cpp.
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

HDC  hdc;
RECT rect;
HPEN hpen, hpenOld;


//Functions used here of module Gr2D.cpp
void Fenetre(double,double,double,double); 
void Cloture(int,int,int,int);
void Axes(); 
void Bordure();
void Gradue(double,double);
void Grille(double,double);
void MoveXY(double,double);
void LineXY(double,double);


//"home made" graphic commands for hdc environment used by above functions
void DrawPixel(int ix,int iy) {
  //sorry, no other available command found
  Rectangle(hdc,rect.left+ix,rect.top+iy,
	            rect.left+ix+2,rect.top+iy+1);
}

void Swap(int *i1,int *i2) {
  int it;
  it=*i1; *i1=*i2; *i2=it;
}

void DrawLine(int ix1,int iy1,int ix2,int iy2) {
  int i,il,ix,iy;
  float dx,dy;
  if (ix2<ix1) {
	Swap(&ix1,&ix2); Swap(&iy1,&iy2);
  }
  il=(int) sqrt((ix2-ix1)*(ix2-ix1)+(iy2-iy1)*(iy2-iy1));
  dx=(float) (ix2-ix1)/il; 
  dy=(float) (iy2-iy1)/il;
  ix=ix1; iy=iy1;
  for (i=1;i<il+1; i++) {
	DrawPixel(ix,iy);
	ix=(int) (ix1+i*dx); 
	iy=(int) (iy1+i*dy);
  }
}

void OutText(int ix,int iy,char *s) {
  RECT rct;
  rct.left=ix; rct.right=ix+10*strlen(s);
  rct.top=iy-5; rct.bottom=iy+15;
  DrawText(hdc, s, -1, &rct,
                DT_SINGLELINE | DT_CENTER | DT_VCENTER);
}


//begin specific section
#define  B    6.29   // 2PI
#define  step 0.05

  int Example, NbTerms;
  double Y[256];

  double Func(double x) {
    if (Example==1) return sin(x);
	else return exp(x);
  }

  double Fact(int N) {
    double tmp; 
    int i;
    if (N < 1) return 1;
    tmp=1.0;
    for (i=1; i<=N; i++) tmp *= i;
    return tmp;
  }

  void Data() {
    Example=1;
    NbTerms = 8;
  }

  void DrawFunc() {
    double I;
	if (Example==1)
      I=0.0;
	else
      I=-4.0;
    while (I <= B) {
      MoveXY(I, Func(I));
      LineXY(1.01*I, 1.01*Func(I));
      I += step;
    }
  }

  void DrawFuncMaclaurin(int Nbterms) {
    int term,cpt,i, D;
    double X,T; char s[10];
	for (i=0; i<256; i++) Y[i]=0.0;
	D=-1;
    for (term=1; term<=Nbterms; term++) {
      cpt=1;
	  if (Example==1) {
        D += 2;
        X=0.0;
      }
	  else {
        D += 1;
		X=-4.0;
      }
      T=pow(X,D)/Fact(D);
	  if (Example==1)
        if (term%2)
          Y[cpt] += T;
        else
          Y[cpt] -= T;
      else
	    Y[cpt] += T;  	   
      MoveXY(X,Y[cpt]);
      while (X <= B) {
        X += step;
        T=pow(X,D)/Fact(D);
        cpt++;
        if (Example==1)
          if (term%2)
            Y[cpt] += T;
          else
            Y[cpt] -= T;
        else
          Y[cpt] += T;
        LineXY(X,Y[cpt]);
      }
    }
    sprintf(s,"%2d terms.",Nbterms);
	OutText(45,50,s);
  }


  //main function
  void Exec_MacFunc() {
    extern MaxX, MaxY;
    Data();
    MaxX=(rect.right-rect.left);
    MaxY=(rect.bottom-rect.top);
	if (Example==1)
      Fenetre(0, 6, -2, 2);
	else
      Fenetre(-4, 2, -2, 8);
    Cloture(50,MaxX-10,95,MaxY-10);
    Axes();
    Gradue(1.0,1.0);
    Grille(0.5,0.5);
    Bordure();
    DrawFunc();
    DrawFuncMaclaurin(NbTerms);
  }



// end specific section


//Handle window Paint and Destroy messages
long FAR PASCAL /*_export*/ WndProc(HWND hwnd,
    UINT message, UINT wParam, LONG lParam) 
{
   
    PAINTSTRUCT ps;

    switch (message) {
        case WM_PAINT:
	    hdc = BeginPaint(hwnd, &ps);
	    GetClientRect(hwnd, &rect);
            hpen = CreatePen(PS_SOLID, 1, RGB(0, 0, 255));
			hpenOld = SelectObject(hdc,hpen);
            
            Exec_MacFunc();
               
            SelectObject(hdc,hpenOld);
            DeleteObject(hpen);
			EndPaint(hwnd, &ps);
            return 0;
        case WM_DESTROY:
            PostQuitMessage(0);
            return 0;
    }
    return DefWindowProc(hwnd, message, wParam, lParam);
}

// main program
int PASCAL WinMain(HANDLE hInstance, HANDLE hPrevInstance,
    LPSTR lpszCmdParam, int nCmdShow)
{
    static char szAppName[] = "MacFunc";
    HWND        hwnd;
    MSG         msg;
    WNDCLASS    wndclass;

    if (!hPrevInstance) {
        wndclass.style         = CS_HREDRAW | CS_VREDRAW;
        wndclass.lpfnWndProc   = WndProc;
        wndclass.cbClsExtra    = 0;
        wndclass.cbWndExtra    = 0;
        wndclass.hInstance     = hInstance;
        wndclass.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
        wndclass.hCursor       = LoadCursor(NULL, IDC_ARROW);
        wndclass.hbrBackground = GetStockObject(WHITE_BRUSH);
        wndclass.lpszMenuName  = NULL;
        wndclass.lpszClassName = szAppName;

        RegisterClass(&wndclass);
    }

    hwnd = CreateWindow(szAppName,  // window class name
        " MACFUNC",                  // window caption
        WS_OVERLAPPEDWINDOW,        // window style                       
        CW_USEDEFAULT,              // initial x position
        CW_USEDEFAULT,              // initial y position
        CW_USEDEFAULT,              // initial x size
        CW_USEDEFAULT,              // initial y size
        NULL,                       // parent window handle
        NULL,                       // window menu handle
        hInstance,                  // program instance handle
        NULL);                      // creation parameters

   ShowWindow(hwnd, nCmdShow);
   UpdateWindow(hwnd);

   while (GetMessage(&msg, NULL, 0, 0)) {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
   }
   return msg.wParam;
}

// Jean-Pierre Moreau - last update Feb. 2008

//end of file macsin.cpp