Équation du centre de gravité en langage C

La version en langage C de l'équation du centre de gravité se divise en trois parties :

• le programme principal qui appelle la routine de calcul de centre de gravité;
• la sous-routine de calcul des coordonnées X et Y du centre de gravité d'une surface plane;
• la sous-routine de calcul des pentes et ordonnées à l'origine d'une surface plane.

Exemple de progamme principal

   
/*****************************************************************************\
| PROGRAMME : QUELCONQUE
| Description : Programme permettant de...
| ****************************************************************************
|  Variables :  dim : Nombre de coordonnées de la surface plane
|               xy  : Coordonnées X et Y de la surface
|               ctr : Coordonnées X et Y du centroïde
\*****************************************************************************/
main () {
	int n;
	double xy[2] [18000], ctr[2];
	
	n = 4;
	xy[0] [0] = 543564;
	xy[1] [0] = 5678654;
	xy[0] [1] = 543735;
	xy[1] [1] = 5678943;
	xy[0] [2] = 543423;
	xy[1] [2] = 5678679;
	xy[0] [3] = 543564;
	xy[1] [3] = 5678654;
	
	centroid (n-1, xy, ctr);
	
	printf("%f\n",ctr[0]);  /* Affichage de la coordonnée X du centre de gravité */
	printf("%f\n",ctr[1]);  /* Affichage de la coordonnée Y du centre de gravité */
}
    

Routine de calcul du centre de gravité

/*****************************************************************************\
| ROUTINE : centroid
| Description : Cette routine retourne le centroïde d'une surface fermée
|               à partir de vecteurs de pente (pente), d'ordonnées à l'origine 
|               (ord), de débuts et de fins de coordonnées X (x1, x2).
|*****************************************************************************
| Variables d'entrée :   dim   : Nombre de coordonnées de la surface
|                        xy    : Coordonnées X et Y de la surface
| Variables de sortie :  ctr   : Coordonnées X et Y du centroïde
| Arguments :            pente : Vecteur de pentes
|                        ord   : Vecteur d'ordonnées à l'origine
|                        x1    : X de début d'un segment
|                        X2    : X de fin d'un segment
\*****************************************************************************/
centroid (int dim, double xy[2] [18000], double ctr[2]) {
	int    i;
	double x1[18000], x2[18000];
	double pente[18000], ord[18000];
	double m1, m2, m3;
	double a, mx, my, suma, summx, summy;
	
	/* début du traitement */
	
	suma  = 0;
	summx = 0;
	summy = 0;
	
	pente_ord (dim, xy, pente, ord, x1, x2);
	
	for (i = 0; i < dim; i++) {
	   m3 = (x2[i]*x2[i]*x2[i])-(x1[i]*x1[i]*x1[i]);
	   m2 = (x2[i]*x2[i])-(x1[i]*x1[i]);
	   m1 = x2[i]-x1[i];
	   mx = ((pente[i]*pente[i])*m3/6)+(((ord[i]*pente[i])*m2)/2) 
	                + (((ord[i]*ord[i])*m1)/2);
	   my = ((pente[i]*m3)/3)+((ord[i]*m2)/2);
	   a  = ((pente[i]/2)*m2)+(ord[i]*m1);
	   suma = suma + a;
	   summx = summx + mx;
	   summy = summy + my;
	   }
	
	/* calcul du centroïde */
	
	ctr[0] = summy/suma;    /* x du centroïde */
	ctr[1] = summx/suma;    /* y du centroïde */
}
    

Subroutine that calculates the slopes and y-intercepts of a plane region

/*****************************************************************************\
| ROUTINE: pente_ord
| Description: Routine permettant de calculer un vecteur de pentes et
|              d'ordonnées à l'origine de segments constituant une surface
|              fermée.
|*****************************************************************************
| Variables d'entrée :   dim   : Nombre de coordonnées de la surface
|                        xy    : Coordonnées X et Y de la surface
| Variables de sortie :  pente : Vecteur de pentes
|                        ord   : Vecteur d'ordonnées à l'origine
|                        x1    : X de début d'un segment
|                        x2    : X de fin d'un segment
| Arguments :            i     : Variable de travail
|                        y1    : Y de début d'un segment
|                        y2    : Y de fin d'un segment
\*****************************************************************************/
pente_ord ( int dim, double xy[2] [18000], double pente[18000], 
            double ord[18000], double x1[18000], double x2[18000]) {
	int i;
	double y1[18000], y2[18000];
	
	/* transfert des coordonnées de la surface */
	
	for (i = 0; i < dim-1; i++) {
	   x1[i] = xy[0] [i];
	   y1[i] = xy[1] [i];
	   x2[i] = xy[0] [i+1];
	   y2[i] = xy[1] [i+1];
	   }
	
	x1[dim-1] = xy[0] [dim-1];
	y1[dim-1] = xy[1] [dim-1];
	x2[dim-1] = xy[0] [0];
	y2[dim-1] = xy[1] [0];
	
	/* calcul des pentes et des ordonnées à l'origine */
	
	for (i = 0; i < dim; i++) {
	   if (x1[i] == x2[i]) {
	      pente[i] = 0;
	      ord[i] = 0;
	   }
	   else {
	      pente[i] = (y2[i] - y1[i]) / (x2[i] - x1[i]);
	      ord[i]   = ((x1[i] * y2[i]) - (x2[i] * y1[i])) / (x1[i] - x2[i]);
	   }
    }
}