La Matriz Abstracta no Polimorfica:
 Todo Clases Namespaces Archivos Funciones Variables 'typedefs' Amigas 'defines'
Clases | Funciones
Referencia del Namespace Mx

Matriz chirrisquitica de adolf.nosp@m.o@di.nosp@m.-mare.nosp@m..com. Más...

Clases

class  Matrix_BASE
 Esta es la plantilla base para las implementacion de la clase matriz chirrisquitica. Más...
class  Matrix_Dense
 Esta es una clase matriz muy chirrisquitica que puede cambiar dinámicamente de tamaño. Más...
class  Matrix_List_ColVal
 Clase privada para implementar la lista de valores de cada fila. Más...
class  Matrix_List
 Matriz muy chirrisquitica almacenada como matriz rala implementada con listas. Más...
class  Matrix_Sparse
 Matriz chirrisquitica almacenada como una matriz rala. Más...

Funciones

template<class MAT >
bool check_ok_Matrix (const MAT &M)
 Verificación genérica de la invariante de la clase check_ok().
template<class MAT >
unsigned count_Matrix (const MAT &M)
 Implementación por defecto para Matrix_BASE<E>::count()
template<class MAT >
void clear_Matrix (MAT &M)
 Implementación por defecto para Matrix_BASE<E>::clear()
template<class MAT >
bool equals_Matrix (const MAT &A, const MAT &B)
 Implementación por defecto para Matrix_BASE<E>::operator==()
template<class MAT >
void add_Matrix (MAT &Res, const MAT &M)
 Implementación por defecto para operator+( Matrix_BASE<E>&, Matrix_BASE<E> )
template<class MAT >
void substract_Matrix (MAT &Res, const MAT &M)
 Implementación por defecto para operator-( Matrix_BASE<E>&, Matrix_BASE<E> )
template<class MAT >
void multiply_Matrix (MAT &Res, const MAT &A, const MAT &B)
 Calcula la multiplicación A * B y almacena el resultado en "Res".
template<class MAT >
MAT::reference at_Matrix (MAT &M, unsigned i, unsigned j)
 Implementación por defecto para Matrix_BASE<E>::at()
template<class MAT >
MAT::const_reference at_Matrix (const MAT &M, unsigned i, unsigned j)
 Implementación por defecto para Matrix_BASE<E>::at() const.
template<class MAT >
MAT operator+ (const Matrix_BASE< typename MAT::value_type > &A, const MAT &B)
 A+B
template<class MAT >
MAT operator- (const Matrix_BASE< typename MAT::value_type > &A, const MAT &B)
 A-B
template<class MAT >
MAT operator* (const Matrix_BASE< typename MAT::value_type > &A, const MAT &B)
 Res=A*B
template<class MAT >
bool operator== (const Matrix_BASE< typename MAT::value_type > &A, const MAT &B)
 ¿¿¿ (A == B) ???
template<class MAT >
bool operator!= (const Matrix_BASE< typename MAT::value_type > &A, const MAT &B)
 ¿¿¿ (A != B) ???
template<class MAT >
bool isSquare (const MAT &M)
 Retorna "true" si la matriz M[][] es una matriz cuadrada.
template<class MAT >
bool isDiagonal (const MAT &M)
 Retorna "true" si la matriz M[][] es una matriz diagonal.
template<class MAT >
bool isScalar (const MAT &M)
 Retorna "true" si la matriz M[][] es escalar.
template<class MAT >
bool isUnit (const MAT &M)
 Retorna "true" si la matriz M[][] es unitaria.
template<class MAT >
void setUnit (const MAT &M, unsigned n)
 Convierte a M[][] en una matriz identidad de tamaño n x n.
template<class MAT >
bool isNull (const MAT &M)
 Retorna "true" si la matriz M[][] es nula.
template<class MAT >
bool isSymmetric (const MAT &M)
 Retorna "true" si la matriz M[][] es simétrica.
template<class MAT >
bool isUpperTiangular (const MAT &M)
 Retorna "true" si la matriz M[][] es triangular superior.
template<class MAT >
bool isLowerTiangular (const MAT &M)
 Retorna "true" si la matriz M[][] es triangular inferior.
template<class T >
bool check_ok (const Matrix_Dense< T > &M)
 Verifica la invariante de la clase.
template<class T >
void add_Matrix (Matrix_Dense< T > &Res, const Matrix_Dense< T > &M)
 Implementación por defecto para operator+( Matrix_BASE<E>&, Matrix_BASE<E> )
template<class T >
bool check_ok (const Matrix_List< T > &M)
 Verificación genérica de la invariante de la clase check_ok().
template<class T >
bool check_ok (const Matrix_Sparse< T > &M)
 Verifica la invariante de la clase.
template<class T >
void add_Matrix (Matrix_Sparse< T > &Res, const Matrix_Sparse< T > &M)
 Implementación por defecto para operator+( Matrix_BASE<E>&, Matrix_BASE<E> )

Descripción detallada

Matriz chirrisquitica de adolf.nosp@m.o@di.nosp@m.-mare.nosp@m..com.

Documentación de las funciones

template<class MAT >
bool Mx::check_ok_Matrix ( const MAT &  M)

Verificación genérica de la invariante de la clase check_ok().

Comentarios:
Libera al programador de implementar el método Ok()
  • check_ok(): (M.rows() == 0) <==> (M.cols() == 0)

Definición en la línea 140 del archivo Matrix_BASE.h.

template<class MAT >
unsigned Mx::count_Matrix ( const MAT &  M)

Implementación por defecto para Matrix_BASE<E>::count()

Definición en la línea 167 del archivo Matrix_BASE.h.

template<class MAT >
void Mx::clear_Matrix ( MAT &  M)

Implementación por defecto para Matrix_BASE<E>::clear()

Definición en la línea 178 del archivo Matrix_BASE.h.

template<class MAT >
bool Mx::equals_Matrix ( const MAT &  A,
const MAT &  B 
)

Implementación por defecto para Matrix_BASE<E>::operator==()

Definición en la línea 190 del archivo Matrix_BASE.h.

template<class MAT >
void Mx::add_Matrix ( MAT &  Res,
const MAT &  M 
)

Implementación por defecto para operator+( Matrix_BASE<E>&, Matrix_BASE<E> )

Precondición:
  • "*this" y "M" deben tener las mismas dimensiones.
  • rows() == M.rows() && cols() == M.cols() .
Comentarios:
  • Esta es la implementación para Matrix_BASE<E> operator+( Matrix_BASE<E>&, Matrix_BASE<E> ) .
  • El compilador tiene problemas en compilar un función amiga ("friend") definida con plantillas si esa función amiga no está definida (implementada) dentro de la declaración de la clase. Para solventar esta deficiencia existe esta función que realiza el trabajo, aunque es poco cómodo de usar.

Definición en la línea 239 del archivo Matrix_BASE.h.

template<class MAT >
void Mx::substract_Matrix ( MAT &  Res,
const MAT &  M 
)

Implementación por defecto para operator-( Matrix_BASE<E>&, Matrix_BASE<E> )

Definición en la línea 259 del archivo Matrix_BASE.h.

template<class MAT >
void Mx::multiply_Matrix ( MAT &  Res,
const MAT &  A,
const MAT &  B 
)

Calcula la multiplicación A * B y almacena el resultado en "Res".

  • Las dimensiones de "*this" se ajustan de manera que:
    Res.rows() == A.rows() && Res.cols() == B.cols()
  • Esta es la implementación de Matrix_BASE<E> operator*() .
Precondición:
  • "A" y "B" deben tener dimensiones compatibles.
  • A.cols() == B.rows() .
  • La multiplicación se hace [Fila x Columna], lo que implica que la cantidad de valores en la filas de "A" debe ser igual a la cantidad de columnas de "B".
Complejidad:
O( A.cols() * B.cols() * A.cols() )

Definición en la línea 307 del archivo Matrix_BASE.h.

template<class MAT >
MAT::reference Mx::at_Matrix ( MAT &  M,
unsigned  i,
unsigned  j 
)

Implementación por defecto para Matrix_BASE<E>::at()

Definición en la línea 335 del archivo Matrix_BASE.h.

template<class MAT >
MAT::const_reference Mx::at_Matrix ( const MAT &  M,
unsigned  i,
unsigned  j 
)

Implementación por defecto para Matrix_BASE<E>::at() const.

Definición en la línea 354 del archivo Matrix_BASE.h.

template<class MAT >
MAT Mx::operator+ ( const Matrix_BASE< typename MAT::value_type > &  A,
const MAT &  B 
) [inline]

A+B

Definición en la línea 368 del archivo Matrix_BASE.h.

template<class MAT >
MAT Mx::operator- ( const Matrix_BASE< typename MAT::value_type > &  A,
const MAT &  B 
) [inline]

A-B

Definición en la línea 448 del archivo Matrix_BASE.h.

template<class MAT >
MAT Mx::operator* ( const Matrix_BASE< typename MAT::value_type > &  A,
const MAT &  B 
) [inline]

Res=A*B

Definición en la línea 454 del archivo Matrix_BASE.h.

template<class MAT >
bool Mx::operator== ( const Matrix_BASE< typename MAT::value_type > &  A,
const MAT &  B 
) [inline]

¿¿¿ (A == B) ???

Definición en la línea 460 del archivo Matrix_BASE.h.

template<class MAT >
bool Mx::operator!= ( const Matrix_BASE< typename MAT::value_type > &  A,
const MAT &  B 
) [inline]

¿¿¿ (A != B) ???

Definición en la línea 466 del archivo Matrix_BASE.h.

template<class MAT >
bool Mx::isSquare ( const MAT &  M)

Retorna "true" si la matriz M[][] es una matriz cuadrada.

Definición en la línea 32 del archivo Matrix_Lib.h.

template<class MAT >
bool Mx::isDiagonal ( const MAT &  M)

Retorna "true" si la matriz M[][] es una matriz diagonal.

Definición en la línea 43 del archivo Matrix_Lib.h.

template<class MAT >
bool Mx::isScalar ( const MAT &  M)

Retorna "true" si la matriz M[][] es escalar.

Definición en la línea 68 del archivo Matrix_Lib.h.

template<class MAT >
bool Mx::isUnit ( const MAT &  M) [inline]

Retorna "true" si la matriz M[][] es unitaria.

Definición en la línea 89 del archivo Matrix_Lib.h.

template<class MAT >
void Mx::setUnit ( const MAT &  M,
unsigned  n 
)

Convierte a M[][] en una matriz identidad de tamaño n x n.

Definición en la línea 102 del archivo Matrix_Lib.h.

template<class MAT >
bool Mx::isNull ( const MAT &  M)

Retorna "true" si la matriz M[][] es nula.

Definición en la línea 121 del archivo Matrix_Lib.h.

template<class MAT >
bool Mx::isSymmetric ( const MAT &  M)

Retorna "true" si la matriz M[][] es simétrica.

Definición en la línea 141 del archivo Matrix_Lib.h.

template<class MAT >
bool Mx::isUpperTiangular ( const MAT &  M)

Retorna "true" si la matriz M[][] es triangular superior.

Definición en la línea 163 del archivo Matrix_Lib.h.

template<class MAT >
bool Mx::isLowerTiangular ( const MAT &  M)

Retorna "true" si la matriz M[][] es triangular inferior.

Definición en la línea 187 del archivo Matrix_Lib.h.

template<class T >
bool Mx::check_ok ( const Matrix_Dense< T > &  M)

Verifica la invariante de la clase. 

{{  // Rep ==> Diagrama de la clase
    +---+                                         /         \
    | 2 |  M(i,j) ==> m_val[ (i * m_cols) + j ]   | 0 1 2 3 |   m_rows == 2
    +---+  (almacenamiento por filas)             | 4 5 6 7 |   m_cols == 4
    | 4 |                                         \         /
    +---+   +---+---+---+---+---+---+---+---+
    | *-|-->| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
    +---+   +---+---+---+---+---+---+---+---+

    +---+
    | 4 |  M(i,j) ==> m_val[ i + (j * m_rows) ]   / a e \
    +---+  (almacenamiento por columnas)          | b f |   m_rows == 4
    | 2 |                                         | c g |   m_cols == 2
    +---+   +---+---+---+---+---+---+---+---+     \ d h /
    | *-|-->| a | b | c | d | e | f | g | h |
    +---+   +---+---+---+---+---+---+---+---+
}}
Comentarios:
Libera al programador de implementar el método Ok()

  • check_ok(): (M.m_rows == 0) <==> (M.m_cols == 0)

Definición en la línea 140 del archivo Matrix_Dense.h.

template<class T >
void Mx::add_Matrix ( Matrix_Dense< T > &  Res,
const Matrix_Dense< T > &  M 
)

Implementación por defecto para operator+( Matrix_BASE<E>&, Matrix_BASE<E> )

Precondición:
  • "*this" y "M" deben tener las mismas dimensiones.
  • rows() == M.rows() && cols() == M.cols() .
Comentarios:
  • Esta es la implementación para Matrix_BASE<E> operator+( Matrix_BASE<E>&, Matrix_BASE<E> ) .
  • El compilador tiene problemas en compilar un función amiga ("friend") definida con plantillas si esa función amiga no está definida (implementada) dentro de la declaración de la clase. Para solventar esta deficiencia existe esta función que realiza el trabajo, aunque es poco cómodo de usar.

Definición en la línea 394 del archivo Matrix_Dense.h.

template<class T >
bool Mx::check_ok ( const Matrix_List< T > &  M)

Verificación genérica de la invariante de la clase check_ok().

Comentarios:
Libera al programador de implementar el método Ok()
Verifica la invariante de la clase. 

- El campo \c m_same indica cuál es el valor que se repite más en toda la matriz.
- Usualmente \c m_same es el neutro aditivo \c value_type().
- No existe un constructor explícito para darle a \c m_same su valor inicial, que
  es siempre inicializado en \c value_type(). Para cambiarlo es necesario invocar
  el método \c setgetDefault().
- El vector \c m_VL[] contiene las listas de valores almacenados en la matriz.
  Cualquiera de estas listas puede estar vacía; aún todas pueden ser listas vacías.
- La cantidad de columnas de la matriz es el valor fijo es \c m_cols.
- El largo de las listas de valores cambia cuando se hace referencia a un valor M(i,j)
  mediante la versión que no es \c const del \c operator()(i,j). O sea, que es
  ese método el encargado de agregar valores en \c m_VL[], pues el operador
  homónimo \c const operator()(i,j) nunca agrega nada y, como es \c const, en
  general retorna una referencia constante a \c m_same.
- Es posible que la matriz tenga dimensiones nulas, lo que implica que el vector
  \c m_VL[] está vacío.
- No hace falta alacenar la cantidad de valores de la matriz porque se siempre es
  \c m_VL.size().
  el valor \c 0 (cero) al campo \c m_capacity.

\par <em>Rep</em> Modelo de la clase

m_VL<list<>>  _______
    +---+    /       \
  0 | *-|---| 1 , 'a' |
    +---+    \_______/                      0 1 2 3 4 5 6
  1 | ? |   M(0,1)=='a'                 0 / - a - - - - - \
    +---+                               1 | - - - - - - - |
  2 | ? |     _______       _______     2 | - - - - - - - |
    +---+    /       \     /       \    3 | - c - - - b - |
  3 | *-|---| 5 , 'b' |---| 1 , 'c' |   4 \ - - - - - - - /
    +---+    \_______/     \_______/
  4 | ? |   M(3,5)=='b'   M(3,1)=='c'
    +---+
        m_same == '-'    rows() == m_VL.size()  m_cols == 7

Definición en la línea 187 del archivo Matrix_List.h.

template<class T >
bool Mx::check_ok ( const Matrix_Sparse< T > &  M)

Verifica la invariante de la clase. 

- El campo \c m_same indica cuál es el valor que se repite más en toda la matriz.
- Usualmente \c same es el neutro aditivo \c value_type().
- No existe un constructor explícito para darle a \c m_same su valor inicial, que
  es siempre inicializado en \c value_type(). Para cambiarlo es necesario invocar
  el método \c setgetDefault().
- Los vectores \c m_I[], \c m_J[] y \c m_val[] son vectores paralelos, todos de
  longitud \c Matrix_Sparse::m_capacity.
- La cantidad máxima de valores diferente que pueden ser almacenados en la matriz
  es \c Matrix_Sparse::m_capacity.
- El largo de estos vectores aumenta cuando se hace referencia a un valor M(i,j)
  mediante la versión que no es \c const del \c operator()(i,j). O sea, que es
  ese método el encargado de agregar valores en \c m_val[], pues el operador
  homónimo \c const operator()(i,j) nunca agrega nada y, como es \c const, en
  general retorna una referencia constante a \c m_same.
- Es posible que la matriz tenga dimensiones nulas, lo que implica que todos los
  punteros a los vectors paralelos deben ser nulos. Este hecho se marca dándolo
  el valor \c 0 (cero) al campo \c m_capacity.
- En todos los algoritmos, "m" o "m_rows" es la cantidad de filas == \c rows()
- En todos los algoritmos, "n" o "m_cols" es la cantidad de columnas == \c cols()

\par <em>Rep</em> Modelo de la clase

         ____________________________________
        /          m_capacity                \
        +---+---+---+---+---+---+-..-+---+---+       0 1 2 3 4 5 6
 m_I--->| 1 | 3 | 3 |'-'| ...       ...  |'-'|   0 / - - - - - - - \
        +---+---+---+---+ ...       ...  +---+   1 | - a - - - - - |
 m_J--->| 1 | 2 | 1 |'-'| ...       ...  |'-'|   2 | - - - - - - - |
        +---+---+---+---+ ...       ...  +---+   3 | - c b - - - - |
m_val-->|'a'|'b'|'c'|'-'| ...       ...  |'-'|   4 \ - - - - - - - /
        +---+---+---+---+---+---+-..-+---+---+
          0   1   2   |
        m_size--------+ == 3    m_same == '-'   m_rows == 5  m_cols == 7
  • check_ok(): ( (0<=m_I[k]) && (m_I[k] < m_rows) ) k = [0..m_size-1]
  • check_ok(): ( (0<=m_J[k]) && (m_J[k] < m_cols) ) k = [0..m_size-1]

Definición en la línea 141 del archivo Matrix_Sparse.h.

template<class T >
void Mx::add_Matrix ( Matrix_Sparse< T > &  Res,
const Matrix_Sparse< T > &  M 
)

Implementación por defecto para operator+( Matrix_BASE<E>&, Matrix_BASE<E> )

Precondición:
  • "*this" y "M" deben tener las mismas dimensiones.
  • rows() == M.rows() && cols() == M.cols() .
Comentarios:
  • Esta es la implementación para Matrix_BASE<E> operator+( Matrix_BASE<E>&, Matrix_BASE<E> ) .
  • El compilador tiene problemas en compilar un función amiga ("friend") definida con plantillas si esa función amiga no está definida (implementada) dentro de la declaración de la clase. Para solventar esta deficiencia existe esta función que realiza el trabajo, aunque es poco cómodo de usar.

Definición en la línea 652 del archivo Matrix_Sparse.h.

Generado el Viernes, 25 de Mayo de 2012 10:10:46 para La Matriz Abstracta no Polimorfica: por   doxygen 1.8.0