Tracer une fonction

Soyez le premier à donner votre avis sur cette source.

Vue 3 522 fois - Téléchargée 332 fois

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; }

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

cs_Nicolus
Messages postés
16
Date d'inscription
mercredi 18 juillet 2001
Statut
Membre
Dernière intervention
15 juillet 2003

oui c'est sur il y a deja des lib toutes pretes.
mais c'est tres interessant d'ecrire un analyseur quand on n'en a jamais ecrit!
sur le code va grossir, mais c'est surtout ca qui fera la richesse et la puissance de ton prog :)
cs_Nicolus
Messages postés
16
Date d'inscription
mercredi 18 juillet 2001
Statut
Membre
Dernière intervention
15 juillet 2003

oui c'est sur il y a deja des lib toutes pretes.
mais c'est tres interessant d'ecrire un analyseur quand on n'en a jamais ecrit!
sur le code va grossir, mais c'est surtout ca qui fera la richesse et la puissance de ton prog :)
cs_NiFF
Messages postés
92
Date d'inscription
dimanche 2 juin 2002
Statut
Membre
Dernière intervention
24 juin 2004

Faisable et pas trop dur en utilisant Flex et Bison (autrefois Lex et Yacc), Lex=analyseur lexical, Yacc= yet another compiler of compiler.
Ces outils sont utilisés pour faire des compilateurs et des analyseurs lesxicaux, parsers, enfin tout ce dont tu as besoin ici.
cs_JCDjcd
Messages postés
1138
Date d'inscription
mardi 10 juin 2003
Statut
Membre
Dernière intervention
25 janvier 2009
2
Pour ce qui est des fonction a saisir ...
c'est dur d'analyser une expression, bon je sais faire met si je le met le code va grossir enormenet, et il faudras tester s'il n'y a pas d'erreur ! Bon en gros galere et long ....................................
cs_751
Messages postés
68
Date d'inscription
vendredi 3 mai 2002
Statut
Membre
Dernière intervention
6 juillet 2007

pas mal mais avec un menu pour chaque fonction ce serait peut être mieux, ou si cela peut être amélioré pour tracer n'importe quelle fonction à saisir

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.