matrice.cpp

Algorithme de multiplication de matrices traditionnel

////////////////////////////////////////////////////////////////////////////////
///
/// @file matrice.cpp
///
/// @author Marwan et Mehdi
///
////////////////////////////////////////////////////////////////////////////////
#include <fstream>
#include <iostream>
#include "matrice.h"

using namespace std;

////////////////////////////////////////////////////////////////////////////////
/// 
/// Constructeur de la matrice
///
/// @param[in] Size La taille de la matrice a creer
///
////////////////////////////////////////////////////////////////////////////////
matrice::matrice( unsigned int Size ):size(Size)
{
  // allocation espace non contigue
  allocate(size);
}


////////////////////////////////////////////////////////////////////////////////
/// 
/// Constructeur copie de la matrice
///
/// @param[in] C La matrice qui doit etre copiee
///
////////////////////////////////////////////////////////////////////////////////
matrice::matrice( const matrice &C ):size(C.size)
{
  allocate(size);
  for( unsigned int i=0; i<size; ++i )
    for( unsigned int j=0; j<size; ++j )
  	mat[i][j]=C.mat[i][j];
}


////////////////////////////////////////////////////////////////////////////////
/// 
/// Destructeur de la matrice
///
////////////////////////////////////////////////////////////////////////////////
matrice::~matrice( void )
{
  if( size == 0 )
    return;

  for( unsigned int i=0; i<size; ++i )
    delete []mat[i];

  delete []mat;
}


////////////////////////////////////////////////////////////////////////////////
///
/// M閠hode qui permet de charger une matrice a partir d'un fichier
///
/// @param[in] filename Le nom du fichier a lire.
///
////////////////////////////////////////////////////////////////////////////////
matrice::matrice( string filename ):size(0)
{
  // Chargement du fichier
  ifstream in( filename.c_str() );
  if( in.fail() )
  {
    cerr << "Fichier inconnu: " << filename << endl;
    in.close();
    return;
  }

  // Lecture de la taille
  string num;
  in >> num;
  size = strtoul(num.c_str(), NULL, 10);
  size = 1 << size;
  // Allocation de l'espace  
  allocate(size);

  // Remplissage du tableau  
  for( unsigned int i=0; i<size; ++i )
    for( unsigned int j=0; j<size; ++j )
    {
      in >> num;
      mat[i][j] = strtoul(num.c_str(), NULL, 10);
    }

  in.close();
}


////////////////////////////////////////////////////////////////////////////////
///
/// M閠hode qui alloue de l'espace pour pouvoir creer une matrice
///
/// @param[in] Size La taille de la matrice.
//
////////////////////////////////////////////////////////////////////////////////
void matrice::allocate( unsigned int n )
{
  mat = new int*[size];
  for( unsigned int i=0; i<size; ++i )
    	mat[i]= new int[size];
}


////////////////////////////////////////////////////////////////////////////////
///
/// Methode qui permet d'afficher la matrice a l'ecran
///
////////////////////////////////////////////////////////////////////////////////
void matrice::imprimer( ostream& o )const
{
  for( unsigned int i=0; i<size; ++i )
  {
    for( unsigned int j=0; j<size; ++j )
      o << mat[i][j] <<'\t';

    o << endl;
  }
}


////////////////////////////////////////////////////////////////////////////////
///
/// Surcharge de l'op閞ateur d'addition.
///
/// @param[in] rop La matrice a faire additionner de la matrice courante
///
/// @return La matrice courante apr鑣 la addition.
///
////////////////////////////////////////////////////////////////////////////////
matrice matrice::operator+(const matrice& rop)const
{
  matrice result(size);
  for( unsigned int i=0; i<size; ++i )
    for( unsigned int j=0; j<size; ++j )
      result.mat[i][j] = mat[i][j] + rop.mat[i][j];

  return result;
}


////////////////////////////////////////////////////////////////////////////////
///
/// Surcharge de l'op閞ateur de soustraction.
///
/// @param[in] rop La matrice a faire soustraire de la matrice courante
///
/// @return La matrice courante apr鑣 la soustraction.
///
////////////////////////////////////////////////////////////////////////////////
matrice matrice::operator-(const matrice& rop)const
{
  matrice result(size);
  for( unsigned int i=0; i<size; ++i )
    for( unsigned int j=0; j<size; ++j )
      result.mat[i][j] = mat[i][j] - rop.mat[i][j];

  return result;
}


////////////////////////////////////////////////////////////////////////////////
///
/// Surcharge de l'op閞ateur d'affectation.
///
/// @param[in] rop La matrice