#ifndef _MATRIZ_H_
#define _MATRIZ_H_

#include "comum.h" /* Observe que este include é desnecessário, pois
                      vetor.h já inclui comum.h. No entanto, a
                      declaração ifndef _COMUM_H usada em comum.h só
                      permitirá sua inclusão uma única vez. Assim não
                      haverá problema de múltiplas definições de
                      estruturas e operações. */
 
#include "vetor.h" /* necessário, pois uma das operações requer o tipo
                      Vetor como saída. */

/* Tipo abstrato Matriz : estrutura seqüencial e estática. Neste caso
   podemos observar que uma estrutura abstrata Imagem em tons de cinza
   poderia usar a mesma representação que Matriz, mas com operações
   diferentes (e.g. convolução, transformada de Fourier, equalização) 
*/

typedef struct matriz {
  int **info;   /* informação: vetor de vetores de inteiros */
  int nl,nc;    /* número de elementos na linha e na coluna, respectivamente*/
} Matriz;

/* Avisos especificos para matrizes. */

#define AVSMAT1 "Tamanhos incompativeis de matriz"
/* Utilize este aviso para operacoes que verificam se os tamanhos
   dos parametros estao corretos */

/* Operações sobre Matriz (alguns exemplos) */

Matriz *matCria(int nl, int nc);  /* Cria matriz vazia com capacidade
                           para armazenar nl elementos por linha e nc
                           elementos por coluna. */
void  matDestroi(Matriz *m); /* Destrói matriz. */  
Matriz *matTransposta(Matriz *m); /* Retorna a matriz transposta de m. */
Matriz *matMultiplica(Matriz *m1, Matriz *m2); /* Retorna a matriz
                                                  resultante da
                                                  multiplicação entre
                                                  as matrizes m1 e m2,
                                                  se a multiplicação
                                                  for possível, ou
                                                  NULL no caso
                                                  contrário. */
Matriz *matEscala(Matriz *m, int x); /* Retorna a matriz resultante
                                         da multiplicação entre a
                                         matriz m e um escalar inteiro
                                         x. */
Matriz *matSoma(Matriz *m1, Matriz *m2); /* Retorna a matriz
					    resultante da soma entre
					    as matrizes m1 e m2, se a
					    soma for possível, ou NULL
					    no caso contrário. */

/* Tipo abstrato Matriz (Implementação Linear): estrutura seqüencial e
   estática. */

typedef struct matrizl {
  int *info;   /* informação, vetor de inteiros */
  int nl,nc;    /* número de elementos na linha e na coluna, respectivamente*/
  int *tblin;   /* tabela de acesso rápido às linhas da matriz */
} MatrizL;

/* Macros para conversão linha,coluna para índice e vice-versa na
   implementação linear de matriz */

#define matlLin(m,i) (i / ((MatrizL *)m)->nc) 
#define matlCol(m,i) (i % ((MatrizL *)m)->nc)
#define matlInd(m,l,c) (c + ((MatrizL *)m)->tblin[l])

/* Operações sobre Matriz (implementação linear) - alguns exemplos */

MatrizL *matlCria(int nl, int nc);  /* Cria matriz vazia com capacidade
                           para armazenar nl elementos por linha e nc
                           elementos por coluna. */
void  matlDestroi(MatrizL *m); /* Destrói matriz. */  
MatrizL *matlTransposta(MatrizL *m); /* Retorna a matriz transposta de m. */
MatrizL *matlMultiplica(MatrizL *m1, MatrizL *m2); /* Retorna a matriz
                                                  resultante da
                                                  multiplicação entre
                                                  as matrizes m1 e m2,
                                                  se a multiplicação
                                                  for possível, ou
                                                  NULL no caso
                                                  contrário. */
MatrizL *matlEscala(MatrizL *m, int x); /* Retorna a matriz resultante
                                         da multiplicação entre a
                                         matriz m e um escalar inteiro
                                         x. */
MatrizL *matlSoma(MatrizL *m1, MatrizL *m2); /* Retorna a matriz
					    resultante da soma entre
					    as matrizes m1 e m2, se a
					    soma for possível, ou NULL
					    no caso contrário. */

#endif