Referencia de la Clase Mx::Sparse_Matrix< E >

Esta es una clase matriz muy chirrisquitica almacenada como una matriz rala. Más...

#include <Sparse_Matrix.h>

Lista de todos los miembros.

Tipos públicos
typedef E	value_type
	Tipo del objeto almacenado, similar al nombre usado en STL.
typedef value_type &	reference
	Tipo del objeto almacenado, similar al nombre usado en STL.
typedef const value_type &	const_reference
	Tipo del objeto almacenado, similar al nombre usado en STL.
typedef unsigned	size_type
	Tipo del tamaño de un objeto, similar al nombre usado en STL.
Métodos públicos
	Sparse_Matrix (unsigned m=1, unsigned n=1)
	Constructor de vector.
	Sparse_Matrix (const Sparse_Matrix &o)
	Constructor de copia.
	Sparse_Matrix (const value_type V)
	Constructor a partir de Sparse_Matrix<E>::value_type(V).
	~Sparse_Matrix ()
	Destructor.
unsigned	count () const
	Cantidad de valores almacenados en la matriz.
unsigned	size () const
	Cantidad de valores almacenados en la matriz.
unsigned	rows () const
	Cantidad de filas de la matriz.
unsigned	cols () const
	Cantidad de columnas de la Matriz.
size_type	capacity () const
	Cantidad máxima posible de valores diferentes que pueden ser almacenados en la matriz.
Sparse_Matrix &	operator= (const Sparse_Matrix &o)
	Sinónimo de this->copy(o).
Sparse_Matrix &	copy (const Sparse_Matrix &o)
	Copia desde "o".
Sparse_Matrix &	move (Sparse_Matrix &o)
	Traslada el valor de "o" a "*this".
Sparse_Matrix &	swap (Sparse_Matrix &o)
	Intercambia los valores de "*this" y "o".
bool	equals (const Sparse_Matrix &o) const
	¿¿¿ (*this==o) ???
bool	same (const Sparse_Matrix &o) const
	Retorna true si "o" comparte sus valores con "*this".
reference	operator() (unsigned, unsigned)
	Retorna una referencia al elemento [i,j] de la matriz.
const_reference	operator() (unsigned, unsigned) const
	Retorna una referencia al elemento [i,j] de la matriz ( const ).
void	reSize (unsigned, unsigned)
	Le cambia las dimensiones a la matriz.
void	reShape (unsigned, unsigned)
	Le ajusta las dimensiones a la matriz.
void	setDefault (const E &same)
	Define el escalar que por defecto está en todas las entradas de la Sparse_Matrix.
const E &	getDefault ()
	Valor almacenado en la mayor parte de la Sparse_Matrix.
void	reserve (size_type _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.
void	clear ()
	Borra todos los valores de la Sparse_Matrix.
Métodos privados
void	add (const Sparse_Matrix &)
	Le suma a "*this" la matriz "O".
void	substract (const Sparse_Matrix &)
	Le resta a "*this" la matriz "O".
void	multiply (const Sparse_Matrix &, const Sparse_Matrix &)
	Calcula la multiplicación A * B y la almacena en "*this".
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.
E	m_same
	Valor almacenado en la mayor parte de la Sparse_Matrix.
Amigas
class	test_Sparse_Matrix
	Datos de prueba para la clase.
bool	operator== (const Sparse_Matrix &p, const Sparse_Matrix &q)
	¿¿¿ (p == q) ???
bool	operator!= (const Sparse_Matrix &p, const Sparse_Matrix &q)
	¿¿¿ (p != q) ???
Sparse_Matrix	operator+ (const Sparse_Matrix &A, const Sparse_Matrix &B)
	Retorna A+B.
Sparse_Matrix	operator- (const Sparse_Matrix &A, const Sparse_Matrix &B)
	Retorna A-B.
Sparse_Matrix	operator * (const Sparse_Matrix &A, const Sparse_Matrix &B)
	Retorna A*B.
template<class T>
bool	check_ok (const Sparse_Matrix< T > &M)
	Verifica la invariante de la clase.

---

Descripción detallada

template<class E>
class Mx::Sparse_Matrix< E >

Esta es una clase matriz muy chirrisquitica almacenada como una matriz rala.

• La matriz tiene tamaño rows() x cols().
• Se le puede cambiar el tamaño dinámicamente con el método reSize().
• La clase E debe incluir un neutro para la adición, cuyo valor debe poderse obtener invocando el convertidor Sparse_Matrix<E>::value_type(0).
• Las operaciones aritméticas "+" "-" "*" deben estar definidas para Sparse_Matrix<E>::value_type y debe existir el valor Sparse_Matrix<E>::value_type(0).

  Ver también:

  http://www.oonumerics.org/oon/

Definición en la línea 33 del archivo Sparse_Matrix.h.

---

Documentación de los 'Tipos Definidos' miembros de la clase

template<class E> typedef E Mx::Sparse_Matrix< E >::value_type

Tipo del objeto almacenado, similar al nombre usado en STL. Definición en la línea 36 del archivo Sparse_Matrix.h.

template<class E> typedef value_type& Mx::Sparse_Matrix< E >::reference

Tipo del objeto almacenado, similar al nombre usado en STL. Definición en la línea 38 del archivo Sparse_Matrix.h.

template<class E> typedef const value_type& Mx::Sparse_Matrix< E >::const_reference

Tipo del objeto almacenado, similar al nombre usado en STL. Definición en la línea 40 del archivo Sparse_Matrix.h.

template<class E> typedef unsigned Mx::Sparse_Matrix< E >::size_type

Tipo del tamaño de un objeto, similar al nombre usado en STL. Definición en la línea 42 del archivo Sparse_Matrix.h.

---

Documentación del constructor y destructor

template<class E> Mx::Sparse_Matrix< E >::Sparse_Matrix (  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 240 del archivo Sparse_Matrix.h.

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

Constructor de copia. Definición en la línea 260 del archivo Sparse_Matrix.h.

template<class E> template< class E > inline Mx::Sparse_Matrix< E >::Sparse_Matrix (  const value_type  V  )  [inline]

Constructor a partir de Sparse_Matrix<E>::value_type(V). La matriz resultante es una matriz escalar, de dimensiones 1x1, y su valor es "V" Definición en la línea 47 del archivo Sparse_Matrix.h.

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

Destructor. Definición en la línea 282 del archivo Sparse_Matrix.h.

---

Documentación de las funciones miembro

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

Cantidad de valores almacenados en la matriz. Definición en la línea 50 del archivo Sparse_Matrix.h.

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

Cantidad de valores almacenados en la matriz. Definición en la línea 51 del archivo Sparse_Matrix.h.

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

Cantidad de filas de la matriz. Definición en la línea 52 del archivo Sparse_Matrix.h.

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

Cantidad de columnas de la Matriz. Definición en la línea 53 del archivo Sparse_Matrix.h.

template<class E> size_type Mx::Sparse_Matrix< E >::capacity (   )  const [inline]

Cantidad máxima posible de valores diferentes que pueden ser almacenados en la matriz. Definición en la línea 55 del archivo Sparse_Matrix.h.

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

Sinónimo de this->copy(o). Definición en la línea 57 del archivo Sparse_Matrix.h.

template<class E> Sparse_Matrix< E > & Mx::Sparse_Matrix< E >::copy (  const Sparse_Matrix< E > &  o  )

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 326 del archivo Sparse_Matrix.h.

template<class E> Sparse_Matrix< E > & Mx::Sparse_Matrix< E >::move (  Sparse_Matrix< E > &  o  )

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 388 del archivo Sparse_Matrix.h.

template<class E> Sparse_Matrix< E > & Mx::Sparse_Matrix< E >::swap (  Sparse_Matrix< E > &  o  )  [inline]

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 Sparse_Matrix::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 427 del archivo Sparse_Matrix.h.

template<class E> bool Mx::Sparse_Matrix< E >::equals (  const Sparse_Matrix< E > &  o  )  const

¿¿¿ (*this==o) ??? Definición en la línea 291 del archivo Sparse_Matrix.h.

template<class E> bool Mx::Sparse_Matrix< E >::same (  const Sparse_Matrix< E > &  o  )  const [inline]

Retorna true si "o" comparte sus valores con "*this". Definición en la línea 68 del archivo Sparse_Matrix.h.

template<class E> void Mx::Sparse_Matrix< E >::add (  const Sparse_Matrix< E > &  O  )  [private]

Le suma a "*this" la matriz "O". Precondición: "*this" y "O" deben tener las mismas dimensiones rows() == O.rows() && cols() == O.cols() Complejidad: O( rows() * cols() ) Comentarios: Esta es la implementación de Sparse_Matrix<E> operator+( Sparse_Matrix<E>&, Sparse_Matrix<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 este método que realiza el trabajo, aunque es poco cómodo de usar. Definición en la línea 702 del archivo Sparse_Matrix.h.

template<class E> void Mx::Sparse_Matrix< E >::substract (  const Sparse_Matrix< E > &  O  )  [private]

Le resta a "*this" la matriz "O". Precondición: "*this" y "O" deben tener las mismas dimensiones rows() == O.rows() && cols() == O.cols() Complejidad: O( rows() * cols() ) Comentarios: Esta es la implementación de Sparse_Matrix<E> operator-( Sparse_Matrix<E>&, Sparse_Matrix<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 este método que realiza el trabajo, aunque es poco cómodo de usar. Definición en la línea 736 del archivo Sparse_Matrix.h.

template<class E> void Mx::Sparse_Matrix< E >::multiply (  const Sparse_Matrix< E > &  A, const Sparse_Matrix< E > &  B )  [private]

Calcula la multiplicación A * B y la almacena en "*this". Las dimensiones de "*this" se ajustan de manera que: rows() == A.rows() && cols() == B.cols() 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() * A.capacity() * B.capacity() ) Comentarios: Esta es la implementación de Sparse_Matrix<E> operator*( Sparse_Matrix<E>&, Sparse_Matrix<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 este método que realiza el trabajo, aunque es poco cómodo de usar. Definición en la línea 775 del archivo Sparse_Matrix.h.

template<class E> E & Mx::Sparse_Matrix< 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) Definición en la línea 623 del archivo Sparse_Matrix.h.

template<class E> const E & Mx::Sparse_Matrix< 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) Definición en la línea 561 del archivo Sparse_Matrix.h.

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

Le cambia las dimensiones a la matriz. En algunos casos los valores almacenados en la matriz no quedan todos iguales a Sparse_Matrix<E>::value_type(0). Precondición: (m > 0) && (n > 0) Definición en la línea 445 del archivo Sparse_Matrix.h.

template<class E> void Mx::Sparse_Matrix< 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. Definición en la línea 551 del archivo Sparse_Matrix.h.

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

Define el escalar que por defecto está en todas las entradas de la Sparse_Matrix. Si same != getDefault() la matriz queda vacía. De lo contrario, nada ocurre. Definición en la línea 212 del archivo Sparse_Matrix.h.

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

Valor almacenado en la mayor parte de la Sparse_Matrix. Definición en la línea 89 del archivo Sparse_Matrix.h.

template<class E> void Mx::Sparse_Matrix< E >::reserve (  size_type  _Count  )

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

template<class E> void Mx::Sparse_Matrix< E >::reSize (  unsigned  newsize  )

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 662 del archivo Sparse_Matrix.h.

template<class E> void Mx::Sparse_Matrix< E >::clear (   )

Borra todos los valores de la Sparse_Matrix.

---

Documentación de las funciones relacionadas y clases amigas

template<class E> friend class test_Sparse_Matrix [friend]

Datos de prueba para la clase. Definición en la línea 96 del archivo Sparse_Matrix.h.

template<class E> bool operator== (  const Sparse_Matrix< E > &  p, const Sparse_Matrix< E > &  q )  [friend]

¿¿¿ (p == q) ??? Definición en la línea 63 del archivo Sparse_Matrix.h.

template<class E> bool operator!= (  const Sparse_Matrix< E > &  p, const Sparse_Matrix< E > &  q )  [friend]

¿¿¿ (p != q) ??? Definición en la línea 65 del archivo Sparse_Matrix.h.

template<class E> Sparse_Matrix operator+ (  const Sparse_Matrix< E > &  A, const Sparse_Matrix< E > &  B )  [friend]

Retorna A+B. Definición en la línea 74 del archivo Sparse_Matrix.h.

template<class E> Sparse_Matrix operator- (  const Sparse_Matrix< E > &  A, const Sparse_Matrix< E > &  B )  [friend]

Retorna A-B. Definición en la línea 76 del archivo Sparse_Matrix.h.

template<class E> Sparse_Matrix operator * (  const Sparse_Matrix< E > &  A, const Sparse_Matrix< E > &  B )  [friend]

Retorna A*B. Definición en la línea 78 del archivo Sparse_Matrix.h.

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

Verifica la invariante de la clase. El campo m_same indica cuál es el valor que se repite más en toda la matriz. Usualmente same es el neutro aditivo value_type(0). No existe un constructor explícito para darle a m_same su valor inicial, que es siempre inicializado en value_type(0). Para cambiarlo es necesario invocar el método setgetDefault(). Los vectores m_I[], m_J[] y m_val[] son vectores paralelos, todos de longitud Sparse_Matrix::m_capacity. La cantidad máxima de valores diferente que pueden ser almacenados en la matriz es Sparse_Matrix::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 const del operator()(i,j). O sea, que es ese método el encargado de agregar valores en m_val[], pues el operador homónimo const operator()(i,j) nunca agrega nada y, como es const, en general retorna una referencia constante a 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 0 (cero) al campo m_capacity. En todos los algoritmos, "m" o "m_rows" es la cantidad de filas == rows() En todos los algoritmos, "n" o "m_cols" es la cantidad de columnas == cols() Rep 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 http://www.di-mare.com/adolfo/binder/c03.htm#k1-Rep Comentarios: Libera al programador de implementar el método Ok() http://www.di-mare.com/adolfo/binder/c04.htm#sc11 - Invariante: (m_capacity == 0) <==> (m_I == 0) - Invariante: (m_capacity == 0) <==> (m_J == 0) - Invariante: (m_capacity == 0) <==> (m_val == 0) - Invariante: (m_rows == 0) ==> (m_capacity == 0) - Invariante: (m_cols == 0) ==> (m_capacity == 0) - Invariante: (m_capacity != 0) <==> (m_I != 0) - Invariante: (m_capacity != 0) <==> (m_J != 0) - Invariante: (m_capacity != 0) <==> (m_val != 0) - Invariante: (m_rows == 0) <==> (m_cols == 0) - Invariante: ( m_size <= m_capacity ) - Invariante: check_ok (m_same) - Invariante: ( (0<=m_I[k]) && (m_I[k] < m_rows) ) k = [0..m_size-1] - Invariante: ( (0<=m_J[k]) && (m_J[k] < m_cols) ) k = [0..m_size-1] - Invariante: check_ok( m_val[k] ) Definición en la línea 149 del archivo Sparse_Matrix.h.

---

Documentación de los datos miembro

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

Indice "i" de M(i,j) 0 <= i < m_capacity. Definición en la línea 98 del archivo Sparse_Matrix.h.

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

Indice "j" de M(i,j) 0 <= i < m_capacity. Definición en la línea 99 del archivo Sparse_Matrix.h.

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

Valor para M(i,j) 0 <= i < m_capacity. Definición en la línea 100 del archivo Sparse_Matrix.h.

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

Cantidad de valores insertados en los 3 vectores paralelos. Definición en la línea 101 del archivo Sparse_Matrix.h.

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

Tamaño de los 3 vectores paralelos. Definición en la línea 102 del archivo Sparse_Matrix.h.

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

Cantidad de filas de la matriz. Definición en la línea 103 del archivo Sparse_Matrix.h.

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

Cantidad de columnas de la matris. Definición en la línea 104 del archivo Sparse_Matrix.h.

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

Valor almacenado en la mayor parte de la Sparse_Matrix. Definición en la línea 105 del archivo Sparse_Matrix.h.

---

La documentación para esta clase fué generada a partir del siguiente archivo:

• Sparse_Matrix.h

---