Tracer une fonction

Télécharger le projet
Commenter

Description

Voila un exemple de tracage de fonctions.

pour quitter vous faite 'q'*
pour faire un Zoom Avant 'i' (comme In)
pour faire un Zoom Arriere 'o' (comme Out)

Mais bon les zoom sont bugger car lorsque vous faite trop de ZoomIn, l'ecart Xmin Xmax est trop petit donc ==0 donc erreur non gerer

Je ferais une version Win32 plus evoluer plus tard ...

DES COMMENTAIRES S.V.P. !

Source / Exemple : 


#include <graphics.h>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <math.h>

/*************************************************/
/* TOUS LES PARAMETRES */
#define X_SCREEN_MAX 630
#define Y_SCREEN_MAX 470

#define PRECISION 2000

/*************************************************/
/* la strucure */
typedef struct tagVIEW
	{
	double xMin,xMax;
	double yMin,yMax;
	}VIEW,*P_VIEW;
/*************************************************/
/* initialisation bete et mechante */
void SetView(P_VIEW p,double xMin,double xMax,double yMin,double yMax)
{
p->xMin = min(xMin,xMax);
p->xMax = max(xMin,xMax);
p->yMin = min(yMin,yMax);
p->yMax = max(yMin,yMax);
}
/*************************************************/
/* zoom arriere, i.e. 4x plus de vision */
void ZoomOutView(P_VIEW p)
{
/* longeur et largeur DIVISER PAR 2 */
double lar,lon;

lon = (p->xMax - p->xMin)/2.;
lar = (p->yMax - p->yMin)/2.;

/* on redimensionne */
p->xMin -= lon;
p->xMax += lon;
p->yMin -= lar;
p->yMax += lar;
}
/*************************************************/
/* zoom avant */
void ZoomInView(P_VIEW p)
{
/* longeur et largeur DIVISER PAR 4 */
double lar,lon;

lon = (p->xMax - p->xMin)/4.;
lar = (p->yMax - p->yMin)/4.;

/* on redimensionne */
p->xMin += lon;
p->xMax -= lon;
p->yMin += lar;
p->yMax -= lar;
}

/*************************************************/
void DefaultView(P_VIEW p)
{
SetView(p,-10.,+10.,-10.,+10.);
}
/*************************************************/
/* calcul une coordonne en fonction d'un min et d'un max */
/* dans un 'ecran' allant de 0 a maxScreen */
double _LineView(double min,double max,double nb,int maxScreen)
{
return (maxScreen * (nb - min)) / (max - min);
}

/* trace une ligne de (xStart,yStart) a (xEnd,yEnd) */
void LineView(P_VIEW p,double xStart,double yStart,double xEnd,double yEnd)
{
int x,y,xx,yy;

x  = (int) _LineView(p->xMin,p->xMax,xStart,X_SCREEN_MAX);
y  = (int) _LineView(p->xMin,p->xMax,yStart,Y_SCREEN_MAX);
xx = (int) _LineView(p->yMin,p->yMax,xEnd  ,X_SCREEN_MAX);
yy = (int) _LineView(p->yMin,p->yMax,yEnd  ,Y_SCREEN_MAX);

/* +1 est vers le haut sur un graph, mais sur l'ecran c'est vers le bas ! */
line(x,Y_SCREEN_MAX - y,xx,Y_SCREEN_MAX - yy);
}

/*************************************************/
void VerticalLineView(P_VIEW p,double a)
{
LineView(p,a,p->yMin,a,p->yMax);
}
/*************************************************/
void HorizontalLineView(P_VIEW p,double a)
{
LineView(p,p->xMin,a,p->xMax,a);
}
/*************************************************/

void initGraphics(void)
	{
	int gr,mode,error;
	gr = DETECT;
	initgraph(&gr,&mode,"");
	error = graphresult();
	if(error != grOk)
		{
		printf("Erreur initgaph():%s",grapherrormsg(error));
		exit(1);
		}
	cleardevice();
	}
/*************************************************/
void PrintFunction(P_VIEW pView,int (*func)(double*,double),int color)
{
double x,f,step;
double old_X,old_Y;
int    boolFunction;

setcolor(color);

/* on calcule le step en fonction du #define PRECISION */
step = (pView->xMax - pView->yMin) / PRECISION;

x = pView->xMin;
do
  {
	boolFunction = func(&f,x);
  if(boolFunction || x > pView->xMax)
    {
    break;
    }
  x += step;
	}while(1);

old_X = x;
old_Y = f;

while( x<= pView->xMax)
	{
	if(func(&f,x))
		{
		LineView(pView,old_X,old_Y,x,f);
		}

	old_X = x;
	old_Y = f;
	x += step;
	}

}
/*************************************************/
/* 						LES FONCTIONS											 */
/*************************************************/
/* --------------------------------------------- */
int funcParabole(double *res,double x)
{


  • res = x*x - 3;

return 1;
}
/* --------------------------------------------- */
int funcHyperbole(double *res,double x)
{
if(x == 0.0)
	{
	return 0;
	}


  • res = 1/x;

return 1;
}
/* --------------------------------------------- */
int funcLn(double *res,double x)
{
if(x <= 0.0)
 {
 return 0;
 }


  • res = log(x);

return 1;
}
/* --------------------------------------------- */
int funcSin(double *res,double x)
{


  • res = sin(x);

return 1;
}
/* --------------------------------------------- */
int funcTan(double *res,double x)
{
/* ici pour les erreurs ??? */


  • res = tan(x);

return 1;
}

/*************************************************/
int main(int argc,char **argv)
{
VIEW view,*pView;

(void) argc;
(void) argv;
initGraphics();
pView = &view;

DefaultView(pView);

do
	{
	int key;

	cleardevice();
	/* on affiche les axes */
	setcolor(LIGHTRED);
	VerticalLineView(pView,0);
	HorizontalLineView(pView,0);
	PrintFunction(pView,funcParabole		,LIGHTGREEN);
	PrintFunction(pView,funcHyperbole		,LIGHTBLUE);
	PrintFunction(pView,funcTan					,BROWN);
	PrintFunction(pView,funcLn					,LIGHTCYAN);
	PrintFunction(pView,funcSin					,YELLOW);

	key = getch();
	if(key == 'q')					/* QUITTER */
		{
		break;
		}
	else if(key == 'o')
		{
		ZoomOutView(pView);		/* OUT */
		}
	else if(key == 'i')
		{
		ZoomInView(pView);		/* IN */
		}

	}while(1);

closegraph();
return 0;
}
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (cs_JCDjcd)