Programmation de complexe sous C

Version imprimable

Bonsoir mes amis, je suis entrein de faire un exercice sur les complexe pour me preparer pour un exam et j'aimerais bien savoir votre avis des mon programme j'ai des question que j'ai du mal à faire.

1) Structure complexe.
2) Somme de complexe.
3) multiplication complexe.

Code:

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
 
typedef struct complexe
{
    int Partie_Re;
    int Partie_Im;
}complexe;
 
complexe somme(complexe *z1, complexe *z2)
{
    int somme_Re;
    int somme_Im;
    complexe *somme_Total;
    somme_Re = z1->Partie_Re + z2->Partie_Re;
    somme_Im = z1->Partie_Im + z2->Partie_Im;
    somme_Total-> Partie_Re = somme_Re;
    somme_Total->Partie_Im = somme_Im;
    return somme_Total;
}
 
complexe multiplication( complexe *z1, complexe *z2)
{
    int multi_Re, multi_Im;
    complexe *multi_Total;
    multi_Re = (z1->Partie_Re * z2->Partie_Re) + (z1->Partie_Im * z2->Partie_Im);
    multi_Im = (z1->Partie_Re * z2->Partie_Im) + (z1->Partie_Im * z2->Partie_Re);
    multi_Total->Partie_Re = multi_Re;
    multi_Total->Partie_Im = multi_Im;
    return multi_Total;
}

23/06/2010, 23h07
NiceMarocain

vous pouvez me dire ce que vou pensez de ma premiere partie.
23/06/2010, 23h52
Melem

- J'aurais mis double à la place de int pour les parties réelle et imaginaire.
- Pour les prototypes, j'aurais écrit COMPLEXE somme(const COMPLEXE * z1, const COMPLEXE * z2), où COMPLEX est un typedef de struct complexe. Cf const.
24/06/2010, 00h57
NiceMarocain

j'ai une question à te poser, comment allouer la memoire pour un polynome de complexe de degre d, j'ai du mal à comprendre le principe de malloc

j'ai fait un petit programme et j'aimerais savoir ce que tu pense stp,

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
typedef struct poly
{
    int d;
    complexe *coef;
}poly;
 
poly allouePoly(int degre)
{
    poly *p;
    p->d = degre;
    p= (poly *) malloc (sizeof(poly));
    return *p;
 
}

Code:

1 2 3 4 5 6 7 complexe somme(complexe *z1, complexe *z2) { .... complexe *somme_Total; .... return somme_Total; }
somme_Total n'est pas un complexe, mais un complexe * : un pointeur sur complexe. somme_Total est donc destiné à recevoir l'adresse d'un complexe. Pour l'instant, ce complexe n'existe pas.
En fait, il te faut un complexe pour recevoir le résultat et tu veux en renvoyer une copie. On aura donc :
Code:

1 2 3 4 5 6 7 complexe somme(complexe *z1, complexe *z2) { complexe somme_Total; somme_Total.Partie_Re = z1->Partie_Re + z2->Partie_Re; somme_Total.Partie_Im = z1->Partie_Im + z2->Partie_Im; return somme_Total; }
Même remarque pour multiplication() avec en plus une erreur dans la formule :

Code:

multi_Re = (z1->Partie_Re * z2->Partie_Re) - (z1->Partie_Im * z2->Partie_Im);

Sur ton polynome :

Il faut savoir si tu veux créer un poly par allocation dynamique ou non. Ce semble être le cas dans ton code, donc ta fonction doit retourner l'adresse du poly qu'elle a créé. D'où le prototype :

Code:

poly * allouePoly(int degre);

La fonction doit
Code:

1 2 3 4 5 6 7 8 1- allouer de la mémoire pour un poly 2- si (1) a réussi, 2-1 allouer de la mémoire pour les coefficients 2-2 si (2-1) a réussi, 2-2-1 éventuellement initialiser les coefficients à 0 2-2-2 retourner l'adresse du poly sinon libérer la mémoire allouée en (1) et retourner NULL sinon retourner NULL
A remarquer qu'il y a donc deux allocations à faire :
1- pour un poly :
Code:

1 2 3 4 5 6 7 poly *p = malloc (sizeof(poly)); if(p != NULL) { p->d = degre; ..... } return p;
2-1 pour les coefficients :
Code:

1 2 3 4 p->coef = malloc((degre+1)*sizeof(complexe)); if(p->coef != NULL) { ....

Problème découlant de la situation précédente

Bonjour à tous !

Pour un calcul assez bourrin, j'ai besoin d'utiliser les complexes. A ce que j'ai compris, en C, on ne peut pas y couper: il faut les implémenter. N'ayant pas trouver de bout de code tout prêt tout chaud, je me suis rabattu sur le fils de discussion actuel. En reprenant les bouts de codes et les corrections de chacun, j'ai fait ça:
Code:

1 2 3 4 5 6 7 8 9 10 #include "Test.h" Complex somme(Complex *z1, Complex *z2) { Complex *somme_Total; somme_Total->reel = z1->reel + z2->reel; somme_Total->imag = z1->imag + z2->imag; return *somme_Total; }
Dans test j'ai mis :
Code:

1 2 3 4 5 6 7 typedef struct Complex Complex; struct Complex { double reel; double imag; }; Complex somme(Complex*, Complex*);
Et dans ma main, qui fait d'autres choses mais qui ne plantait pas avant que j'introduise au tout début de la main un test de la fonction somme (donc c'est à cause de somme que le programme plante je pense), j'ai:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 #include <stdio.h> #include <stdlib.h> #include <math.h> #include "Test.h" int main() { printf("Programme de calcul des valeurs a fournir a l Eprom\n"); // Test de la structure Complex Complex za = {3,4}; Complex zb = {6,-4}; printf("za.reel: %f et za.imag: %f", za.reel, za.imag); somme(&za,&zb);
Voilà voilou, NB: le printf se fait sans problème.

Bon été à tous !