#include <stdio.h>
#include <stdlib.h>
#include "matrice.h"

/*
   Crée une nouvelle matrice de n lignes et m colonnes, dont les éléments
   sont initialement nuls.
   Retourne un pointeur vers la matrice créée, ou NULL en cas d'erreur.
*/

matrice *creer_matrice(unsigned n, unsigned m)
{
  matrice *r;
  unsigned i, j;

  r = malloc(sizeof(matrice));
  if (!r)
    return NULL;

  r -> el = malloc(n * sizeof(double *));
  if (!(r -> el))
    {
      free(r);
      return NULL;
    }

  for (i = 0; i < n; i++)
    {
      r -> el[i] = malloc(m * sizeof(double));
      if (!(r -> el[i]))
        {
          for (j = 0; j < i; j++)
            free(r -> el[j]);
          free(r -> el);
          free(r);
          return NULL;
        }

      for (j = 0; j < m; j++)
        r -> el[i][j] = 0.0;
    }

  r -> n = n;
  r -> m = m;

  return r;
}

/*
   Libère l'espace mémoire occupé par la matrice m.
*/

void liberer_matrice(matrice *m)
{
  unsigned i;

  for (i = 0; i < m -> n; i++)
    free(m -> el[i]);

  free(m -> el);
  free(m);
}

/*
   Calcule la somme de deux matrices a et b. Retourne un pointeur vers
   une nouvelle matrice contenant cette somme, ou le pointeur vide en
   cas d'erreur.
*/

matrice *somme_matrices(const matrice *a, const matrice *b)
{
  matrice *s;
  unsigned i, j;

  if (a -> n != b -> n || a -> m != b -> m)
    return NULL;

  s = creer_matrice(a -> n, a -> m);
  if (!s)
    return NULL;

  for (i = 0; i < a -> n; i++)
    for (j = 0; j < a -> m; j++)
      s -> el[i][j] = a -> el[i][j] + b -> el[i][j];

  return s;
}

/*
   Calcule le produit de deux matrices a et b. Retourne un pointeur
   vers une nouvelle matrice contenant ce produit, ou le pointeur
   vide en cas d'erreur.
*/

matrice *produit_matrices(const matrice *a, const matrice *b)
{
  matrice *p;
  unsigned i, j, k;

  if (a -> m != b -> n)
    return NULL;

  p = creer_matrice(a -> n, b -> m);
  if (!p)
    return NULL;

  for (i = 0; i < a -> n; i++)
    for (j = 0; j < b -> m; j++)
      for (k = 0; k < a -> m; k++)
        p -> el[i][j] += a -> el[i][k] * b -> el[k][j];

  return p;
}