Discussion :

[nant44]

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]

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]

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]

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]

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]

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]

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é.