La Matriz Abstracta no Polimorfica:
 Todo Clases Namespaces Archivos Funciones Variables 'typedefs' Amigas 'defines'
Tipos públicos | Métodos públicos | Métodos protegidos | Métodos privados | Atributos privados | Amigas
Referencia de la plantilla de la Clase Mx::Matrix_Sparse< E >

Matriz chirrisquitica almacenada como una matriz rala. Más...

#include <Matrix_Sparse.h>

Diagrama de herencias de Mx::Matrix_Sparse< E >
Mx::Matrix_BASE< E >

Lista de todos los miembros.

Tipos públicos

typedef E value_type
 Tipo del objeto almacenado, similar al nombre usado en STL.
typedef value_typereference
 Referencia al objeto almacenado, similar al nombre usado en STL.
typedef const value_typeconst_reference
 Referencia constante al objeto almacenado, similar al nombre usado en STL.

Métodos públicos

 Matrix_Sparse (unsigned m=1, unsigned n=1)
 Constructor de vector.
 Matrix_Sparse (const Matrix_Sparse &o)
 Matrix_Sparse (const E &V)
 Constructor escalar.
 ~Matrix_Sparse ()
 Destructor.
unsigned rows () const
 Cantidad de filas de la matriz.
unsigned cols () const
 Cantidad de columnas de la matriz.
unsigned size () const
 Cantidad de valores almacenados en la matriz.
unsigned count () const
 Sinónimo de size().
unsigned capacity () const
 Cantidad máxima posible de valores diferentes que pueden ser almacenados en la matriz.
Matrix_Sparseoperator= (const Matrix_Sparse &M)
Matrix_Sparsecopy (const Matrix_Sparse &M)
 Copia desde "o".
Matrix_Sparsemove (Matrix_Sparse &M)
 Traslada el valor de "o" a "*this".
Matrix_Sparseswap (Matrix_Sparse &M)
 Intercambia los valores de "*this" y "o".
void clear ()
 Deja el valor de "*this" en el valor en que lo inicializa el constructor de vector.
bool equals (const Matrix_Sparse &M) const
E & operator() (unsigned i, unsigned j)
 Retorna una referencia al elemento [i,j] de la matriz.
const E & operator() (unsigned i, unsigned j) const
 Retorna una referencia al elemento [i,j] de la matriz ( const ).
E & at (unsigned i, unsigned j)
 Retorna una referencia al elemento [i][j] de la matriz.
const E & at (unsigned i, unsigned j) const
 Retorna una referencia constante al elemento [i][j] de la matriz [CONST].
void reShape (unsigned m, unsigned n)
 Le ajusta las dimensiones a la matriz.
void reSize (unsigned m, unsigned n)
 Le cambia las dimensiones a la matriz.
void transpose ()
 Transforma la matriz en su transpuesta.
void setDefault (const E &same)
 Define el escalar que por defecto está en todas las entradas de la Matrix_Sparse.
const E & getDefault ()
 Valor almacenado en la mayor parte de la matriz.
bool same (const Matrix_BASE &M) const
 Retorna true si "M" comparte su valor con "*this".

Métodos protegidos

Matrix_BASEcopy (const Matrix_BASE &M)
 Copia desde "M".
Matrix_BASEmove (Matrix_BASE &M)
 Traslada el valor de "M" a "*this".
Matrix_BASEswap (Matrix_BASE &M)
 Intercambia los valores de "*this" y "M".
bool equals (const Matrix_BASE &M) const
 ¿¿¿ A == B ???

Métodos privados

void reserve (unsigned _Count)
 Ajusta la matriz para que pueda almacenar n valores diferentes a getDefault().
void reSize (unsigned newsize)
 Le cambia el tamaño máximo posible a la matriz.

Atributos privados

unsigned * m_I
 Indice "i" de M(i,j) 0 <= i < m_capacity
unsigned * m_J
 Indice "j" de M(i,j) 0 <= i < m_capacity
E * m_val
 Valor para M(i,j) 0 <= i < m_capacity
unsigned m_size
 Cantidad de valores insertados en los 3 vectores paralelos.
unsigned m_capacity
 Tamaño de los 3 vectores paralelos.
unsigned m_rows
 Cantidad de filas de la matriz.
unsigned m_cols
 Cantidad de columnas de la matris.
m_same
 Valor almacenado en la mayor parte de la Matrix_Sparse.

Amigas

class test_Matrix
 BUnit Test.
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> )
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 >
bool check_ok_Matrix (const MAT &M)
 Verificación genérica de la invariante de la clase check_ok().
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 >
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.

Descripción detallada

template<class E>
class Mx::Matrix_Sparse< E >

Matriz chirrisquitica almacenada como una matriz rala.

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


Documentación de los 'Typedef' miembros de la clase

template<class E>
Mx::Matrix_BASE< E >::value_type [inherited]

Tipo del objeto almacenado, similar al nombre usado en STL.

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

template<class E>
Mx::Matrix_BASE< E >::reference [inherited]

Referencia al objeto almacenado, similar al nombre usado en STL.

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

template<class E>
Mx::Matrix_BASE< E >::const_reference [inherited]

Referencia constante al objeto almacenado, similar al nombre usado en STL.

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


Documentación del constructor y destructor

template<class E >
Mx::Matrix_Sparse< E >::Matrix_Sparse ( unsigned  m = 1,
unsigned  n = 1 
) [inline]

Constructor de vector.

  • Obtiene suficiente memoria dinámica para almacenas los n * m valores de la matriz.
  • Si "value_type" tiene un constructor de vector, lo usar para inicializar cada uno de los valores de la matriz; de lo contrario, los deja tal cual están en la memoria.
  • Si "value_type" es uno de los tipos escalares básicos, como lo son int o float, los valores almacenados en la matriz quedan tal cual están y no son inicializados.
    Precondición:
    • m * n > 0
    • (m > 0) && (n > 0)

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

template<class E >
Mx::Matrix_Sparse< E >::Matrix_Sparse ( const Matrix_Sparse< E > &  o) [inline]

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

template<class E>
Mx::Matrix_Sparse< E >::Matrix_Sparse ( const E &  V) [inline]

Constructor escalar.

  • La matriz es escalar de dimensiones 1x1 y valor "V".

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

template<class E >
Mx::Matrix_Sparse< E >::~Matrix_Sparse ( ) [inline]

Destructor.

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


Documentación de las funciones miembro

template<class E>
unsigned Mx::Matrix_Sparse< E >::rows ( ) const [inline]

Cantidad de filas de la matriz.

Reimplementado de Mx::Matrix_BASE< E >.

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

template<class E>
unsigned Mx::Matrix_Sparse< E >::cols ( ) const [inline]

Cantidad de columnas de la matriz.

Reimplementado de Mx::Matrix_BASE< E >.

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

template<class E>
unsigned Mx::Matrix_Sparse< E >::size ( ) const [inline]

Cantidad de valores almacenados en la matriz.

Reimplementado de Mx::Matrix_BASE< E >.

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

template<class E>
unsigned Mx::Matrix_Sparse< E >::count ( ) const [inline]

Sinónimo de size().

Reimplementado de Mx::Matrix_BASE< E >.

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

template<class E>
unsigned Mx::Matrix_Sparse< E >::capacity ( ) const [inline]

Cantidad máxima posible de valores diferentes que pueden ser almacenados en la matriz.

Reimplementado de Mx::Matrix_BASE< E >.

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

template<class E>
Matrix_Sparse& Mx::Matrix_Sparse< E >::operator= ( const Matrix_Sparse< E > &  M) [inline]

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

template<class E >
Matrix_Sparse< E > & Mx::Matrix_Sparse< E >::copy ( const Matrix_Sparse< E > &  M)

Copia desde "o".

  • Copia todo el valor de "o" sobre "*this", de forma que el nuevo valor de "*this" sea un duplicado exacto del valor de "o".
  • El valor anterior de "*this" se pierde.
  • El objeto "o" mantiene su valor anterior.
  • Luego de la copia, cuando el valor de "o" cambia, el de "*this" no cambiará, y viceversa, pues la copia es una copia profunda; no es superficial.
  • Si "*this" es "o" entonces su valor no cambia.
  • Después de esta operación siempre ocurre que *this == o .
Complejidad:
O( rows() * cols() )
Devuelve:
*this
Ver también:
http://www.di-mare.com/adolfo/binder/c04.htm#sc05

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

template<class E >
Matrix_Sparse< E > & Mx::Matrix_Sparse< E >::move ( Matrix_Sparse< E > &  M)

Traslada el valor de "o" a "*this".

  • El valor anterior de "*this" se pierde.
  • El nuevo valor de "*this" es el que "o" tuvo.
  • "o" queda en el estado en que lo dejaría Erase().
  • Si "*this" es "o" entonces su valor no cambia.
  • En general, después de esta operación casi nunca ocurre que (*this == o)

    Complejidad:
    O( rows() * cols() )
    Devuelve:
    *this
    Ver también:
    http://www.di-mare.com/adolfo/binder/c04.htm#sc07

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

template<class E >
Matrix_Sparse< E > & Mx::Matrix_Sparse< E >::swap ( Matrix_Sparse< E > &  M)

Intercambia los valores de "*this" y "o".

  • Debido a que algunos métodos retornan copias del valor de "*this" en lugar de una referencia, como ocurre con Matrix_Sparse::Child(), a veces swap() no tiene el resultado esperado por el programador.
  • Por ejemplo, si se invoca T.Child(i). swap( T.Child(j) ) el resultado no es intercambiar los hijos, sino más bien intercambiar los valores de los sub-árboles temporales T.Child(i) y T.Child(j). La forma correcta de intercambiar hijos es usar Graft().

    Complejidad:
    O( 1 )
    Devuelve:
    *this
    Ver también:
    http://www.di-mare.com/adolfo/binder/c04.htm#sc08

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

template<class E>
void Mx::Matrix_Sparse< E >::clear ( ) [inline]

Deja el valor de "*this" en el valor en que lo inicializa el constructor de vector.

Reimplementado de Mx::Matrix_BASE< E >.

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

template<class E>
bool Mx::Matrix_Sparse< E >::equals ( const Matrix_Sparse< E > &  M) const [inline]

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

template<class E >
E & Mx::Matrix_Sparse< E >::operator() ( unsigned  i,
unsigned  j 
) [inline]

Retorna una referencia al elemento [i,j] de la matriz.

  • M(i,j) significa lo que en arreglos se denota con M[i][j].
  • M(i,j) = val; // M(i,j) es un "lvalue" (modificable)

Reimplementado de Mx::Matrix_BASE< E >.

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

template<class E >
const E & Mx::Matrix_Sparse< E >::operator() ( unsigned  i,
unsigned  j 
) const [inline]

Retorna una referencia al elemento [i,j] de la matriz ( const ).

  • M(i,j) significa lo que en arreglos se denota con M[i][j].
  • val = M(i,j); // M(i,j) es un "rvalue" (const)

Reimplementado de Mx::Matrix_BASE< E >.

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

template<class E>
E& Mx::Matrix_Sparse< E >::at ( unsigned  i,
unsigned  j 
) [inline]

Retorna una referencia al elemento [i][j] de la matriz.

  • Vefica que en la matriz exista el valor de índices [i][j].
  • Si [i][j] está fuera de rango levanta una excepción de tipo std::out_of_range.
  • Esta referencia permite cambiar el valor almacenado.
  • M.at(i,j) = val; // M.at(i,j) es un "lvalue" (modificable)

Reimplementado de Mx::Matrix_BASE< E >.

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

template<class E>
const E& Mx::Matrix_Sparse< E >::at ( unsigned  i,
unsigned  j 
) const [inline]

Retorna una referencia constante al elemento [i][j] de la matriz [CONST].

  • Vefica que en la matriz exista el valor de índices [i][j].
  • Si [i][j] está fuera de rango levanta una excepción de tipo std::out_of_range.
  • Esta referencia solo permite leer el valor almacenado.
  • val = M.at(i,j); // M.at(i,j) es un "rvalue" (const)

Reimplementado de Mx::Matrix_BASE< E >.

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

template<class E >
void Mx::Matrix_Sparse< E >::reShape ( unsigned  m,
unsigned  n 
) [inline]

Le ajusta las dimensiones a la matriz.

  • Si ocurre que (m*n) == rows()*cols() hace lo mismo que haría reSize(m,n).
  • En caso contrario, no hace nada.

Reimplementado de Mx::Matrix_BASE< E >.

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

template<class E >
void Mx::Matrix_Sparse< E >::reSize ( unsigned  m,
unsigned  n 
)

Le cambia las dimensiones a la matriz.

Reimplementado de Mx::Matrix_BASE< E >.

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

template<class E>
void Mx::Matrix_Sparse< E >::transpose ( )

Transforma la matriz en su transpuesta.

Reimplementado de Mx::Matrix_BASE< E >.

template<class E >
void Mx::Matrix_Sparse< E >::setDefault ( const E &  same) [inline]

Define el escalar que por defecto está en todas las entradas de la Matrix_Sparse.

  • Si same != getDefault() la matriz queda vacía.
  • De lo contrario, nada ocurre.

Reimplementado de Mx::Matrix_BASE< E >.

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

template<class E>
const E& Mx::Matrix_Sparse< E >::getDefault ( ) [inline]

Valor almacenado en la mayor parte de la matriz.

Reimplementado de Mx::Matrix_BASE< E >.

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

template<class E>
void Mx::Matrix_Sparse< E >::reserve ( unsigned  _Count) [private]

Ajusta la matriz para que pueda almacenar n valores diferentes a getDefault().

template<class E >
void Mx::Matrix_Sparse< E >::reSize ( unsigned  newsize) [private]

Le cambia el tamaño máximo posible a la matriz.

  • Le aumenta la cantidad de valores diferentes a getDefault().
  • No hace nada cuando size() < newsize.

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

template<class E>
Matrix_BASE< E > & Mx::Matrix_BASE< E >::copy ( const Matrix_BASE< E > &  M) [protected, inherited]

Copia desde "M".

  • Copia todo el valor de "M" sobre "*this" de forma que el nuevo valor de "*this" sea un duplicado exacto del valor de "M".
  • El valor anterior de "*this" se pierde.
  • El objeto "M" mantiene su valor.
  • Luego de la copia, cuando el valor de "M" cambia, el de "*this" no cambiará, y viceversa, pues la copia es una copia profunda; no es superficial.
  • Si "*this" es "M" su valor no cambia.
  • Después de esta operación siempre es verdadero que *this == M .
Devuelve:
"*this"
Ver también:
http://www.di-mare.com/adolfo/binder/c04.htm#sc05
template<class E>
Matrix_BASE< E > & Mx::Matrix_BASE< E >::move ( Matrix_BASE< E > &  M) [protected, inherited]

Traslada el valor de "M" a "*this".

  • El valor anterior de "*this" se pierde
  • El nuevo valor de "*this" es el que "M" tuvo
  • "M" queda en el estado en que queda cualquier objeto cuando es inicializardo con el constructor de vector.
  • Si "*this" es "M" entonces su valor no cambia
  • En general, después de esta operación casi nunca ocurre que (*this == M)
Devuelve:
"*this"
Ver también:
http://www.di-mare.com/adolfo/binder/c04.htm#sc07
template<class E>
Matrix_BASE< E > & Mx::Matrix_BASE< E >::swap ( Matrix_BASE< E > &  M) [protected, inherited]

Intercambia los valores de "*this" y "M".

  • En muchas ocasiones toma menos tiempo esta operación que copy() o move().
Devuelve:
"*this"
Ver también:
http://www.di-mare.com/adolfo/binder/c04.htm#sc08
template<class E>
bool Mx::Matrix_BASE< E >::same ( const Matrix_BASE< E > &  M) const [inline, inherited]

Retorna true si "M" comparte su valor con "*this".

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

template<class E>
bool Mx::Matrix_BASE< E >::equals ( const Matrix_BASE< E > &  M) const [protected, inherited]

¿¿¿ A == B ???


Documentación de las funciones relacionadas y clases amigas

template<class E>
friend class test_Matrix [friend]

BUnit Test.

Reimplementado de Mx::Matrix_BASE< E >.

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

template<class E>
template<class T >
bool check_ok ( const Matrix_Sparse< T > &  M) [friend]

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 E>
template<class T >
void add_Matrix ( Matrix_Sparse< T > &  Res,
const Matrix_Sparse< T > &  M 
) [friend]

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.

template<class E>
template<class MAT >
bool check_ok_Matrix ( const MAT &  M) [friend, inherited]

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 E>
template<class MAT >
bool check_ok_Matrix ( const MAT &  M) [friend, inherited]

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 E>
template<class MAT >
MAT operator+ ( const Matrix_BASE< typename MAT::value_type > &  A,
const MAT &  B 
) [friend, inherited]

A+B

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

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

A-B

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

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

Res=A*B

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

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

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

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

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

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

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

template<class E>
template<class MAT >
unsigned count_Matrix ( const MAT &  M) [friend, inherited]

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

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

template<class E>
template<class MAT >
void clear_Matrix ( MAT &  M) [friend, inherited]

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

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

template<class E>
template<class MAT >
bool equals_Matrix ( const MAT &  A,
const MAT &  B 
) [friend, inherited]

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

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

template<class E>
template<class MAT >
void add_Matrix ( MAT &  Res,
const MAT &  M 
) [friend, inherited]

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 E>
template<class MAT >
void substract_Matrix ( MAT &  Res,
const MAT &  M 
) [friend, inherited]

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 E>
template<class MAT >
void multiply_Matrix ( MAT &  Res,
const MAT &  A,
const MAT &  B 
) [friend, inherited]

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 E>
template<class MAT >
MAT::reference at_Matrix ( MAT &  M,
unsigned  i,
unsigned  j 
) [friend, inherited]

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

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

template<class E>
template<class MAT >
MAT::const_reference at_Matrix ( const MAT &  M,
unsigned  i,
unsigned  j 
) [friend, inherited]

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

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


Documentación de los datos miembro

template<class E>
unsigned* Mx::Matrix_Sparse< E >::m_I [private]

Indice "i" de M(i,j) 0 <= i < m_capacity

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

template<class E>
unsigned* Mx::Matrix_Sparse< E >::m_J [private]

Indice "j" de M(i,j) 0 <= i < m_capacity

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

template<class E>
E* Mx::Matrix_Sparse< E >::m_val [private]

Valor para M(i,j) 0 <= i < m_capacity

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

template<class E>
unsigned Mx::Matrix_Sparse< E >::m_size [private]

Cantidad de valores insertados en los 3 vectores paralelos.

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

template<class E>
unsigned Mx::Matrix_Sparse< E >::m_capacity [private]

Tamaño de los 3 vectores paralelos.

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

template<class E>
unsigned Mx::Matrix_Sparse< E >::m_rows [private]

Cantidad de filas de la matriz.

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

template<class E>
unsigned Mx::Matrix_Sparse< E >::m_cols [private]

Cantidad de columnas de la matris.

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

template<class E>
E Mx::Matrix_Sparse< E >::m_same [private]

Valor almacenado en la mayor parte de la Matrix_Sparse.

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


La documentación para esta clase fue generada a partir del siguiente fichero: