Esta es una clase matriz muy chirrisquitica que puede cambiar dinámicamente de tamaño. Más...

#include <Matrix.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 (unsigned m=1, unsigned n=1)
	Constructor de vector. Más...

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

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

	~Matrix ()
	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 &	operator= (const Matrix &o)
	Sinónimo de `this->copy(o)` Más...

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

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

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

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

bool	same (const Matrix &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...

reference	at (unsigned m, unsigned n)
	Retorna `operator()(m,n)`. Más...

const_reference	at (unsigned m, unsigned n) const
	Retorna `operator()(m,n)` `"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	transpose ()
	Transpone la matriz. Más...

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

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

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

Atributos privados
value_type *	m_val
	Vector de valores de la matriz. Más...

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

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

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

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

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

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

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

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

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

Descripción detallada

template<class E>
class Mx::Matrix< E >

Esta es una clase matriz muy chirrisquitica que puede cambiar dinámicamente de tamaño.

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().
Las operaciones aritméticas "+" "-" "*" deben estar definidas para Matrix<E>::value_type y debe existir el valor Matrix<E>::value_type() y también Matrix<E>::value_type(1) (para matrices unitarias)
Los valores de la matriz pueden estar almacenados por filas o por columnas, según quede implementado el método Matrix<E>::operator(unsigned, unsigned)

Ver también: http://www.oonumerics.org/oon/

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

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

template<class E>

typedef E Mx::Matrix< E >::value_type

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

Definición en la línea 66 del archivo Matrix.h.

template<class E>

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

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

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

template<class E>

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

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

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

template<class E>

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

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

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

Documentación del constructor y destructor

template<class E >

Mx::Matrix< E >::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)

{{ // test::constructor()
    int M[4][5];       //   [0][1][2][3][4]
    intmatrix<4,5>( M , " |  1  2  3  4  5 | "   // [0]
                        " |  6  7  8  9 10 | "   // [1]
                        " | 11 12 13 14 15 | "   // [2]
                        " | 16 17 18 19 20 | " );// [3]
    assertTrue( M[0][0] == 1 );  assertTrue( M[2][1] == 12 );
    Matrix<int> Mchirri(4,5); // la chirrisquitica
    int k=1;
    for ( size_t i=0; i<4; ++i ) {
        for ( size_t j=0; j<5; ++j ) {
            Mchirri(i,j) = M[i][j];
            assertTrue( Mchirri(i,j)==k ); k++;
        }
    }
}}

Definición en la línea 219 del archivo Matrix.h.

template<class E >

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

Constructor de copia.

Definición en la línea 238 del archivo Matrix.h.

template<class E>

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

inline

Matriz escalar de valor V.

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

template<class E >

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

inline

Destructor.

Definición en la línea 262 del archivo Matrix.h.

Documentación de las funciones miembro

template<class E>

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

inline

Cantidad de filas de la matriz.

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

template<class E>

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

inline

Cantidad de columnas de la Matriz.

{{ // test::rows_cols()

    int M[4][5];       //   [0][1][2][3][4]
    intmatrix<4,5>( M , " |  1  2  3  4  5 | "   // [0]
                        " |  6  7  8  9 10 | "   // [1]
                        " | 11 12 13 14 15 | "   // [2]
                        " | 16 17 18 19 20 | " );// [3]
    Matrix<int> Mchirri(4,5); // la chirrisquitica
    int k=1;
    for ( size_t i=0; i<4; ++i ) {
        for ( size_t j=0; j<5; ++j ) {
            Mchirri(i,j) = M[i][j];
            assertTrue( Mchirri(i,j)==k ); k++;
        }
    }
    assertTrue( Mchirri.rows() == 4 );
    assertTrue( Mchirri.cols() == 5 );
}}

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

template<class E>

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

inline

Cantidad de valores almacenados en la matriz.

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

template<class E>

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

inline

Cantidad de valores almacenados en la matriz.

Definición en la línea 83 del archivo Matrix.h.

template<class E>

size_type Mx::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 85 del archivo Matrix.h.

template<class E>

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

inline

Sinónimo de this->copy(o)

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

template<class E >

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

template<class E >

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

template<class E >

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

template<class E >

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

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

Definición en la línea 269 del archivo Matrix.h.

template<class E>

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

inline

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

Definición en la línea 98 del archivo Matrix.h.

template<class E >

void Mx::Matrix< E >::add ( const Matrix< E > & O )

protected

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<E> operator+( Matrix<E>&, 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 513 del archivo Matrix.h.

template<class E >

void Mx::Matrix< E >::substract ( const Matrix< E > & O )

protected

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<E> operator-( Matrix<E>&, 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 544 del archivo Matrix.h.

template<class E >

void Mx::Matrix< E >::multiply	(	const Matrix< E > &	A,
		const Matrix< E > &	B
	)

protected

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() )

Comentarios

Esta es la implementación de Matrix<E> operator*( Matrix<E>&, 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 580 del archivo Matrix.h.

template<class E >

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

template<class E >

const E & Mx::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 477 del archivo Matrix.h.

template<class E>

reference Mx::Matrix< E >::at	(	unsigned	m,
		unsigned	n
	)

inline

Retorna operator()(m,n).

Definición en la línea 113 del archivo Matrix.h.

template<class E>

const_reference Mx::Matrix< E >::at	(	unsigned	m,
		unsigned	n
	)		const

inline

Retorna operator()(m,n) "const".

Definición en la línea 115 del archivo Matrix.h.

template<class E >

void Mx::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 Matrix<E>::value_type().
Si (m * n == 0) deja la matriz vacía.

Definición en la línea 406 del archivo Matrix.h.

template<class E >

void Mx::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 465 del archivo Matrix.h.

template<class E>

void Mx::Matrix< E >::transpose ( )

inline

Transpone la matriz.

Definición en la línea 120 del archivo Matrix.h.

Documentación de las funciones relacionadas y clases amigas

template<class E>

template<class T >

friend class test_Matrix

friend

Datos de prueba para la clase.

Definición en la línea 127 del archivo Matrix.h.

template<class E>

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

friend

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

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

template<class E>

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

friend

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

Definición en la línea 95 del archivo Matrix.h.

template<class E>

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

friend

Retorna A+B.

Definición en la línea 104 del archivo Matrix.h.

template<class E>

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

friend

Retorna A-B.

Definición en la línea 106 del archivo Matrix.h.

template<class E>

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

friend

Retorna A*B.

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

template<class E>

template<class T >

bool check_ok ( const Matrix< T > & M )

friend

Verifica la invariante de la clase.

- 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_val.
- Las matrices quedan almacenadas en un vector de tamaño [M x N].
- 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

+---+                                         /         \
| 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 |
+---+   +---+---+---+---+---+---+---+---+

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

+---+
| 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 |
+---+   +---+---+---+---+---+---+---+---+

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.m_rows == 0) <==> (M.m_cols == 0)
Invariante: (M.m_rows == 0) <==> (M.m_val == 0)
Invariante: check_ok( m_val[k] )

Definición en la línea 170 del archivo Matrix.h.

Documentación de los datos miembro

template<class E>

value_type* Mx::Matrix< E >::m_val

private

Vector de valores de la matriz.

Definición en la línea 129 del archivo Matrix.h.

template<class E>

unsigned Mx::Matrix< E >::m_rows

private

Cantidad de filas de la matriz.

Definición en la línea 130 del archivo Matrix.h.

template<class E>

unsigned Mx::Matrix< E >::m_cols

private

Cantidad de columnas de la matris.

Definición en la línea 131 del archivo Matrix.h.

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

Matrix.h

Tipos públicos

Métodos públicos

Métodos protegidos

Atributos privados

Amigas

Descripción detallada

template<class E> class Mx::Matrix< 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< E >