Discussion :

[thtghgh]

Bonjour à tous, J'ai fait un petit programme qui me permet de calculer des suites de vecteur (vecteurs 3 dimensions). J'ai 3 questions à vous poser concernant mon programme :

1 - Pouvez vous m'aider à l'optimiser? C'est à dire j'ai crée des fonctions mais en fait je pense qu'il y a plus simple donc si vous voulez m'aider on peut en discuter ici !

2 - En fait comme je l'ai dit plus haut, mon programme calcule des suites de vecteurs et j'aimerais enregistrer ces vecteurs (mon soft en calcule 8 ici, le nombre d'itérations que j'ai choisi) dans un fichier .txt en sortie de mon programme. Comment je peux faire?

3 - Quand je run mon programme tout se passe bien mais je n'ai pas le temps de voir ce qu'il se passe dans la fenetre de commande car elle s'ouvre et se referme directement après, il n'y a pas moyen de la laisser ouverte pour voir les résultats défilé?

Voici mon programme (il est lourd mais je débute...) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
 
 
double eps(double x, double y, double z)  //Fonction epsilon
{
	double m;
	double eps0;
 
	eps0=8.85*pow(10,-12);
	m=(1+eps0*exp(-x)); 
	return m;
}
 
double grad_epsx(double x, double y, double z) //Composante 1 du Vecteur gradient de epsilon
{
	double a;
	double eps0;
 
	eps0=8.85*pow(10,-12);
	a=-eps0*exp(-x); 
	return a;
}
 
double grad_epsy(double x, double y, double z) //Composante 2 du Vecteur gradient de epsilon
{
	double b;
	double eps0;
 
	eps0=8.85*pow(10,-12);
	b=0; 
	return b;
}
 
double grad_epsz(double x, double y, double z) //Composante 3 du Vecteur gradient de epsilon
{
	double c;
	double eps0;
 
	eps0=8.85*pow(10,-12);
	c=-eps0*exp(-x); 
	return c;
}
 
 
void main(void)
{
	int N=8; // nombre d'itérations
	int i,j;
	double r[3];  //Vecteur rayon
	double t[3];  //Vecteur direction
	double temp[3];
	double dh=0.5;
 
	r[0]=0;
	r[1]=0;
	r[2]=0;
 
	t[0]=1;
	t[1]=0;
	t[2]=0;
 
	for (j=1;j<=N;j++)
	{
 
		for (i=0;i<=2;i++) {temp[i]=r[i];}
 
		r[0]=r[0]+dh*t[0];
		r[1]=r[1]+dh*t[1];
		r[2]=r[2]+dh*t[2];
 
 
		t[0]=(sqrt(eps(temp[0],temp[1],temp[2]))/sqrt(eps(r[0],r[1],r[2])))*t[0]+(dh/sqrt(eps(r[0],r[1],r[2])))*grad_epsx(temp[0],temp[1],temp[2]);
		t[1]=(sqrt(eps(temp[0],temp[1],temp[2]))/sqrt(eps(r[0],r[1],r[2])))*t[1]+(dh/sqrt(eps(r[0],r[1],r[2])))*grad_epsy(temp[0],temp[1],temp[2]);
		t[2]=(sqrt(eps(temp[0],temp[1],temp[2]))/sqrt(eps(r[0],r[1],r[2])))*t[2]+(dh/sqrt(eps(r[0],r[1],r[2])))*grad_epsz(temp[0],temp[1],temp[2]);
 
		for (i=0;i<=2;i++)
		{
			printf("\nVecteur rayon (composante %d) : %lf \n",i+1,r[i]);
		}
		printf("\n iteration : %d \n",j);
 
 
	}
}

[haraelendil]

1- pour l'optimisation, si tu expliquait un peu ce que fait ton code et pourquoi, ça permettra de t'aiguiller dans la bonne direction...

2- Ca s'appelle sérialiser, et il y a moyen de faire ça très simplement à partir du moment ou tu n'as pas de considérations de sécurité, genre tu sépare chaques vecteurs entre eux par un certain caractère, chaque valeurs des vecteurs entre elles par un autre.
Après si besoin, tu peux sophistiquer la méthode...

3- Si tu ne met rien pour arrêter le programme, c'est normal qu'il quitte en atteignant la fin de la fonction main.
Pour éviter ça, un simple cin factice, un appel à system("pause") (pas sur de la portabilité de ça^^), ou tout simplement tu lance ton programme depuis une console déjà ouverte.

[thtghgh]

Alors ce que fait mon programme :

Je rentre manuellement une fonction (en 3D) correspondant à la permittivité d'un milieu (en fonction de x y et z), et je rentre aussi le gradient de cette fonction manuellement.

Ensuite, j'utilise une relation entre les vecteurs t et r initialisés dans mon programme pour calculer à chaque itération de nouveaux vecteurs t et r.

A la fin de mes itérations, j'obtiens un vecteur r qui correspond au rayon final.
J'aimerais donc récupérer les coordonées de ce rayon ainsi que les précédents dans un fichier .txt !

[haraelendil]

Bah pour récupérer les valeur de tes vecteurs dans un txt, un simple fprintf avec ce que tu veux suffira, je te laisse chercher un peu voir comment ça marche.

[thtghgh]

Ok merci, concernant le gradient de la permittivité, c'est un vecteur 3D mais j'aimerais au lieu de faire comme j'ai écrit 3 fonctions (1 pour chaque composante) faire une fonction avec un tableau à 3 entrées, est-ce possible?

[diogene]

Une possibilité pour structurer un peu le code est de définir un type pour les vecteurs. Par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
typedef struct
{
  double x;
  double y;
  double z;
} Vect3;

On peut alors avoir une fonction de calcul du gradient (l'argument est spécifié par son adresse pour éviter la recopie) qui renvoie le vecteur gradient:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
#define EPS 8.85E-12
Vect3 grad_eps(const Vect3 * v)
{
  Vect3 vr;
  vr.x = -EPS*exp(-v->x);
  vr.y = 0;
  vr.z = vr.x;
  return vr;
}

On peut également remarquer que la valeur renvoyée par ta fonction eps() pour un Vect3 r est alors 1.0-grad_eps(&r).x. Si ce n'est pas toujours le cas, définir une fonction. Par exemple pour le cas présent, ce serait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
double eps(const * Vect3 v)
{
 return 1+EPS*exp(-v->x);
}

D'après le code à calculer, il peut être commode d'écrire une fonction calculant aB+cD, où a et b sont des scalaires et B et C des Vect3. Le résultat est un Vect3 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
Vect3 aB_plus_cD(double a, const Vect3 *B, double c,const Vect3 *D)
{
  Vect3 vr;
  vr.x = a*B->x + c*D->x;
  vr.y = a*B->y + c*D->y;
  vr.z = a*B->z + c*D->z;
  return vr;
}

Le main devient alors :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
int main(void)
{
   int N=8; // nombre d'itérations
   int j;
   Vect3 r = {0,0,0};  //Vecteur rayon
   Vect3 t = {1,0,0};  //Vecteur direction
   double dh=0.5;
   for (j=1;j<=N;j++)
   {
      double epsr;
      Vect3 temp;
      Vect3 grad;
      temp=r;
      r = aB_plus_cD(1.0,&r,dh,&t);     //r = r+dh*t
      epsr = 1.0/sqrt(1.0-grad_eps(&r).x);
      // ou
      // epsr = 1.0/sqrt(eps(&r));
      grad = grad_eps(&temp);
      t = aB_plus_cD(sqrt(1-grad.x)*epsr,&t,dh*epsr,&grad);
      // ou
      // t = aB_plus_cD(sqrt(eps(&temp))*epsr,&t,dh*epsr,&grad);
      printf("\Iteration %d : Vecteur rayon x=%lf y=%lf z=%lf \n",j,r.x,r.y,r.z);
   }
  getchar();
  return 0;
}