#include "matriz.h"


#define naoimplementada(funcao) printf(">%s<--> Nao implementada\n",funcao);
#define new(type,count) (type *) calloc(count,sizeof(type))
#define alocaverifica(elemento,tipo,numero,nfuncao) if ( (elemento = new(tipo,numero)) == NULL) comTrataErro(MSG1,nfuncao);

/************************************************************** 

   #Funcão#: #matCria#
   #Autor#: #Gustavo Sverzut Barbieri#
   #Data#: #23/08/2001#
   #Descrição#: #
                 Aloca espaco de memoria para uma matriz com nl linhas e nc colunas.
		 Deve testar se existe memoria livre antes de alocar o espaco. tome
		 como exemplo o vetCria para ajuda-lo. A funcao deve devolver
		 um apontador para a matriz vazia.
		#
   #Parâmetros#:
     #entrada#: 
        #nl#: #numero de linhas#
        #nc#: #numero de colunas#
     #saida#: #nenhum#
   #Retorno#: #Apontador para 'Matriz'#  
   #Modificação#: 
     #data#: #99/99/9999#
     #autor#: #<nome de quem fez a modificação>#
     #descrição#: #<descrição da modificação>#

**************************************************************/
Matriz *matCria(int nl, int nc) {
  Matriz *m = NULL;
  int i;
  
  alocaverifica(m,Matriz,1,"matCria")
  else {
    alocaverifica(m->info,int *,nl,"matCria");
    m->nl=nl; m->nc=nc;
    for (i=0; i<nl; i++)
      alocaverifica(m->info[i],int,nc,"matCria")
  }
  return(m);
}

/************************************************************** 

   #Funcão#: #matlCria#
   #Autor#: #Gustavo Sverzut Barbieri#
   #Data#: #23/08/2001#
   #Descrição#: #
                 Aloca espaco de memoria para uma matriz com nl linhas e nc colunas.
		 Deve testar se existe memoria livre antes de alocar o espaco. tome
		 como exemplo o vetCria para ajuda-lo. A funcao deve devolver
		 um apontador para a matriz vazia.
		 Obs: ESTRUTURA LINEAR (vide matriz.h, estrutura MatrizL)
		#
   #Parâmetros#:
     #entrada#: 
        #nl#: #numero de linhas#
        #nc#: #numero de colunas#
     #saida#: #nenhum#
   #Retorno#: #Apontador para 'MatrizL'#  
   #Modificação#: 
     #data#: #99/99/9999#
     #autor#: #<nome de quem fez a modificação>#
     #descrição#: #<descrição da modificação>#

**************************************************************/
MatrizL *matlCria(int nl, int nc) {
  MatrizL *ml = NULL;
  int i,j=0;
  alocaverifica(ml,MatrizL,1,"matlCria")
  else {
    alocaverifica(ml->info, int, nl*nc, "matlCria");
    alocaverifica(ml->tblin, int, nl, "matlCria");
    ml->nl=nl; ml->nc=nc;
    for (i=0; i<(nl*nc); i+=nc)
      ml->tblin[j++] = i;
  }
  return(ml);
}


/************************************************************** 

   #Funcão#: #matDestroi#
   #Autor#: #Gustavo Sverzut Barbieri#
   #Data#: #23/08/2001#
   #Descrição#: #
                 Deve liberar o espaco utilizado por uma matriz. Nao retorna nada. 
		#
   #Parâmetros#:
     #entrada#: 
        #m#: #matriz a ser destruida#
     #saida#: #nenhum#
   #Retorno#: #nenhum#  
   #Modificação#: 
     #data#: #99/99/9999#
     #autor#: #<nome de quem fez a modificação>#
     #descrição#: #<descrição da modificação>#
**************************************************************/
void  matDestroi(Matriz *m) {
  int i;
  if ( m == NULL)
    comAviso(AVS1,"matDestroi");
  else {
    for (i=0; i < m->nl; i++)
      if ( m->info[i] == NULL )
	comAviso(AVS1,"matDestroi");
      else
	free(m->info[i]);
    free(m);
  }
}

/************************************************************** 

   #Funcão#: #matlDestroi#
   #Autor#: #Gustavo Sverzut Barbieri#
   #Data#: #23/08/2001#
   #Descrição#: #
                 Deve liberar o espaco utilizado por uma matriz. Nao retorna nada. 
		 OBS.: ESTRUTURA LINEAR. (Vide estrutura MatrizL em matriz.h)
		#
   #Parâmetros#:
     #entrada#: 
        #m#: #matriz a ser destruida#
     #saida#: #nenhum#
   #Retorno#: #nenhum#  
   #Modificação#: 
     #data#: #99/99/9999#
     #autor#: #<nome de quem fez a modificação>#
     #descrição#: #<descrição da modificação>#
**************************************************************/
void  matlDestroi(MatrizL *m) {
  if ( m == NULL )
    comAviso(AVS1,"matlDestroi");
  else {
    if (m->tblin == NULL)
      comAviso(AVS1,"matlDestroi");
    else
      free(m->tblin);
    if (m->info == NULL)
      comAviso(AVS1,"matlDestroi");
    else
      free(m->info);
    free(m);
  }
}

/************************************************************** 

   #Funcão#: #matSoma#
   #Autor#: #Gustavo Sverzut Barbieri#
   #Data#: #23/08/2001#
   #Descrição#: #
                 Soma duas matrizes(se possivel), retornando um
		   apontador para a matriz com o resultado.
		 As matrizes nao deverao ser nulas e deverao ser 
		   de mesmo tamanho.
		 Se alguma matriz for NULA, 'AVS1' sera impressa 
		   como saida.
		 Se as matrizes forem de tamanhos diferentes, 
		   'AVSMAT1' sera impressa como saida. (vide 
		   matriz.h e comon.h para 'AVS1' e 'AVSMAT1')
		 Se a soma nao for possivel, retorna-se NULL.
		 Nenhuma matriz passada sera modificada.
		#
   #Parâmetros#:
     #entrada#: 
        #m1#: #matriz a ser somada#
	#m2#: #matriz a ser somada#
     #saida#: #nenhum#
   #Retorno#: #Apontador para Matriz com resultado da soma#  
   #Modificação#: 
     #data#: #99/99/9999#
     #autor#: #<nome de quem fez a modificação>#
     #descrição#: #<descrição da modificação>#
**************************************************************/
Matriz *matSoma(Matriz *m1, Matriz *m2) {
  Matriz *m = NULL;
  int i,j;
  if ((m1 == NULL) || (m2 == NULL)) {
    comAviso(AVS1,"matSoma");
    return NULL;
  }
  if ((m1->nc != m2->nc) || (m1->nl != m2->nl)) {
    comAviso(AVSMAT1,"matSoma");
    return NULL;
  }
  m = matCria(m1->nl, m1->nc); /* Nao precisa conferir, pois
				  se nao conseguir alocar
				  memoria, o programa 
				  termina */
  
  for (i=0; i < m1->nl; i++)
    for (j=0; j < m2->nc; j++)
      m->info[i][j] = m1->info[i][j] + m2->info[i][j];
  
  return m;

}

/************************************************************** 

   #Funcão#: #matlSoma#
   #Autor#: #Gustavo Sverzut Barbieri#
   #Data#: #23/08/2001#
   #Descrição#: #
                 Soma duas matrizes(se possivel), retornando um
		   apontador para a matriz com o resultado.
		 As matrizes nao deverao ser nulas e deverao ser 
		   de mesmo tamanho.
		 Se alguma matriz for NULA, 'AVS1' sera impressa 
		   como saida.
		 Se as matrizes forem de tamanhos diferentes, 
		   'AVSMAT1' sera impressa como saida. (vide 
		   matriz.h e comon.h para 'AVS1' e 'AVSMAT1')
		 Se a soma nao for possivel, retorna-se NULL.
		 Nenhuma matriz passada sera modificada.
		 OBS.: ESTRUTURA LINEAR. (Vide estrutura MatrizL
		   em matriz.h)
		#
   #Parâmetros#:
     #entrada#: 
        #m1#: #matriz a ser somada#
	#m2#: #matriz a ser somada#
     #saida#: #nenhum#
   #Retorno#: #Apontador para MatrizL com resultado da soma#  
   #Modificação#: 
     #data#: #99/99/9999#
     #autor#: #<nome de quem fez a modificação>#
     #descrição#: #<descrição da modificação>#
**************************************************************/
MatrizL *matlSoma(MatrizL *m1, MatrizL *m2) {
  MatrizL *m = NULL;
  int i;
  if ((m1 == NULL) || (m2 == NULL)) {
    comAviso(AVS1,"matlSoma");
    return NULL;
  }
  if ((m1->nc != m2->nc) || (m1->nl != m2->nl)) {
    comAviso(AVSMAT1,"matlSoma");
    return NULL;
  }
  m = matlCria(m1->nl, m1->nc);
  for (i=0; i < (m1->nl * m1->nc); i++)
      m->info[i] = m1->info[i] + m2->info[i];

  return m;
}


/************************************************************** 

   #Funcão#: #matMultiplica#
   #Autor#: #Gustavo Sverzut Barbieri#
   #Data#: #23/08/2001#
   #Descrição#: #
                 Multiplica duas matrizes(se possivel), 
		   retornando um apontador para a matriz com o
		   resultado.
		 Se alguma matriz for nula, sera impresso 'AVS1'
		   como saida.
		 Se as matrizes nao forem compativeis para a
		   multiplicacao, sera impresso 'AVSMAT1' como
		   saida. (Vide matriz.h e comum.h para 'AVS1'
		   e 'AVSMAT1')
		#
   #Parâmetros#:
     #entrada#: 
        #m1#: #matriz a ser Multiplicada#
	#m2#: #matriz a ser Multiplicada#
     #saida#: #nenhum#
   #Retorno#: #Apontador para Matriz com resultado da multiplicacao#  
   #Modificação#: 
     #data#: #99/99/9999#
     #autor#: #<nome de quem fez a modificação>#
     #descrição#: #<descrição da modificação>#
**************************************************************/
Matriz *matMultiplica(Matriz *m1, Matriz *m2) {
  Matriz *m = NULL;
  int i,j,k;

  if ((m1 == NULL) || (m2 == NULL)) {
    comAviso(AVS1,"matMultiplica");
    return NULL;
  }
  if ( m1->nc != m2->nl ) {
    comAviso(AVSMAT1,"matMultiplica");
    return NULL;
  }
  m = matCria(m1->nl, m2->nc);
  for (i=0; i < m1->nl; i++)
    for (j=0; j < m2->nc; j++) {
      m->info[i][j] = 0;
      for (k=0; k < m1->nc; k++)
	m->info[i][j] += m1->info[i][k] * m2->info[k][j];
    }
  
  return m;
}

/************************************************************** 
   #Funcão#: #matlMultiplica#
   #Autor#: #Gustavo Sverzut Barbieri#
   #Data#: #23/08/2001#
   #Descrição#: #
                 Multiplica duas matrizes(se possivel), 
		   retornando um apontador para a matriz com o
		   resultado.
		 Se alguma matriz for nula, sera impresso 'AVS1'
		   como saida.
		 Se as matrizes nao forem compativeis para a
		   multiplicacao, sera impresso 'AVSMAT1' como
		   saida. (Vide matriz.h e comum.h para 'AVS1'
		   e 'AVSMAT1')
		 OBS.: ESTRUTURA LINEAR. (Vide estrutura MatrizL
		   em matriz.h)
		#
   #Parâmetros#:
     #entrada#: 
        #m1#: #matriz a ser Multiplicada#
	#m2#: #matriz a ser Multiplicada#
     #saida#: #nenhum#
   #Retorno#: #Apontador para MatrizL com resultado da multiplicacao#  
   #Modificação#: 
     #data#: #99/99/9999#
     #autor#: #<nome de quem fez a modificação>#
     #descrição#: #<descrição da modificação>#
**************************************************************/
MatrizL *matlMultiplica(MatrizL *m1, MatrizL *m2) {
  MatrizL *m = NULL;
  int i,j,k;

  if ((m1 == NULL) || (m2 == NULL)) {
    comAviso(AVS1,"matlMultiplica");
    return NULL;
  }
  if ( m1->nc != m2->nl ) {
    comAviso(AVSMAT1,"matlMultiplica");
    return NULL;
  }
  m = matlCria(m1->nl, m2->nc);

  for (i=0; i < m1->nl; i++)
    for (j=0; j < m2->nc; j++) {
      m->info[matlInd(m,i,j)] = 0;
      for (k=0; k < m1->nc; k++)
	m->info[matlInd(m,i,j)] += m1->info[matlInd(m1,i,k)] * m2->info[matlInd(m2,k,j)];
    }
  
  return m;

}

/************************************************************** 
   #Funcão#: #matTransposta#
   #Autor#: #Gustavo Sverzut Barbieri#
   #Data#: #23/08/2001#
   #Descrição#: #
                 Acha a transposta da matriz e retorna o
		   apontador para esta.
		 Se a matriz for nula, imprime 'AVS1' e 
		   retorna nulo. (Vide comum.h p/ 'AVS1')
		#
   #Parâmetros#:
     #entrada#: 
        #m#: #matriz a ser Transposta#
     #saida#: #nenhum#
   #Retorno#: #Apontador para Matriz com a transposta#  
   #Modificação#: 
     #data#: #99/99/9999#
     #autor#: #<nome de quem fez a modificação>#
     #descrição#: #<descrição da modificação>#
**************************************************************/
Matriz *matTransposta(Matriz *m) { 
  Matriz *mt = NULL;
  int i,j;
  if (m == NULL)
    comAviso(AVS1,"matTransposta");
  else {
    mt = matCria(m->nc, m->nl);
    for (i=0; i < mt->nl; i++) 
      for (j=0; j < mt->nc; j++) 
	mt->info[i][j] = m->info[j][i];
  }
  return mt;
}

/************************************************************** 
   #Funcão#: #matlTransposta#
   #Autor#: #Gustavo Sverzut Barbieri#
   #Data#: #23/08/2001#
   #Descrição#: #
                 Acha a transposta da matriz e retorna o
		   apontador para esta.
		 Se a matriz for nula, imprime 'AVS1' e 
		   retorna nulo. (Vide comum.h p/ 'AVS1')
		 OBS.: ESTRUTURA LINEAR. (Vide estrutura MatrizL
		   em matriz.h)
		#
   #Parâmetros#:
     #entrada#: 
        #m#: #matriz a ser Transposta#
     #saida#: #nenhum#
   #Retorno#: #Apontador para MatrizL com a transposta#  
   #Modificação#: 
     #data#: #99/99/9999#
     #autor#: #<nome de quem fez a modificação>#
     #descrição#: #<descrição da modificação>#
**************************************************************/
MatrizL *matlTransposta(MatrizL *m) { 
  MatrizL *mt = NULL;
  int i,j;
  if (m == NULL)
    comAviso(AVS1,"matlTransposta");
  else {
    mt = matlCria(m->nc, m->nl);
    for (i=0; i < mt->nl; i++) 
      for (j=0; j < mt->nc; j++) {
	mt->info[matlInd(mt,i,j)] = m->info[matlInd(m,j,i)];
      }
  }
  return mt;
}


/************************************************************** 
   #Funcão#: #matEscala#
   #Autor#: #Gustavo Sverzut Barbieri#
   #Data#: #23/08/2001#
   #Descrição#: #
                 Multiplica a matriz por escalar e retorna a 
		   matriz escalonada.
		 Se a matriz for nula, imprime-se 'AVS1' como
		   saida. (Vide comum.h p/ 'AVS1')
		 Nenhum dos parametros sera modificado.
		#
   #Parâmetros#:
     #entrada#: 
        #m#: #matriz a ser Escalonada#
	#x#: #inteiro#
     #saida#: #nenhum#
   #Retorno#: #Apontador para Matriz escalonada#  
   #Modificação#: 
     #data#: #99/99/9999#
     #autor#: #<nome de quem fez a modificação>#
     #descrição#: #<descrição da modificação>#
**************************************************************/
Matriz *matEscala(Matriz *m, int x) { 
  Matriz *me = NULL;
  int i,j;

  if (m == NULL)
    comAviso(AVS1,"matEscala");
  else {
    me = matCria(m->nl,m->nc);
    for (i=0; i < m->nl; i++)
      for (j=0; j < m->nc; j++)
	me->info[i][j] = m->info[i][j] * x;
  }
  return me;
}

/************************************************************** 
   #Funcão#: #matlEscala#
   #Autor#: #Gustavo Sverzut Barbieri#
   #Data#: #23/08/2001#
   #Descrição#: #
                 Multiplica a matriz por escalar e retorna a 
		   matriz escalonada.
		 Se a matriz for nula, imprime-se 'AVS1' como
		   saida. (Vide comum.h p/ 'AVS1')
		 Nenhum dos parametros sera modificado.
		 OBS.: ESTRUTURA LINEAR.
		#
   #Parâmetros#:
     #entrada#: 
        #m#: #matriz a ser Escalonada#
	#x#: #inteiro#
     #saida#: #nenhum#
   #Retorno#: #Apontador para MatrizL escalonada#  
   #Modificação#: 
     #data#: #99/99/9999#
     #autor#: #<nome de quem fez a modificação>#
     #descrição#: #<descrição da modificação>#
**************************************************************/
MatrizL *matlEscala(MatrizL *m, int x) { 
  MatrizL *me = NULL;
  int i;

  if (m == NULL)
    comAviso(AVS1,"matlEscala");
  else {
    me = matlCria(m->nl,m->nc);
    for (i=0; i < (m->nl * m->nc); i++)
      me->info[i] = m->info[i] * x;
  }
  return me;
}