[debutant] matrice 2d

**nant44** · 28/09/2009, 10h35

Bonjour,
Je suis nouveau en c/c++ et j'essaye en ce moment d'écrire un programme en c++ qui me calcul les éléments d'une matrice à 2 dimensions, stocker les resultats d'un fichier text pour l'utiliser dans un autre programme global (pas encore réalisé !

Les élèments de la matrice calculés par ce programme sont :
matrice(k,l) = exp(j*2*pi*(k-1)*(sin(xk)-sin(x0)))*exp(j*2*pi*(l-1)*(sin(yk)-sin(y0)))
avec k = 1, 2 ,..., N
l = 1,2,....,M
xk = 0,...,90 (avec un pas donné)
yk = 0,...,360 (avec un pas donné)
x0 choisi entre 0 et 90
y0 choisi entre 0 et 360

J'ai 3 questions à vos poser svp:
1) que pensez vous ce code ?
2) j'ai problème d'allocation dynamique je crois mais je ne vois pas comment le résoudre ! car qd je compile avec le paramèttre STEP=1 tout marche bien par contre qd je le lance avec STEP=0.1 il m'affiche le message suivant "16223 [main] output 5388 _cygtls::handle_exceptions: Error while dumping state (probably corrupted stack) Segmentation fault (core dumped)"
3) Normalement les deux paramettres N et M sont relativement grands (de l'ordre de 100), le temps de calcul est important dans ce cas. Comment optimiser mon code pour qu'il soit rapide ?

ci-joint ce que j'ai pu faire pour le moment.

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
 
#include <iostream>
#include <iomanip>
#include <fstream>
#include <math.h>
#include <complex>
 
using namespace std;
 
#define  STEP  0.1
#define nthetaMAX  901
#define nphiMAX 3601
 
int main()
{
    float theta0,phi0,d2r,dn,dm,A0,B0,Ak,Bk;
    int N,M;
    int n1,n2,n3,n4;
    complex <float> matrice[nthetaMAX][nphiMAX];
 
    // ***************************
    // declaration de paramettres
    // ***************************
    theta0 = 30;
    phi0 = 136;
    dn = 3.2;
    dm = 2.7;
    N = 5;
    M = 8;
    d2r = M_PI/180;
 
    // **********************************
    // Calcul des éléments de la matrice
    // **********************************
    A0 = -2*M_PI*dn*sin(theta0*d2r);
    B0 = -2*M_PI*dm*cos(phi0*d2r);
 
    for (n1 = 0; n1 < nthetaMAX-1; n1++){
        for (n2 = 0; n2 < nphiMAX-1; n2++){
                Ak = 2*M_PI*dn*sin(n1*STEP*d2r);
                Bk = 2*M_PI*dm*cos(n2*STEP*d2r);
                for (n3 = 0; n3 <= N-1; n3++){
                    for (n4 = 0; n4 <=M-1; n4++){
                    matrice [n1][n2]+= exp(complex<float>(0,n3*A0))*exp(complex<float>(0,n4*B0))*exp(complex<float>(0,n3*Ak))*exp(complex<float>(0,n4*Bk));
                    }
                }
        }
    }
    //cout << "printfile";
    ofstream myfile;
    myfile.open ("test.txt");
    for (n1=0; n1 <= nthetaMAX-1; n1++){
        for (n2=0; n2 <= nphiMAX-1; n2++){
            myfile << (abs(matrice[n1][n2])) << " ";
            }
            myfile << endl;
            }
            myfile.close();
 
}

**bacelar** · 28/09/2009, 11h01

Sur mon Visual Studio 2008, c'est tout le contraire. Il n'y a pas d’allocations dynamiques (sur le tas) mais que des allocations automatiques (sur la pile).

Le problème, c'est que votre matrice est bien trop grande pour être dans la pile. Essayez de la mettre dans le tas avec un new[][].

**nant44** · 28/09/2009, 11h27

Merci bacelar.
J'ai essayé de remplacer la ligne

Code :

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

 complex <float> matrice[nthetaMAX][nphiMAX];

par

Code :

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

complex <float> (*matrice)[nthetaMAX][nphiMAX] = new float [nthetaMAX][nphiMAX];

malheureusement cela ne marche pas. J'ai surement mal exploité votre idée.

**Goten** · 28/09/2009, 11h40

Normal c'est pas la bonne façon de faire, une façon propre de le faire est exposé ici :
http://cpp.developpez.com/faq/cpp/?p..._new_array_dim (il y'a l'entrée de faq correspondante pour la libération).

Mais autant utiliser des outils adapter (plutôt que des tableaux C-like) :
soit la solution un peu plus légére boost::multi-array
ou carrément boost::ublas qui est fait pour le calcul matriciel.

Ah et aussi : les constantes à coup de define en C++ c'est pas le top. (on préférera de vraie constante.)

**r0d** · 28/09/2009, 11h42

Bonjour,

ton code ne fonctionne pas chez moi, et je n'arrive pas à trouver l'erreur (stack overflow avant d'entrer dans le main).

Mais quoi qu'il en soit, je te conseille de mieux structurer ton code. Il y aura peut-être plus de lignes de code à la fin, mais il sera plus facile à comprendre, à débugger et à améliorer. De plus, le c++ offre une approche objet qu'il serait dommage de ne pas utiliser.

Je te conseilles donc de créer une classe matrice. Voici une bonne piste:
http://www.developpez.net/forums/d24...s-utilise-stl/

**bacelar** · 28/09/2009, 14h56

nant44 :

Code :

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

complex<float> (*matrice)[nphiMAX] = new complex<float>[nthetaMAX][nphiMAX];

Goten :
Merci pour l'exemple d'allocation "exception safe", mais je ne pense pas que cela soit le principale problème de robustesse du programme.

r0d :
C'est normal de ne pas le voir dans le débuggeur, il faut mettre un bien d'arrêt dans la fonction généré par le compilateur __mainCRTStartup.
C'est dans le prologue de la méthode main que cela plante en essayant d'allouer sur la pile l'ensemble de la place nécessaire aux variables locales de la fonction.

**Goten** · 28/09/2009, 15h05

Ben si je répondais à son deuxiéme post... il faisait d'une façon erroné. (la syntaxe était erroné en tout cas). Donc avec l'exemple il a les deux choses : la bonne syntaxe et la bonne façon de faire.
La vraie bonne façon de faire étant d'utilisé les outils approprié.

**nant44** · 28/09/2009, 17h26

merci pour vos réponses, j'ai essayé de prendre en compte certaines de vos remarque (desolé je suis debutant et j'ai pas tt compri).
bacelar : merci pour ta ligne de code, desolé j'ai pas fait attention a la syntaxe !
Par contre, après compilation j'ai constaté que mon code donne des résulats bizarres pourtant tt me semble correct !!!
voici mon code :

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
 
#include <iostream>
#include <iomanip>
#include <fstream>
#include <math.h>
#include <complex>
 
using namespace std;
 
// ***************************
// declaration des constantes
// ***************************
const float STEP = 1; // pas de calcul 
const int nthetaMAX = 91; // nombre de points de l'axe theta
const int nphiMAX = 361; // nombre de points de l'axe phi
const float   dn = 2.3;
const float   dm = 1.8;
const float  d2r = M_PI/180;
const int N = 3;
const int M = 4;
 
 
int main()
{
    float theta0,phi0,A0,B0,Ak,Bk;
    int n1,n2,n3,n4;
    complex<float> (*matrice)[nphiMAX] = new complex<float>[nthetaMAX][nphiMAX];
    theta0 = 30;
    phi0 = 30;
 
    // **********************************
    // Remplissage de la matrice
    // **********************************
    A0 = -2*M_PI*dn*sin(theta0*d2r);
    B0 = -2*M_PI*dm*cos(phi0*d2r);
 
    for (n1 = 0; n1 < nthetaMAX-1; n1++){
        for (n2 = 0; n2 < nphiMAX-1; n2++){
                Ak = 2*M_PI*dn*sin(n1*STEP*d2r);
                Bk = 2*M_PI*dm*cos(n2*STEP*d2r);
                for (n3 = 0; n3 <= N-1; n3++){
                for (n4 = 0; n4 <= M-1; n4++){
                matrice[n1][n2]+=exp(complex<float>(0,n3*A0))*exp(complex<float>(0,n4*B0))*exp(complex<float>(0,n3*Ak))*exp(complex<float>(0,n4*Bk));
                }
                }
      }
    }
 
 
    ofstream myfile;
    myfile.open ("matrix.txt");
    for (n1=0; n1 <= nthetaMAX-1; n1++){
        for (n2=0; n2 <= nphiMAX-1; n2++){
            myfile << abs(matrice[n1][n2]) << " ";
            }
            myfile << endl;
            }
            myfile.close();
 
 
}

**bacelar** · 28/09/2009, 18h26

j'ai constaté que mon code donne des résulats bizarres pourtant tt me semble correct !!!

Madame Irma, c'est le forum d'à côté.

Un new[], pourquoi pas mais ou est le delete[] ?

**nant44** · 28/09/2009, 18h40

J'ai essayé de mettre

Code :

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

delete matrice;

juste avant l'accolade de fin de main mais ca change rien dans le probleme. la matrice resultante est est tjrs nulle!
J'ai meme essayé sans new[] ... rien a faire

**bacelar** · 28/09/2009, 19h33

la matrice resultante est est tjrs nulle!

Alors qu'est-ce que fait un fichier text.txt de 26 991 954 octets sur mon disque ???

Code :

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

delete matrice;

Moi, j'ai dis delete[]

Code :

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

delete[](matrice);

**nant44** · 28/09/2009, 23h33

a quel endroit exactement dois-je mettre ? voila ce que j'ai fait mais ca marche pas

Code :

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

1
2
3
4
5
 
            myfile.close();
 
     delete[](matrice);       
}

Peux-tu copier ton code stp ?

**bacelar** · 29/09/2009, 09h43

Marche pas ? normal, ça fonctionne

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
 
#include <iostream>
#include <iomanip>
#include <fstream>
#include <math.h>
#include <complex>
 
using namespace std;
 
// ***************************
// declaration des constantes
// ***************************
const float STEP = 1; // pas de calcul 
const int nthetaMAX = 91; // nombre de points de l'axe theta
const int nphiMAX = 361; // nombre de points de l'axe phi
const float   dn = 2.3;
const float   dm = 1.8;
const float  d2r = M_PI/180;
const int N = 3;
const int M = 4;
 
 
int main()
{
	float theta0,phi0,d2r,dn,dm,A0,B0,Ak,Bk;
	int N,M;
	int n1,n2,n3,n4;
	int i =1;
	complex<float> (*matrice)[nphiMAX] = new complex<float>[nthetaMAX][nphiMAX];
 
	// ***************************
	// declaration de paramettres
	// ***************************
	theta0 = 30;
	phi0 = 136;
	dn = 3.2;
	dm = 2.7;
	N = 5;
	M = 8;
	d2r = M_PI/180;
 
	// **********************************
	// Calcul des éléments de la matrice
	// **********************************
	A0 = -2*M_PI*dn*sin(theta0*STEP*d2r);
	B0 = -2*M_PI*dm*cos(phi0*STEP*d2r);
 
	for (n1 = 0; n1 < nthetaMAX-1; n1++){
		for (n2 = 0; n2 < nphiMAX-1; n2++){
			Ak = 2*M_PI*dn*sin(n1*STEP*d2r);
			Bk = 2*M_PI*dm*cos(n2*STEP*d2r);
			for (n3 = 0; n3 <= N-1; n3++){
				for (n4 = 0; n4 <=M-1; n4++){
					matrice [n1][n2]+= exp(complex<float>(0,n3*A0))*exp(complex<float>(0,n4*B0))*exp(complex<float>(0,n3*Ak))*exp(complex<float>(0,n4*Bk));
				}
			}
		}
	}
	//cout << "printfile";
	ofstream myfile;
	myfile.open ("test.txt");
	for (n1=0; n1 <= nthetaMAX-1; n1++){
		for (n2=0; n2 <= nphiMAX-1; n2++){
			myfile << (abs(matrice[n1][n2])) << " ";
		}
		myfile << endl;
	}
	myfile.close();
	delete[](matrice);
}

**nant44** · 29/09/2009, 16h34

merci bacelar.
J'ai une autre question svp.
pour rendre le code evolutif j'ai pensé à rempalcer

Code :

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

1
2
3
 
const float STEP = 1; // pas de calcul 
const int nthetaMAX = 91; // nombre de points de l'axe theta

par :

Code :

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

1
2
3
4
 
const float STEP = 1; // pas de calcul 
const float nthetaMAXtemp = 1 + 90/STEP; // nombre de point de l'axe theta
int nthetaMAX = (int)nthetaMAXtemp;

j'ai essayé de faire la même chose pour nphiMAX mais ca ne marche pas a cause de l'allocation dynamique

Code :

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

complex<float> (*matrice)[nphiMAX] = new complex<float>[nthetaMAX][nphiMAX];

avez-vous svp une idée résoudre ce probleme ?

**bacelar** · 29/09/2009, 17h30

Alors, si vous commencez à vouloir sérieusement faire un programme maintenable, pensez à regarder les remarques de Goten.

Un code évolutif avec des constantes à modifier à chaque évolution, c'est très moyen.

Pensez à utiliser les paramètres de la ligne de commande et les convertir en entier. Les constantes seraient alors utilisées comme des valeurs par défauts.

L'allocation dynamique permet de facilement prendre en compte des valeurs passées en paramètre mais l'utilisation en est quelque peu abscond par rapport aux voies montrées par Goten.

[debutant] matrice 2d

C++

Discussions similaires

Partager

Partager