Discussion :

[conanran]

Bonjour,
J'ai une fonction codé en C qui permet de générer un tableau 3D. Cette fonction génère le grand pourcentage du temps de l'exécution de tout le programme.
La même fonction a été codé sous Matlab et le temps de calcul est beaucoup moins inférieur, malgré que normalement le C est plus rapide que Matlab.
Est-ce que vous pensez que normale ou bien je n’ai pas bien codé la fonction?

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
 
void matrice_F(float ***F,int M,int N, int O)
{
	   float ***Mt=alloue_tableau(vs,vs,s);
        matrice_Mt(Mt,vs,vs,s);
 
 
     float **P=alloue_mtrice(vs,vs);
     matrice_Mr(P,vs,vs);
 
 
    int i,j,k;   
       for (k = 0; k < O; k++)
 
    {
        for (i = 0; i < M; i++)
        {
			for (j = 0; j < N; j++)
             {   
 
				 if (k<dv)
                   {
		   flash[i][j][k]=0;
	               }
	             else
	               {
 
        F[i][j][k]=(2*Q)/(E*sqrt(pow(M_PI,3)*Mt[i][j][k]))*(1/(pow(R,2)+8*D*Mt[i][j][k]))*exp((-2*pow(P[i][j],2))/(pow(R,2)+8*D*Mt[i][j][k]));
 
	               }
            }
       }
   }
   	libre_tab(Mt,vs,vs);
   	libre_matrice(P);
}

Merci

[Bousk]

On t'a déjà dit à plusieurs reprises que ton truc est un gouffre à perf.
En plus que l'utilisation de tableau à 3 dimensions est une hérésie.
Sans compter les 2 matrices temporaires sûrement dispensables, du mauvais C ne sera pas plus rapide que Matlab.

https://c.developpez.com/faq/?page=L...a-2-dimensions

[Kannagi]

La même fonction a été codé sous Matlab et le temps de calcul est beaucoup moins inférieur, malgré que normalement le C est plus rapide que Matlab.

Sachant que Matlab est écrit en partie en C et C++
Et donc que les calculs mathématique sur Matlab sont sûrement bien optimisé et écrit en C ou C++ derrière

Sinon ton code est vachement horrible à lire , et les triples pointeur c'est le truc que personnellement j'éviterai (enfaîte je n’ai jamais utilisé de triple pointeur pour dire ) , un vrai nid a bug ces machins là !

[Sve@r]

Bonjour

Certains t'ont déjà fait des remarques dans tes autres topics concernant l'utilisation de tableaux3D dupliqués et redupliqués, remarques que tu ne prends visiblement pas en compte. De mon côté je rajoute que je t'ai déjà parlé des avantages d'écrire du code bien indenté qui permet de le lire facilement et je vois que tu n'en tiens là aussi pas non plus compte avec ce code et son indentation de merde.
Donc visiblement tu n'aimes pas le C donc tu nous excuseras si de notre côté nous n'avons pas envie d'investir du temps et des efforts pour rien.

[conanran]

Merci Sve@r pour tes conseils et tes remarques pertinentes

Par ailleurs, ce n’est pas question que je n’aime pas le C, mais la réalité que j’ai commencée il y a deux semaines à coder avec le C et je le trouve très difficile et d'ailleurs parfois je ne comprends même pas tes remarques, pref j’applique ce que je comprends.
Je comprends aussi que vous n’avez pas envie d'investir du temps et des efforts pour les débutants.
Merci encore…

[Bktero]

Bonjour,

Si tu as commencé le C il y a 2 semaines, alors clairement attaquer des tableaux à 3 dimensions est un sujet bien trop difficile pour toi. Ca fait 10 ans que j'ai appris le C (aïe ça pique d'écrire ça !) et clairement ce genre de choses me fait peur, comme Kannagi. Es-tu obligé de devoir utiliser le C pour résoudre ce problème ? Est-ce un exercice ? Un TP ? Un projet ? Un stage ?

Je comprends aussi que vous n’avez pas envie d'investir du temps et des efforts pour les débutants.

Et pourtant ces 3 personnes ont déjà investi du temps pour toi et on encore une fois pris le temps de te répondre

[conanran]

@Bktero
j'ai dit merci pour toutes et tous (même les personnes qui n'ont pas répondues ). Oui, effectivement je travaille sur un projet que doit le faire avec C., dans l'habitude j'utilise que Matlab. Et malheureusement il y a beaucoup de tableaux
Merci

[Bktero]

Si le C est obligatoire (à voir si tu pourrais pas le faire en C++ d'ailleurs), alors il faut y aller très progressivement et avec beaucoup de précaution. Il te faut construire des abstractions sur ce qu'est une matrice 3D (et donc dire au revoir aux float*** bruts), avec des fonctions et des macros qui vont te simplifier la vie, et enfin idéalement des tests pour valider ces fonctions. En bref, te faire une bibliothèque de gestion des matrices 3D. Ca existe d'ailleurs sûrement sur GitHub, tu devrais chercher avant de tout réinventer (*) ! En effet, réinventer tout ça n'est pas le travail de quelques heures, mais au moins de quelques jours, pour ne pas dire quelques semaines si tu débutes. Dans tous les cas, il faut que tu prennes le temps de comprendre les remarques, de faire des essais et ainsi tu pourras construire une base saine pour réaliser ton projet.

(*) Voici par exemple le premier résultat Google pour une recherche "github 3d matrix C" : https://github.com/recp/mathkit

[Sve@r]

mais la réalité que j’ai commencée il y a deux semaines à coder avec le C et je le trouve très difficile

Et ça t'empêche de bien l'écrire ??? C'est donc si difficile que ça de remplacer cet immonde

Code c :

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
void matrice_F(float ***F,int M,int N, int O)
{
	   float ***Mt=alloue_tableau(vs,vs,s);
        matrice_Mt(Mt,vs,vs,s);
 
 
     float **P=alloue_mtrice(vs,vs);
     matrice_Mr(P,vs,vs);
 
 
    int i,j,k;   
       for (k = 0; k < O; k++)
 
    {
        for (i = 0; i < M; i++)
        {
			for (j = 0; j < N; j++)
             {   
 
				 if (k<dv)
                   {
		   flash[i][j][k]=0;
	               }
	             else
	               {
 
        F[i][j][k]=(2*Q)/(E*sqrt(pow(M_PI,3)*Mt[i][j][k]))*(1/(pow(R,2)+8*D*Mt[i][j][k]))*exp((-2*pow(P[i][j],2))/(pow(R,2)+8*D*Mt[i][j][k]));
 
	               }
            }
       }
   }
   	libre_tab(Mt,vs,vs);
   	libre_matrice(P);
}

Par un élégant

Code c :

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
void matrice_F(float ***F,int M,int N, int O)
{
	float ***Mt=alloue_tableau(vs,vs,s);
	matrice_Mt(Mt,vs,vs,s);
	float **P=alloue_mtrice(vs,vs);
	matrice_Mr(P,vs,vs);
 	int i,j,k;   
 
	for (k = 0; k < O; k++)
	{
		for (i = 0; i < M; i++)
		{
			for (j = 0; j < N; j++)
			{
				if (k<dv)
				{
					flash[i][j][k]=0;
				}
				else
				{
					F[i][j][k]=(2*Q)/(E*sqrt(pow(M_PI,3)*Mt[i][j][k]))*(1/(pow(R,2)+8*D*Mt[i][j][k]))*exp((-2*pow(P[i][j],2))/(pow(R,2)+8*D*Mt[i][j][k]));
				}
			}
		}
	}
   	libre_tab(Mt,vs,vs);
   	libre_matrice(P);
}

??? Et encore je dis "remplacer" mais ça ne devrait même être le cas puisque (en théorie) ce code indenté devrait venir naturellement dès son écriture. Et là, je remarque alors du premier coup d'oeuil que la variable "flash" n'existe pas.

et d'ailleurs parfois je ne comprends même pas tes remarques

T'as le droit de dire "je n'ai pas compris tel ou tel truc"

bref j’applique ce que je comprends.

Ben non. Ou alors tu n'as pas compris ce que signifie "indenter son code".

Je comprends aussi que vous n’avez pas envie d'investir du temps et des efforts pour les débutants.

Très bel exemple de sophisme. Je n'ai pas envie d'aider un débutant qui montre qu'il n'a que faire des aides qu'on lui apporte donc je n'ai pas envie d'aider les débutants en général.
On est là pour aider mais aider ceux qui s'investissent, c'est à dire qui déjà appliquent les premières remarques de base. On (ou du moins moi) en revanche je ne vais pas investir du temps sur quelqu'un qui visiblement n'en a rien à faire (donc fatalement à perte).
Accessoirement tu as une sous-branche "débutant" du forum spécialement dédiée aux débutants et tu verras qu'il y a beaucoup de réponses.

[chrtophe]

Pour commencer comprends ce qu'est indenter le code ?
Au cas ou la réponse est non, il s'agit de l'organiser en décalant les lignes par des tabulations de façon à voir les différentes structures imbriqués. Et dès que le code commence à prendre de l'ampleur, ça devient quasi obligatoire.
exemple :

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
 
if (condition)
{
   for (boucle;boucle<10;++boucle)
  {
      for (boucle_deux;boucle_deux<10;++boucle_deux)
      {
         ...
      }
  }
}
else
{
  ...
}

Tu vois tout de suite l’intérêt pour la relecture et la compréhension.
Et surtout que le moindre EDI le fait tout seul.

Ensuite une ligne comme :

Code :

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

1
2
F[i][j][k]=(2*Q)/(E*sqrt(pow(M_PI,3)*Mt[i][j][k]))*(1/(pow(R,2)+8*D*Mt[i][j][k]))*exp((-2*pow(P[i][j],2))/(pow(R,2)+8*D*Mt[i][j][k]));

C'est imbitable. Nomme correctement tes variables avec un nom explicite au lieu de i,j,k. Surtout si ton code doit être relu par d'autres.

Et je te garantie que tu seras content de l'avoir fait dans 2 ans si tu dois relire le code.
Par ailleurs, une ligne comme ça je l'aurais fait en plusieurs lignes pour la clarté. décomposes. Ce n'est pas parce que tu mets l'équivalent de ce code sur plusieurs lignes que ce sera plus long, c'est au compilateur d'optimiser. Mais il n'optimisera pas ton algorithme.
Je ne sais pas ce que tu cherches à faire comme calcul, mais saches qu'il existe des bibliothèques spécialisées pour plein de choses. Ça évites de réinventer la roue, ça évite les erreurs, et c'est peut-être plus optimisé que ce que tu feras.
Bien que le faire toi même, c'est bien pour apprendre.

La solution t'a été donnée lors du 1er post (de Bousk).

Et gardes à l'esprit qu'en temps que débutant, faire un code qui marche est le 1er objectif à atteindre. Le rendre plus efficace, c'est après.

[Sve@r]

Nomme correctement tes variables avec un nom explicite au lieu de i,j,k.

A la limite "i,j et k" c'est des noms habituels de variables de boucles donc là encore ça va. Mais "E", "M_PI", "D", "Q" etc là ça va plus.

[edgarjacobs]

A la limite "i,j et k" c'est des noms habituels de variables de boucles donc là encore ça va. Mais "E", "M_PI", "D", "Q"....

Entièrement d'accord avec toi, mais M_PI est #defined dans math.h

[Guntha]

Le problème quand on essaie de retranscrire un algo écrit en langage "mathématique" vers le C ou autre (ce qui semble être le cas ici), on a tendance à garder les mêmes noms de variables pour rester cohérent. Et malheureusement dans les maths, la norme, ce n'est pas des noms de variable explicite :p

Je me souviens, pendant ma formation d'ingénieur, pour un projet de Recherche Opérationnelle, j'ai écrit un truc du genre:

Code :

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

1
2
3
4
5
6
7
for(int i = 0; i < something.length(); i++
{
    for(int j = 0; j < J.length(); j++)
    {
        J[j] = ...;
    }
}

Parce que "J" représentait quelque chose de précis dans l'algo qu'on essayait de retranscrire :p

Et encore, maintenant qu'on a des compilateurs qui acceptent des fichiers encodés en Unicode, on devrait s'estimer heureux de ne pas tomber sur des noms de variable en lettres grecques :p

Mais oui, si c'est pour autre chose que retranscrire des maths, il vaut mieux éviter les "i", "j" et compagnie, et choisir des noms explicites.

[Matt_Houston]

Suis le conseil donné par ce post, à savoir : laisse tomber l'écriture multi-dimensionnelle qui n'apporte que de la confusion et quelques incongruités (la cache-friendliness et le coût de sérialisation d'un float *** font pas bander..). Si les dimensions de la matrice à représenter sont W, H et D alors il te suffit d'obtenir de quoi stocker W * H * D valeurs, à adresser sur une seule dimension. À moins que tes algorithmes de traitement requièrent une représentation particulière (regroupement par blocs voisins), c'est l'approche à privilégier.

Exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void update_cells(float *v, size_t w, size_t h, size_t d) {
    for (size_t k = 0u; k < d; ++k)
        for (size_t j = 0u; j < h; ++j)
            for (size_t i = 0u; i < w; ++i, ++v)
                *v = update_cell(*v, i, j, k);
}
 
/* ... */
 
float *matrix = calloc(w * h * d, sizeof *matrix);
assert(matrix);
update_cells(matrix, w, h, d);
 
// ...

Tu auras noté qu'on peut difficilement faire plus simple comme parcours.


Le reste, c'est du bon sens. J'ajouterais aux remarques qui t'ont déjà été faites :

• calcule une seule fois les valeurs des termes constants et stocke les résultats dans des variables intermédiaires ;
• n'utilise pas pow - qui est conçue pour effectuer des calculs complexes - lorsque tes exposants sont entiers, écris x * x * ... * x en lieu et place de pow(x, n) ;
• profile ton programme afin d'identifier le coût d'exécution de chaque sous-section.