/*
Titre: Laboratoire7
Description: Ce programme regrouppe un ensemble de fonctions en guise de solution 
			 du laboratoire 7.

Auteur: Anis Boubaker
Date: 2018-02-23
*/

/***********COMMANDES PRÉPROCESSEUR*************/
#define _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include <stdio.h>
#include <float.h>
#include <math.h>

/***********CONSTANTES DE COMPILATION*************/
#define TAILLE_MAX 100

/********* DÉCLARATIONS DES FONCTION **************/
/*
Fonction: afficher_matrice_entier
Description: Affiche une matrice d'entiers de taille nb_lignes x nb_colonnes
Paramètres:
- tab: Tableau à 2 dimensions d'entiers
- nb_lignes (entier): Nombre de lignes de la matrice
- nb_colonnes (entier): Nombre de colonnes de la matrice
Retour: Aucun
Paramètres modifiés: Aucun
*/
void afficher_matrice_entier(int tab[][TAILLE_MAX], int nb_lignes, int nb_colonnes);

/*
Fonction: afficher_matrice_double
Description: Affiche une matrice de réels de taille nb_lignes x nb_colonnes
Paramètres:
- tab: Tableau à 2 dimensions de réels (double)
- nb_lignes (entier): Nombre de lignes de la matrice
- nb_colonnes (entier): Nombre de colonnes de la matrice
Retour: Aucun
Paramètres modifiés: Aucun
*/
void afficher_matrice_double(double tab[][TAILLE_MAX], double nb_lignes, int nb_colonnes);

/*
Fonction: somme_elements
Description: Calcule la somme de tous les éléments d'un tableau
Paramètres:
- tab: Tableau à 2 dimensions d'entiers
- nb_lignes (entier): Nombre de lignes de la matrice
- nb_colonnes (entier): Nombre de colonnes de la matrice
Retour: (entier) Somme de tous les éléments
Paramètres modifiés: Aucun
*/
int somme_elements(int tab[][TAILLE_MAX], int nb_lignes, int nb_colonnes);

/*
Fonction: somme_diagonale
Description: Calcule la somme de la diagonale d'une matrice carrée
Paramètres:
- tab: Tableau à 2 dimensions d'entiers
- taille_matrice (entier): Nombre de lignes / colonnes de la matrice.
Retour: (entier) Somme de la diagonale
Paramètres modifiés: Aucun
*/
int somme_diagonale(int tab[][TAILLE_MAX], int taille_matrice);

/*
Fonction: compter_occurences
Description: Calcule le nombre d'occurences d'un élément dans un tableau
Paramètres:
- tab: Tableau à 2 dimensions d'entiers
- nb_lignes (entier): Nombre de lignes de la matrice
- nb_colonnes (entier): Nombre de colonnes de la matrice
- a_trouver (entier): Élément dont on veut compter le nombre d'occurences
Retour: (entier) Nombre d'occurence de a_trouver dans le tableau
Paramètres modifiés: Aucun
*/
int compter_occurences(int tab[][TAILLE_MAX], int nb_lignes, int nb_cols, int a_trouver);

/*
Fonction: additionner_matrices
Description: Additionne deux matrices de la même taille dans une matrice résultat
Paramètres:
- mat1: Tableau à 2 dimensions de réels à additionner
- mat2: Tableau à 2 dimensions de réels à additionner
- resultat: Tableau à 2 dimensions de réels qui stockera le résultat
- nb_lignes (entier): Nombre de lignes de la matrice
- nb_colonnes (entier): Nombre de colonnes de la matrice
Retour: (Aucun
Paramètres modifiés: resultat
*/
void additionner_matrices(
	double mat1[][TAILLE_MAX],
	double mat2[][TAILLE_MAX],
	double resultat[][TAILLE_MAX],
	int nb_lignes,
	int nb_colonnes);

/*
Fonction: sont_egales
Description: Vérifie si 2 matrices sont égales et retourne vrai si c'est le cas, ou faux sinon.
Paramètres:
- mat1: Tableau à 2 dimensions de réels
- mat2: Tableau à 2 dimensions de réels
- nb_lignes (entier): Nombre de lignes de la matrice
- nb_colonnes (entier): Nombre de colonnes de la matrice
Retour: (entier) Valeur vraie si mat1==mat2, et valeur fausse sinon
Paramètres modifiés: Aucun
*/
int sont_egales(
	double mat1[][TAILLE_MAX],
	double mat2[][TAILLE_MAX],
	int nb_lignes,
	int nb_colonnes);

/*
Fonction: calculer_transposee
Description: Calcule la transposée d'une matrice
Paramètres:
- mat: Tableau à 2 dimensions de réels à transposer
- transposee: Tableau à 2 dimensions de réels qui stockera le résultat
- nb_lignes (entier): Nombre de lignes de la matrice
- nb_colonnes (entier): Nombre de colonnes de la matrice
Retour: Aucun
Paramètres modifiés: transposee
*/
void calculer_transposee(
	double mat[][TAILLE_MAX],
	double transposee[][TAILLE_MAX],
	int nb_lignes,
	int nb_colonnes);

/*
Fonction: calculer_distance
Description: Calcule la distance entre deux points (x1,y1) et (x2,y2)
Paramètres:
- x1: (entier) abscisse du premier point
- y1: (entier) ordonnées du premier point
- x2: (entier) abscisse du second point
- y2: (entier) ordonnées du second point
Retour: (réel) Distance entre les deux points
Paramètres modifiés: Aucun
*/
double calculer_distance(int x1, int y1, int x2, int y2);

/*
Fonction: distance_minimale
Description: Trouve la distance minimale entre un ensemble de points donnés
Paramètres:
- points: Tableau de points, chaque point a deux colonnes: l'abscisse et l'ordonnées
- nb_points: Le nombre de points du tableau.
Retour: (réel) Distance minimale entre les points du tableau points
Paramètres modifiés: Aucun
*/
double distance_minimale(int points[][2], int nb_points);

/*
Fonction: main
*/

int main(void)
{
	//déclaration de variables
	int mon_tab1[6][TAILLE_MAX] = { { 2,5,2,3,1 },{ 0,4,2,2 },{ 6,9,2,1,3 } };
	int mon_tab2[6][TAILLE_MAX] = { { 3,5,2,6,8,7}, {2,8,1,3}, {3,9},{ 9, 8, 6,4}, {8}, {1,5,7,2,3,9} };
	
	int points[5][2] = { {0,1}, {3,5}, {2,9}, {10,4}, {8,9} };
	
	double mon_tab_d1[6][TAILLE_MAX] = { { 2,5.1,2,3,1 },{ 0,4,2,2 },{ 6,9,2,1,3 } };
	double mon_tab_d2[6][TAILLE_MAX] = { { 3,5,2,6,8,7 },{ 2,8,1,3 },{ 3,9 },{ 9, 8, 6,4 },{ 8 },{ 1,5,7,2,3,9 } };
	double resultat[6][TAILLE_MAX];
	double transposee[6][TAILLE_MAX];

	printf("Tableau: \n");
	afficher_matrice_entier(mon_tab1, 6, 6);

	printf("\n**Question 1: somme des elements\n");
	printf("Somme = %d\n", somme_elements(mon_tab1, 6, 6));
	system("pause");

	printf("\n**Question 2: somme de la diagonale\n");
	printf("Somme diagonale = %d\n", somme_diagonale(mon_tab1, 6));
	system("pause");

	printf("\n**Question 3: Compter occurences\n");
	printf("Nb occurences de 2 : %d\n", compter_occurences(mon_tab1, 6,6,2));
	system("pause");
	

	printf("\n**Question 4: Somme matrices\n");
	printf("Matrice 1: \n");
	afficher_matrice_double(mon_tab_d1, 6, 6);
	printf("Matrice 2: \n");
	afficher_matrice_double(mon_tab_d2, 6, 6);
	additionner_matrices(mon_tab_d1, mon_tab_d2, resultat, 6, 6);
	printf("Somme Matrice1 + Matrice 2: \n");
	afficher_matrice_double(resultat, 6, 6);
	system("pause");

	printf("\n**Question 6: Transposee de matrices\n");
	printf("Matrice: \n");
	afficher_matrice_double(mon_tab_d1, 6, 6);
	calculer_transposee(mon_tab_d1, transposee, 6, 6);
	printf("Transposee: \n");
	afficher_matrice_double(transposee, 6, 6);
	system("pause");

	printf("\n**Question 7: Distance minimale\n");
	printf("Distance minimale: %.2f \n", distance_minimale(points, 5));

	system("pause");
	return EXIT_SUCCESS;
}


/********* IMPLÉMENTATIONS DES FONCTION **************/

void afficher_matrice_entier(int tab[][TAILLE_MAX], int nb_lignes, int nb_colonnes)
{
	int i, j;
	for (i = 0; i < nb_lignes; i++)
	{
		for (j = 0; j < nb_colonnes; j++)
		{
			printf("%d ", tab[i][j]);
		}
		printf("\n");
	}
}

void afficher_matrice_double(double tab[][TAILLE_MAX], double nb_lignes, int nb_colonnes)
{
	int i, j;
	for (i = 0; i < nb_lignes; i++)
	{
		for (j = 0; j < nb_colonnes; j++)
		{
			printf("%.1f ", tab[i][j]);
		}
		printf("\n");
	}
}

int somme_elements(int tab[][TAILLE_MAX], int nb_lignes, int nb_colonnes)
{
	int i,
		j; //Compteurs de boucles
	int somme = 0; //Accumulateur des sommes 

	for (i = 0; i < nb_lignes; i++)
	{
		for (j = 0; j < nb_colonnes; j++)
		{
			somme += tab[i][j];
		}
	}
	return somme;
}

int somme_diagonale(int tab[][TAILLE_MAX], int taille_matrice)
{
	int somme = 0; //accumulateur de la somme
	int i; //compteur de boucle

	for (i = 0; i < taille_matrice; i++)
	{
		somme += tab[i][i];
	}
	return somme;
}

int compter_occurences(int tab[][TAILLE_MAX], int nb_lignes, int nb_cols, int a_trouver)
{
	int i, j; //Compteurs de boucle
	int nb_occurences = 0; //Compte le nombre d'occurences de a_trouver

	for (i = 0; i < nb_lignes; i++)
	{
		for (j = 0; j < nb_cols; j++)
		{
			if (tab[i][j] == a_trouver)
			{
				nb_occurences++;
			}
		}
	}
	return nb_occurences;
}

void additionner_matrices(
	double mat1[][TAILLE_MAX],
	double mat2[][TAILLE_MAX],
	double resultat[][TAILLE_MAX],
	int nb_lignes,
	int nb_colonnes)
{
	int i, j; //Compteurs de boucles
	for (i = 0; i < nb_lignes; i++)
	{
		for (j = 0; j < nb_colonnes; j++)
		{
			resultat[i][j] = mat1[i][j] + mat2[i][j];
		}
	}
}

int sont_egales(double mat1[][TAILLE_MAX],
	double mat2[][TAILLE_MAX],
	int nb_lignes,
	int nb_colonnes)
{
	int i, j; //Compteurs de boucles
	for (i = 0; i < nb_lignes; i++)
	{
		for (j = 0; i < nb_colonnes; j++)
		{
			if (mat1[i][j] != mat2[i][j])
			{
				return 0;
			}
		}
	}
	return 1;
}

void calculer_transposee(
	double mat[][TAILLE_MAX],
	double transposee[][TAILLE_MAX],
	int nb_lignes,
	int nb_colonnes)
{
	int i, j;
	for (i = 0; i < nb_lignes; i++)
	{
		for (j = 0; j < nb_colonnes; j++)
		{
			transposee[j][i] = mat[i][j];
		}
	}
}

double calculer_distance(int x1, int y1, int x2, int y2)
{
	double distance; //Stocke la distance calculee

	distance = pow(x1 - x2, 2);
	distance += pow(y1 - y2, 2);
	distance = sqrt(distance);

	return distance;
}

double distance_minimale(int points[][2], int nb_points)
{
	int i, j; //Compteurs de boucle
	double distance; //Stocke la distance entre deux points
	double distance_min = DBL_MAX; //Stocke la distance minimale trouvée.
								   //NDE: DBL_MAX est une constante définie dans la 
								   //librairie float.h.

								   //On calcule la distance entre points[0] et tous les autres, et on retient le 
								   //minimum. Ensuite on calcule la distance entre point[1] et les suivants (donc
								   //en excluant points[0]), et on retient le minimum, etc.
	for (i = 0; i < nb_points - 1; i++)
	{
		for (j = i + 1; j < nb_points; j++)
		{
			distance = calculer_distance(points[i][0], points[i][1], points[j][0], points[j][1]);
			if (distance < distance_min)
			{
				distance_min = distance;
			}
		}
	}
	return distance_min;
}