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

#include <Matrix_Map.h>

Tipos públicos
typedef E	value_type
	Tipo del objeto almacenado, similar al nombre usado en STL. Más...

typedef value_type &	reference
	Tipo del objeto almacenado, similar al nombre usado en STL. Más...

typedef const value_type &	const_reference
	Tipo del objeto almacenado, similar al nombre usado en STL. Más...

typedef unsigned	size_type
	Tipo del tamaño de un objeto, similar al nombre usado en STL. Más...

Métodos públicos
	Matrix_Map (unsigned m=1, unsigned n=1)
	Constructor de vector. Más...

	Matrix_Map (const Matrix_Map &o)
	Constructor de copia. Más...

	Matrix_Map (const value_type V)
	Matriz escalar de valor `V`. Más...

	~Matrix_Map ()
	Destructor. Más...

unsigned	rows () const
	Cantidad de filas de la matriz. Más...

unsigned	cols () const
	Cantidad de columnas de la Matriz. Más...

unsigned	size () const
	Cantidad de valores almacenados en la matriz. Más...

unsigned	count () const
	Cantidad de valores almacenados en la matriz. Más...

size_type	capacity () const
	Cantidad máxima posible de valores diferentes que pueden ser almacenados en la matriz. Más...

Matrix_Map &	operator= (const Matrix_Map &o)
	Sinónimo de `this->copy(o)` Más...

Matrix_Map &	copy (const Matrix_Map &o)
	Copia desde `"o"`. Más...

Matrix_Map &	move (Matrix_Map &o)
	Traslada el valor de `"o"` a `"*this"`. Más...

Matrix_Map &	swap (Matrix_Map &o)
	Intercambia los valores de `"*this"` y `"o"`. Más...

bool	equals (const Matrix_Map &o) const
	¿¿¿ (*this==o) ??? Más...

bool	same (const Matrix_Map &o) const
	Retorna `true` si `"o"` comparte sus valores con `"*this"`. Más...

reference	operator() (unsigned, unsigned)
	Retorna una referencia al elemento [i,j] de la matriz. Más...

const_reference	operator() (unsigned, unsigned) const
	Retorna una referencia al elemento [i,j] de la matriz ( `const` ). Más...

void	reSize (unsigned, unsigned)
	Le cambia las dimensiones a la matriz. Más...

void	reShape (unsigned, unsigned)
	Le ajusta las dimensiones a la matriz. Más...

void	setDefault (const E &same)
	Define el escalar que por defecto está en todas las entradas de la `Matrix_Map`. Más...

const E &	getDefault ()
	Valor almacenado en la mayor parte de la `Matrix_Map`. Más...

void	reserve (size_type _Count)
	Ajusta la matriz para que pueda almacenar `n` valores diferentes a `getDefault()`. Más...

void	reSize (unsigned newsize)
	Le cambia el tamaño máximo posible a la matriz. Más...

void	clear ()
	Deja el valor de `*this` en el valor en que lo inicializa el constructor de vector. Más...

Tipos privados
typedef std::map< std::pair < unsigned, unsigned >, E >	Diccionario

Métodos privados
void	add (const Matrix_Map &)
	Le suma a `"*this"` la matriz `"O"`. Más...

void	substract (const Matrix_Map &)
	Le resta a `"*this"` la matriz `"O"`. Más...

void	multiply (const Matrix_Map &, const Matrix_Map &)
	Calcula la multiplicación `A * B` y la almacena en `"*this"`. Más...

Atributos privados
Diccionario	m_dicc
	Vector que contiene los valores de la matiz. Más...

unsigned	m_rows
	Cantidad de filas de la matriz. Más...

unsigned	m_cols
	Cantidad de columnas de la matriz. Más...

E	m_same
	Valor almacenado en la mayor parte de la `Matrix_Map`. Más...

Amigas
template<class T >
class	test_Matrix_Map
	Datos de prueba para la clase. Más...

bool	operator== (const Matrix_Map &p, const Matrix_Map &q)
	¿¿¿ (p == q) ??? Más...

bool	operator!= (const Matrix_Map &p, const Matrix_Map &q)
	¿¿¿ (p != q) ??? Más...

Matrix_Map	operator+ (const Matrix_Map &A, const Matrix_Map &B)
	Retorna `A+B`. Más...

Matrix_Map	operator- (const Matrix_Map &A, const Matrix_Map &B)
	Retorna `A-B`. Más...

Matrix_Map	operator* (const Matrix_Map &A, const Matrix_Map &B)
	Retorna `A*B`. Más...

template<class T >
bool	check_ok (const Matrix_Map< T > &M)
	Verifica la invariante de la clase. Más...

Descripción detallada

template<class E>
class Mx::Matrix_Map< E >

Esta es una clase matriz muy chirrisquitica almacenada como una matriz rala implementada con Map.

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 Matrix_Map<E>::value_type().
Las operaciones aritméticas "+" "-" "*" deben estar definidas para Matrix_Map<E>::value_type y debe existir el valor Matrix_Map<E>::value_type().
Ver también
http://www.oonumerics.org/oon/

Definición en la línea 37 del archivo Matrix_Map.h.

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

template<class E>

typedef E Mx::Matrix_Map< E >::value_type

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

Definición en la línea 40 del archivo Matrix_Map.h.

template<class E>

typedef value_type& Mx::Matrix_Map< E >::reference

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

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

template<class E>

typedef const value_type& Mx::Matrix_Map< E >::const_reference

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

Definición en la línea 44 del archivo Matrix_Map.h.

template<class E>

typedef unsigned Mx::Matrix_Map< E >::size_type

Tipo del tamaño de un objeto, similar al nombre usado en STL.

Definición en la línea 46 del archivo Matrix_Map.h.

template<class E>

typedef std::map< std::pair<unsigned,unsigned>, E > Mx::Matrix_Map< E >::Diccionario

private

Definición en la línea 107 del archivo Matrix_Map.h.

Documentación del constructor y destructor

template<class E >

Mx::Matrix_Map< E >::Matrix_Map	(	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 219 del archivo Matrix_Map.h.

template<class E >

Mx::Matrix_Map< E >::Matrix_Map ( const Matrix_Map< E > & o )

inline

Constructor de copia.

constructor de copia

Definición en la línea 230 del archivo Matrix_Map.h.

template<class E>

template< class E > inline Mx::Matrix_Map< E >::Matrix_Map ( const value_type V )

inline

Matriz escalar de valor V.

Constructor a partir de Matrix_Map<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 51 del archivo Matrix_Map.h.

template<class E >

Mx::Matrix_Map< E >::~Matrix_Map ( )

inline

Destructor.

Definición en la línea 237 del archivo Matrix_Map.h.

Documentación de las funciones miembro

template<class E>

unsigned Mx::Matrix_Map< E >::rows ( ) const

inline

Cantidad de filas de la matriz.

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

template<class E>

unsigned Mx::Matrix_Map< E >::cols ( ) const

inline

Cantidad de columnas de la Matriz.

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

template<class E>

unsigned Mx::Matrix_Map< E >::size ( ) const

inline

Cantidad de valores almacenados en la matriz.

Definición en la línea 56 del archivo Matrix_Map.h.

template<class E>

unsigned Mx::Matrix_Map< E >::count ( ) const

inline

Cantidad de valores almacenados en la matriz.

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

template<class E>

size_type Mx::Matrix_Map< E >::capacity ( ) const

inline

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

Definición en la línea 59 del archivo Matrix_Map.h.

template<class E>

Matrix_Map& Mx::Matrix_Map< E >::operator= ( const Matrix_Map< E > & o )

inline

Sinónimo de this->copy(o)

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

template<class E >

Matrix_Map< E > & Mx::Matrix_Map< E >::copy ( const Matrix_Map< 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 275 del archivo Matrix_Map.h.

template<class E >

Matrix_Map< E > & Mx::Matrix_Map< E >::move ( Matrix_Map< 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 302 del archivo Matrix_Map.h.

template<class E >

Matrix_Map< E > & Mx::Matrix_Map< E >::swap ( Matrix_Map< 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 Matrix_Map::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 340 del archivo Matrix_Map.h.

template<class E >

bool Mx::Matrix_Map< E >::equals ( const Matrix_Map< E > & o ) const

¿¿¿ (*this==o) ???

Definición en la línea 240 del archivo Matrix_Map.h.

template<class E>

bool Mx::Matrix_Map< E >::same ( const Matrix_Map< E > & o ) const

inline

Retorna true si "o" comparte sus valores con "*this".

Definición en la línea 72 del archivo Matrix_Map.h.

template<class E >

void Mx::Matrix_Map< E >::add ( const Matrix_Map< 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 Matrix_Map<E> operator+( Matrix_Map<E>&, Matrix_Map<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 509 del archivo Matrix_Map.h.

template<class E >

void Mx::Matrix_Map< E >::substract ( const Matrix_Map< 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 Matrix_Map<E> operator-( Matrix_Map<E>&, Matrix_Map<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 538 del archivo Matrix_Map.h.

template<class E >

void Mx::Matrix_Map< E >::multiply	(	const Matrix_Map< E > &	A,
		const Matrix_Map< 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 Matrix_Map<E> operator*( Matrix_Map<E>&, Matrix_Map<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 571 del archivo Matrix_Map.h.

template<class E >

E & Mx::Matrix_Map< 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 463 del archivo Matrix_Map.h.

template<class E >

const E & Mx::Matrix_Map< E >::operator()	(	unsigned	i,
		unsigned	j
	)		const

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 420 del archivo Matrix_Map.h.

template<class E >

void Mx::Matrix_Map< 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 Matrix_Map<E>::value_type().
Precondición
(m > 0) && (n > 0)

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

template<class E >

void Mx::Matrix_Map< 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 401 del archivo Matrix_Map.h.

template<class E >

void Mx::Matrix_Map< E >::setDefault ( const E & same )

inline

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

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

Definición en la línea 192 del archivo Matrix_Map.h.

template<class E>

const E& Mx::Matrix_Map< E >::getDefault ( )

inline

Valor almacenado en la mayor parte de la Matrix_Map.

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

template<class E>

void Mx::Matrix_Map< E >::reserve ( size_type _Count )

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

template<class E >

void Mx::Matrix_Map< E >::reSize ( unsigned newsize )

inline

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 490 del archivo Matrix_Map.h.

template<class E >

void Mx::Matrix_Map< E >::clear ( )

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

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

Documentación de las funciones relacionadas y clases amigas

template<class E>

template<class T >

friend class test_Matrix_Map

friend

Datos de prueba para la clase.

Definición en la línea 100 del archivo Matrix_Map.h.

template<class E>

bool operator==	(	const Matrix_Map< E > &	p,
		const Matrix_Map< E > &	q
	)

friend

¿¿¿ (p == q) ???

Definición en la línea 67 del archivo Matrix_Map.h.

template<class E>

bool operator!=	(	const Matrix_Map< E > &	p,
		const Matrix_Map< E > &	q
	)

friend

¿¿¿ (p != q) ???

Definición en la línea 69 del archivo Matrix_Map.h.

template<class E>

Matrix_Map operator+	(	const Matrix_Map< E > &	A,
		const Matrix_Map< E > &	B
	)

friend

Retorna A+B.

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

template<class E>

Matrix_Map operator-	(	const Matrix_Map< E > &	A,
		const Matrix_Map< E > &	B
	)

friend

Retorna A-B.

Definición en la línea 80 del archivo Matrix_Map.h.

template<class E>

Matrix_Map operator*	(	const Matrix_Map< E > &	A,
		const Matrix_Map< E > &	B
	)

friend

Retorna A*B.

Definición en la línea 82 del archivo Matrix_Map.h.

template<class E>

template<class T >

bool check_ok ( const Matrix_Map< 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 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_dicc 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_dicc, 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_dicc 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

std::map<std::pair<unsigned,unsigned>,  E  , std::less<std::pair<unsigned,unsigned> > >
   m_dicc      IT
               /\
              /  \
             /    \
        First      second
      _____________________
     /                     \
    | std::pair <0,1>, 'a' |
     \_____________________/        0 1 2 3 4 5 6
           M(0,1)=='a'          0 / - a - - - - - \
                                1 | - - - - - - - |
      _____________________     2 | - - - - - - - |
     /                     \    3 | - - - - - b - |
    | std::pair <3,5>, 'b' |    4 \ - - - - - - - /
     \_____________________/
           M(3,5)=='b'
        m_same == '-'   m_rows == 5   m_cols == 7

- http://www.di-mare.com/adolfo/binder/c03.htm#k1-Rep
\remark
Libera al programador de implementar el método \c Ok()
- http://www.di-mare.com/adolfo/binder/c04.htm#sc11

Invariante: ningún objeto puede estar almacenado en la posición nula.
Invariante: (m_cols == 0) <==> (m_dicc.empty())
Invariante: check_ok( M.m_same )
Invariante: check_ok( M(i,j) )

Definición en la línea 164 del archivo Matrix_Map.h.

Documentación de los datos miembro

template<class E>

Diccionario Mx::Matrix_Map< E >::m_dicc

private

Vector que contiene los valores de la matiz.

Definición en la línea 108 del archivo Matrix_Map.h.

template<class E>

unsigned Mx::Matrix_Map< E >::m_rows

private

Cantidad de filas de la matriz.

Definición en la línea 109 del archivo Matrix_Map.h.

template<class E>

unsigned Mx::Matrix_Map< E >::m_cols

private

Cantidad de columnas de la matriz.

Definición en la línea 110 del archivo Matrix_Map.h.

template<class E>

E Mx::Matrix_Map< E >::m_same

private

Valor almacenado en la mayor parte de la Matrix_Map.

Definición en la línea 111 del archivo Matrix_Map.h.

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

Matrix_Map.h

Tipos públicos

Métodos públicos

Tipos privados

Métodos privados

Atributos privados

Amigas

Descripción detallada

template<class E> class Mx::Matrix_Map< E >

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

Documentación del constructor y destructor

Documentación de las funciones miembro

Documentación de las funciones relacionadas y clases amigas

Documentación de los datos miembro

template<class E>
class Mx::Matrix_Map< E >