Métodos de la clase Pds::Matrix, una matriz. Más...

Namespaces
namespace	Pds
	Nombre de espacion para PDS (Procesamiento Digital de Senales)

Estructuras de datos
class	Pds::Matrix
	La clase tipo Pds::Matrix . Esta clase genera una matriz de Nlin lineas y Ncol columnas. Para usar incluir Pds/Matrix. Más...

Constructores
Crean una objeto Pds::Matrix
	Pds::Matrix::Matrix (void)
	Crea un objeto de tipo Pds::Matrix vacio. Más...

	Pds::Matrix::Matrix (unsigned int N)
	Crea un objeto de tipo Pds::Matrix de N lineas y N columnas, con elementos inicializados con cero. Más...

	Pds::Matrix::Matrix (const Pds::Size &S)
	Crea un objeto de tipo Pds::Matrix con elementos inicializados con cero. Más...

	Pds::Matrix::Matrix (const Pds::Matrix &B)
	Crea un objeto de tipo Pds::Matrix copiando datos desde otra matriz. Este es un Copy assignment constructor. Más...

template<class Datum >
	Pds::Matrix::Matrix (const Pds::Array< Datum > &B)
	Crea un objeto de tipo Pds::Matrix copiando datos desde un arreglo. Más...

	Pds::Matrix::Matrix (const char *str)
	Crea un objeto de tipo Pds::Matrix copiando datos desde una cadena. Más...

	Pds::Matrix::Matrix (const std::string &str)
	Crea un objeto de tipo Pds::Matrix copiando datos desde una std::string. Más...

	Pds::Matrix::Matrix (unsigned int Nlin, unsigned int Ncol)
	Crea un objeto de tipo Pds::Matrix con elementos inicializados con cero. Más...

	Pds::Matrix::Matrix (unsigned int Nlin, unsigned int Ncol, double val)
	Crea un objeto de tipo Pds::Matrix con elementos inicializados con val. Más...

	Pds::Matrix::Matrix (double(*func)(double), const Pds::Matrix &B)
	Crea un objeto de tipo Pds::Matrix, evaluando mediante una función, los datos de otra matriz. Más...

	Pds::Matrix::Matrix (double(*func)(double, double), const Pds::Matrix &B, double var)
	Crea un objeto de tipo Pds::Matrix, evaluando mediante una función, los datos de otra matriz. Más...

	Pds::Matrix::Matrix (double(*func)(double, double), const Pds::Matrix &B, const Pds::Matrix &C)
	Crea un objeto de tipo Pds::Matrix, evaluando mediante una función, los datos de otra matriz. Más...

	Pds::Matrix::Matrix (double(*func)(double, double, double), const Pds::Matrix &B, const Pds::Matrix &C, double var)
	Crea un objeto de tipo Pds::Matrix, evaluando mediante una función, los datos de otra matriz. Más...

	Pds::Matrix::Matrix (double(*func)(double, double, double), const Pds::Matrix &X, const Pds::Matrix &Y, const Pds::Matrix &Z)
	Crea un objeto de tipo Pds::Matrix, evaluando mediante una función, los datos de otra matriz. Más...

	Pds::Matrix::Matrix (double(*func)(double, double, double, double), const Pds::Matrix &X, const Pds::Matrix &Y, const Pds::Matrix &Z, double var)
	Crea un objeto de tipo Pds::Matrix, evaluando mediante una función, los datos de otra matriz. Más...

	Pds::Matrix::Matrix (double(*func)(double, double, double, double), const Pds::Matrix &X, const Pds::Matrix &Y, const Pds::Matrix &Z, const Pds::Matrix &W)
	Crea un objeto de tipo Pds::Matrix, evaluando mediante una función, los datos de otra matriz. Más...

	Pds::Matrix::Matrix (Pds::Ra::FormatType Type, std::string filepath)
	Crea un objeto de tipo Pds::Matrix copiando datos desde un archivo. Más...

	Pds::Matrix::~Matrix ()

Métodos de estado
Indican o establecen el estado de una matriz.
bool	Pds::Matrix::IsEmpty (void) const
	Verifica si la matriz es nula es decir con lineas o columnas cero o arreglo NULL. Más...

bool	Pds::Matrix::IsNotEmpty (void) const
	Verifica si la matriz NO es nula, es decir con lineas y columnas diferentes cero y arreglo diferente de NULL. Más...

bool	Pds::Matrix::IsSimilarTo (const Pds::Matrix &B) const
	Verifica si las matrices son similares en tamaño. Más...

bool	Pds::Matrix::IsNotSimilarTo (const Pds::Matrix &B) const
	Verifica si las matrices son similares en tamaño. Más...

bool	Pds::Matrix::IsMulBy (const Pds::Matrix &B) const
	Verifica si las matrices son multiplicables. Más...

bool	Pds::Matrix::IsNotMulBy (const Pds::Matrix &B) const
	Verifica si las matrices son multiplicables. Más...

bool	Pds::Matrix::IsInRange (unsigned int lin, unsigned int col) const
	Verifica si la posición pertenece a la matriz. Más...

bool	Pds::Matrix::IsNotInRange (unsigned int lin, unsigned int col) const
	Verifica si la posición NO pertenece a la matriz. Más...

bool	Pds::Matrix::IsInSizeRange (double lin, double col) const
	Verifica si la posición (lin,col) pertenece al rango de la matriz. Más...

bool	Pds::Matrix::IsRowMatrix (void) const
	Verifica si la matriz tiene solo una linea. Más...

bool	Pds::Matrix::IsColMatrix (void) const
	Verifica si la matriz tiene solo una columna. Más...

bool	Pds::Matrix::IsZero (void) const
	Verifica si la matriz está llena de zeros. Más...

bool	Pds::Matrix::IsLeq (double val) const
	Verifica si cada elemento de la matriz es menor a el valor val. Más...

bool	Pds::Matrix::IsLeq (const Pds::Matrix &B) const
	Verifica si cada elemento de la matriz es menor igual a cada elemento de la matriz B. Más...

bool	Pds::Matrix::IsGeq (double val) const
	Verifica si cada elemento de la matriz es mayor a el valor val. Más...

bool	Pds::Matrix::IsGeq (const Pds::Matrix &B) const
	Verifica si cada elemento de la matriz es mayor igual a cada elemento de la matriz B. Más...

bool	Pds::Matrix::IsEqualTo (double val) const
	Verifica si cada elemento de la matriz es igual a el valor val. Más...

bool	Pds::Matrix::IsEqualTo (const Pds::Matrix &B) const
	Verifica si cada elemento de la matriz es igual a cada elemento de la matriz B. Más...

bool	Pds::Matrix::HasInf (void) const
	Verifica si la matriz tiene algun valor infinito. Más...

bool	Pds::Matrix::HasNan (void) const
	Verifica si la matriz tiene algun valor NAN (Not A Number). Más...

bool	Pds::Matrix::HasNotFinite (void) const
	Verifica si la matriz tiene elementos no finitos (+inf, -inf y NAN). Más...

Métodos de inicialización
Establecen los valores de las matrices.
bool	Pds::Matrix::FillRandC (double p1)
	Inicializa la matriz con números aleatórios unos y ceros, la probabilidad de 1 es p1. Más...

bool	Pds::Matrix::FillRandN (void)
	Inicializa la matriz con números aleatórios, distribuidos usando una distribución Gaussiana normalizada con media 0 y desvío padrón 1.0. Más...

bool	Pds::Matrix::FillRandN (double U, double Sigma)
	Inicializa la matriz con números aleatórios, distribuidos usando una distribución Gaussiana con media U y desvío padrón Sigma. Más...

bool	Pds::Matrix::FillRandU (void)
	Inicializa la matriz con números aleatórios, distribuidos uniformemente, desde 0 a 1.0, incluyendo 0 y excluyendo 1.0. Más...

bool	Pds::Matrix::FillRandU (int a, int b)
	Inicializa la matriz con números aleatórios, distribuidos uniformemente, desde a a b, incluyendo a y b. Más...

bool	Pds::Matrix::FillRandU (double a, double b)
	Inicializa la matriz con números aleatórios, distribuidos uniformemente, desde a a b, incluyendo a y b. Más...

bool	Pds::Matrix::FillId (void)
	Inicializa la matriz con el valor de la posición de cada elemento. Más...

bool	Pds::Matrix::Fill (double val)
	Inicializa la matriz con un valor constante. Más...

bool	Pds::Matrix::FillLinSpace (double a, double b)
	Inicializa la matriz con un espacio linear entre begin y end. Se inicializa primero una columna ante de pasar ala siguiente. Más...

Métodos de tamaño
Herramientas genéricas para lectura y escritura de datos.
unsigned int	Pds::Matrix::Nlin (void) const
	Retorna el numero de lineas de la matriz. Más...

unsigned int	Pds::Matrix::Ncol (void) const
	Retorna el numero de columnas de la matriz. Más...

unsigned int	Pds::Matrix::Nel (void) const
	Retorna el numero de elementos de la matriz (Nlin x Ncol). Más...

Pds::Size	Pds::Matrix::Size (void) const
	Retorna un objeto de tipo Pds::Size con el numero de lineas y columans. Más...

unsigned int	Pds::Matrix::LinEnd (void) const
	Retorna el identificador de la ultima linea de la matriz. Más...

unsigned int	Pds::Matrix::ColEnd (void) const
	Retorna el identificador de la ultima columna de la matriz. Más...

unsigned int	Pds::Matrix::End (void) const
	Retorna el identificador del ultimo elemento de la matriz. Más...

Métodos get y set de elementos
Herramientas genéricas para lectura y escritura de datos.
double	Pds::Matrix::Get (unsigned int id) const
	Retorna el valor en la posición del índice id, hace una verificación si la posición existe. Más...

double	Pds::Matrix::Get (unsigned int lin, unsigned int col) const
	Retorna el valor en la posición (lin,col), hace una verificación si la posición existe. Más...

const double &	Pds::Matrix::GetRaw (unsigned int lin, unsigned int col) const
	Retorna una variable double en la posición (lin,col) de la array. Más...

void	Pds::Matrix::SetRaw (unsigned int lin, unsigned int col, const double &val)
	Establece una variable double en la posición (lin,col) de la array. Más...

bool	Pds::Matrix::Set (unsigned int id, double val)
	Escribe el valor en la posición del índice id, hace una verificación si la posición existe. Más...

bool	Pds::Matrix::Set (unsigned int lin, unsigned int col, double val)
	Escribe el valor en la posición (lin,col), hace una verificación si la posición existe. Más...

double &	Pds::Matrix::At (unsigned int lin, unsigned int col)
	Retorna una variable double en la posición (lin,col) de la matriz. Hace una verificación para evitar leer o escribir fuera de la memoria, con este fin hace lin=linNlin y col=colNcol. Más...

double &	Pds::Matrix::At (unsigned int id)
	Retorna una variable double en la posición (id) de la matriz. Hace una verificación para evitar leer o escribir fuera de la memoria, con este fin hace id=id%(Nlin*Ncol). Más...

double	Pds::Matrix::Bilinear (double lin, double col) const
	Retorna el valor en la posición (lin,col), usando una interpolación bilinear, valores fuera del rango de la matriz retornan cero. Más...

Métodos get y set de matrices y vectores
Herramientas genericas para lectura y escritura de datos.
Pds::Vector	Pds::Matrix::GetDiagonal (void) const
	Retorna un vector columna copia de los valores de la diagonal de la matriz. Más...

bool	Pds::Matrix::SetDiagonal (const Pds::Vector V)
	Copia un vector columna en una diagonal de la matriz. Si los tamaños son diferentes, se interceptan las matrices y se copia solamente en la intersección. Más...

Pds::Matrix	Pds::Matrix::GetMatrix (unsigned int lin_init, unsigned int col_init, unsigned int lin_end, unsigned int col_end) const
	Retorna una sub matriz desde la posición (lin_init,col_init) hasta (lin_end,col_end), inclusive. Hace una verificación si la posición existe, si no existe llena con ceros. Más...

Pds::Matrix	Pds::Matrix::GetMatrix (unsigned int lin_init, unsigned int col_init, Pds::Size size) const
	Retorna una sub matriz desde la posición (lin_init,col_init) hasta (lin_end,col_end), inclusive. Hace una verificación si la posición existe, si no existe llena con ceros. Más...

bool	Pds::Matrix::SetMatrix (unsigned int lin, unsigned int col, const Pds::Matrix &B)
	Copia en si mismo (A) en la posicion (lin,col), el contenido de una matriz B. Si a matriz B no cabe em A se retorna false. Más...

Pds::Matrix	Pds::Matrix::GetRow (unsigned int lin) const
	Retorna una matriz linea escojida en la linea lin. Hace una verificación si la linea existe, si no existe devuelve una matriz vacia. Más...

Pds::Matrix	Pds::Matrix::GetCol (unsigned int col) const
	Retorna una matriz columna escojida en la columna col. Hace una verificación si la columna existe, si no existe devuelve una matriz vacia. Más...

Pds::Matrix	Pds::Matrix::GetRows (unsigned int lin_init, unsigned int lin_end) const
	Retorna una sub matriz escojida desde la linea lin_init hasta lin_end, inclusive. Hace una verificación si la linea existe, si no existe llena esta con ceros. Más...

Pds::Matrix	Pds::Matrix::GetCols (unsigned int col_init, unsigned int col_end) const
	Retorna una sub matriz escojida desde la columna col_init hasta col_end, inclusive. Hace una verificación si la columna existe, si no existe llena esta con ceros. Más...

Pds::Matrix	Pds::Matrix::GetRows (std::list< unsigned int > List) const
	Retorna una sub matriz escojida desde una lista de indices de lineas. Hace una verificación si los indices existen, si alguno no existe devuelve una matriz vacia. Más...

Pds::Matrix	Pds::Matrix::GetCols (std::list< unsigned int > List) const
	Retorna una sub matriz escojida desde una lista de indices de columnas. Hace una verificación si los indices existen, si alguno no existe devuelve una matriz vacia. Más...

Pds::Matrix	Pds::Matrix::GetRows (std::vector< unsigned int > Vec) const
	Retorna una sub matriz escojida desde una lista de indices de lineas. Hace una verificación si los indices existen, si alguno no existe devuelve una matriz vacia. Más...

Pds::Matrix	Pds::Matrix::GetCols (std::vector< unsigned int > Vec) const
	Retorna una sub matriz escojida desde una lista de indices de columnas. Hace una verificación si los indices existen, si alguno no existe devuelve una matriz vacia. Más...

Pds::Matrix	Pds::Matrix::GetRowsRand (unsigned int N) const
	Retorna una sub matriz escojiendo N lineas aleatoriamente (sin repetición). Más...

Pds::Matrix	Pds::Matrix::GetColsRand (unsigned int N) const
	Retorna una sub matriz escojiendo N columnas aleatoriamente (sin repetición). Más...

bool	Pds::Matrix::SetRowValue (unsigned int lin, double value)
	Copia un valor en una linea de la matriz. Más...

bool	Pds::Matrix::SetRowVector (unsigned int lin, const Pds::Vector &X)
	Copia un vector en una linea de la matriz. Más...

bool	Pds::Matrix::SetColValue (unsigned int col, double value)
	Copia un valor en una columna de la matriz. Más...

Pds::Vector	Pds::Matrix::GetRowAsColVector (unsigned int lin) const
	Retorna un vector columna copia de una linea de la matriz. Más...

bool	Pds::Matrix::GetRowAsColVector (unsigned int lin, Pds::Vector &V) const
	Retorna un vector columna copia de una linea de la matriz. Más...

Pds::Vector	Pds::Matrix::GetColVector (unsigned int col) const
	Retorna un vector columna copia de una columna de la matriz. Más...

bool	Pds::Matrix::SetColVector (unsigned int col, const Pds::Vector V)
	Copia un vector columna en una columna de la matriz. Si los tamaños son diferentes, se interceptan las matrices y se copia solamente en la intersección. Más...

bool	Pds::Matrix::SetColVector (unsigned int col, double(*func)(double), const Pds::Vector V)
	Copia un vector columna en una columna de la matriz, despues de evaluar el vector en una funcion. Si los tamaños son diferentes, se interceptan las matrices y se copia solamente en la intersección. Más...

bool	Pds::Matrix::SetColVector (unsigned int col, double(*func)(double, double), const Pds::Vector V, double var)
	Copia un vector columna en una columna de la matriz, despues de evaluar el vector en una funcion. Si los tamaños son diferentes, se interceptan las matrices y se copia solamente en la intersección. Más...

Métodos de opreaciones sobre las lineas de la matriz
operaciones con lineas
bool	Pds::Matrix::RowAddAssig (unsigned int lin1, unsigned int lin2, double alpha)
	Multiplica los valores de la linea lin2 por alfa y el resultado es sumado a los valores de la linea lin1. Más...

bool	Pds::Matrix::RowMulAssig (unsigned int lin, double alpha)
	Multiplica la linea lin por alpha. Más...

bool	Pds::Matrix::RowDivAssig (unsigned int lin, double alpha)
	Divide la linea lin por alpha. Más...

bool	Pds::Matrix::RowSwap (unsigned int lin1, unsigned int lin2)
	Intercambia los valores de las lineas de una matriz. Más...

int	Pds::Matrix::RowSwapBelow (unsigned int n)
	Si el n-avo elemento de la diagonal es cero entonces intercambia la linea n de la matriz con cualquier linea inferior con elemento diferente de cero en la columna n. Más...

bool	Pds::Matrix::RowReduction (void)
	Convierte la matriz en una matriz reducida. Más...

bool	Pds::Matrix::RowDivByAbsMax (void)
	Normaliza cada linea de la matriz dividiendola por el maximo valor absoluto de la linea. Si la linea tiene solo ceros esta no es modificada. Más...

Métodos estadísticos
Herramientas genéricas
double	Pds::Matrix::Sum (void) const
	Calcula el valor de la suma de elementos de la matriz. Más...

double	Pds::Matrix::Mean (void) const
	Calcula el valor medio de la matriz. Más...

Pds::Matrix	Pds::Matrix::MeanInCols (void) const
	Calcula el valor medio de las columnas de la matriz. Más...

Pds::Vector	Pds::Matrix::MeanInRows (void) const
	Calcula la media de cada linea de la matriz. Más...

double	Pds::Matrix::Std (double *mean=NULL) const
	Calcula el valor del desvío padrón de la matriz. Más...

Pds::Vector	Pds::Matrix::StdInRows (void) const
	Calcula el standard deviation de cada linea de la matriz. Más...

bool	Pds::Matrix::MeanStdInRows (Pds::Vector &Mean, Pds::Vector &Std) const
	Calcula la media y el standard deviation de cada linea de la matriz. Más...

bool	Pds::Matrix::MeanStdInCols (Pds::Matrix &Mean, Pds::Matrix &Std) const
	Calcula la media y el standard deviation de cada linea de la matriz. Más...

double	Pds::Matrix::Var (double *mean=NULL) const
	Calcula el valor de la varianza de la matriz. Más...

double	Pds::Matrix::Max (unsigned int *id=NULL) const
	Calcula el máximo valor de la matriz. Más...

double	Pds::Matrix::MaxAbs (unsigned int *id=NULL) const
	Calcula el máximo valor del valor absoluto de la matriz. Más...

Pds::Vector	Pds::Matrix::MaxAbsInRows (void) const
	Retorna un vector con el maximo valor absoluto de cada linea. Más...

double	Pds::Matrix::Min (unsigned int *id=NULL) const
	Calcula el mínimo valor de la matriz. Más...

double	Pds::Matrix::MinAbs (unsigned int *id=NULL) const
	Calcula el mínimo valor del valor absoluto de la matriz. Más...

Pds::Matrix	Pds::Matrix::MinInCols (std::vector< unsigned int > &Lin) const
	Calcula el mínimo en cada columna de la matriz. Más...

Pds::Matrix	Pds::Matrix::MinInCols (Pds::Array< unsigned int > &Lin) const
	Calcula el mínimo en cada columna de la matriz. Más...

bool	Pds::Matrix::NormalizeCols (Pds::Vector &Mean, Pds::Vector &Std)
	Calcula la media y el standard deviation de cada columna de la matriz. Si el std de la columna es cero esta no es normalizada. Más...

bool	Pds::Matrix::NormalizeColsWith (const Pds::Vector &Mean, const Pds::Vector &Std)
	Normaliza cada columna de la matriz usando la media y el standard deviation de cada columna de la matriz. Si el std de la columna es cero esta no es normalizada. Más...

double	Pds::Matrix::Accuracy (const Pds::Matrix &B, double Umbral) const
	Calcula el valor de la Accuracy entre los elementos de las matrices A (Self) y B. Antes de comprarar las matrices se binarizan con el umbral Umbral. A>Umbral, B>Umbral. Más...

double	Pds::Matrix::R2 (const Pds::Matrix &Y) const
	Calcula el coeficiente de determinación o . Más...

double	Pds::Matrix::Rf (const Pds::Matrix &Y) const
	Calcula o . Más...

double	Pds::Matrix::Mape (const Pds::Matrix &B) const
	Calcula el error absoluto medio porcentual (Mean Absolute Percentage Error) de una matriz. Más...

Métodos Information theory
Herramientas genéricas
double	Pds::Matrix::InformationGain (const std::vector< Pds::Matrix > &A, double Umbral=0.5) const
	Retorna el Information Gain entre si mismo B y {A[0],A[1],...,A[N-1]}. Antes de comprarar las matrices se binarizan con el umbral Umbral. A[n]>Umbral, B>Umbral. Más...

double	Pds::Matrix::BinaryEntropy (double umbral) const
	Calcula la entropia binaria de la estadistica de {p0,p1}, la probabilidade de unos y ceros en la matriz despues de ubralizar con >=umbral. Más...

double	Pds::Matrix::P1Probability (double umbral) const
	Calcula la probabilidad binaria {p1}, la probabilidade en relación a los unos y ceros en la matriz despues de ubralizar con >=umbral. Más...

Pds::Matrix	Pds::Matrix::BalancedBinaryWeight (double umbral) const
	Retorna una matriz de pesos para balancear la cantidad de 1s y 0s en la matriz. Los unos y ceros en la matriz son obtenidos despues de ubralizar con >=umbral. Más...

Métodos Digital Signal Processing
Herramientas genéricas
Pds::Vector	Pds::Matrix::HistogramNorm (int min=0, int max=255) const
	Retorna un vector con el histograma desde min hasta max (valores enteros). Elementos con valores menores a min o mayores a max no son computados en el histograma. El histograma és normalizado para que la suma sea igual a 1 de modo que pueda ser usada como una relación de probabilidades. Más...

double	Pds::Matrix::Corr (const Pds::Matrix &B) const
	Calcula la correlación de Pearson con la matriz. Más...

Pds::Matrix	Pds::Matrix::XCorr (const Pds::Matrix &B, bool Same=false) const
	Calcula la correlacion cruzada entre A y B. Más...

Pds::Matrix	Pds::Matrix::FilterMean (unsigned int r) const
	Procesa la matriz A usando un filtro mean de radio r. Más...

Pds::Matrix	Pds::Matrix::FilterMean3 (void) const
	Procesa la matriz A usando un filtro mean de radio 1. Más...

Pds::Matrix	Pds::Matrix::FilterMean3b (void) const
	Procesa la matriz A usando un filtro mean de radio 1. Más...

Pds::Matrix	Pds::Matrix::Resize (double factor) const
	Retorna una matriz B (size: NlinB,NcolB) resultado de aplicar un subsampling de la matriz A (size: Nlin,Ncol) por un factor. Más...

Métodos de álgebra lineal
Herramientas genéricas
double	Pds::Matrix::Det (void) const
	Calcula la determinante. Más...

double	Pds::Matrix::Dot (const Pds::Matrix &B) const
	Calcula el producto punto entre dos matrices. Más...

double	Pds::Matrix::Rms (void) const
	Calcula valor raiz quadrático medio de una matriz. Más...

double	Pds::Matrix::MeanAbsolute (void) const
	Calcula valor absoluto medio de una matriz. Más...

double	Pds::Matrix::MeanSquare (void) const
	Calcula valor quadrático medio de una matriz. Más...

double	Pds::Matrix::SumSquare (void) const
	Calcula valor de la suma quadrática de una matriz. Más...

double	Pds::Matrix::Norm (void) const
	Calcula la 2-norm de una matriz (Frobenius norm). Más...

double	Pds::Matrix::PNorm1 (void) const
	Calcula la 1-norm de un vector. Más...

double	Pds::Matrix::PNormInf (void) const
	Calcula la inf-norm de una matriz. Más...

Pds::Vector	Pds::Matrix::Multiindex (const Pds::Vector &d) const
	Dada una matriz $\mathbf{X}=\left[\mathbf{x}_1,\quad \mathbf{x}_2,\quad ...,\quad \mathbf{x}_n,\quad ...,\quad \mathbf{x}_N\right]$ es calculado el vector $\mathbf{\overline{X}}^{\mathbf{d}}$ . Más...

Métodos para find
Herramientas genéricas
std::vector< unsigned int >	Pds::Matrix::Find (void) const
	Retorna una lista de indices donde existe un 1 en la matriz A. Más...

Pds::Matrix	Pds::Matrix::FindRows (const Pds::Vector &B) const
	Retorna una nueva matriz con las lineas donde existe un 1 en la matriz B. En verdad B es binarizado internamente con (B>0.5). La matriz debe tener el mismo numero de lineas de B caso contrario se retorna una matriz vacia. Más...

Pds::Matrix	Pds::Matrix::FindRows (const Pds::Vector &B, double b) const
	Retorna una nueva matriz con las lineas donde existe un 1 en la matriz B. En verdad B es binarizado internamente con (B>b). La matriz debe tener el mismo numero de lineas de B caso contrario se retorna una matriz vacia. Más...

std::vector< Pds::Matrix >	Pds::Matrix::FindRowsBlock (const Pds::Vector &B) const
	Retorna dos nuevas matrices con las lineas donde existe un 0 (mat0) y un 1 (mat1) en la matriz B. En verdad B es binarizado internamente con (B>0.5). La matriz debe tener el mismo numero de lineas de B caso contrario se retorna una matriz vacia. Más...

Métodos para aplicar operaciones
Herramientas genéricas
bool	Pds::Matrix::Apply (double(*func)(double))
	Aplica la función func a cada elemento de la matriz. Más...

bool	Pds::Matrix::Apply (double(*func)(double), const Pds::Matrix &B)
	Aplica la función func a cada elemento de la matriz. Más...

bool	Pds::Matrix::Apply (double(*func)(double, double), double var)
	Aplica la función func a cada elemento de la matriz. Más...

bool	Pds::Matrix::ApplySub (double(*func)(double), const Pds::Matrix &B, const Pds::Matrix &C)
	Aplica la función func a cada elemento de la diferencia de matrices. Más...

bool	Pds::Matrix::ApplySub (const Pds::Matrix &B, const Pds::Matrix &C)
	Aplica la función func a cada elemento de la diferencia de matrices. Más...

bool	Pds::Matrix::ApplyInCol (unsigned int col, double(*func)(double))
	Aplica la función func a cada elemento de la columna col de la matriz. Más...

bool	Pds::Matrix::ApplyInCol (unsigned int col, double(*func)(double, double), double var)
	Aplica la función func a cada elemento de la columna col de la matriz. Más...

Métodos para operar Pds::Matrix
Herramientas genéricas
Pds::Matrix	Pds::Matrix::OperateRows (double(*func)(const Pds::Matrix &Row)) const
	Opera la función func usando como entrada cada fila de la matriz. Más...

Pds::Matrix	Pds::Matrix::OperateCols (double(*func)(const Pds::Matrix &Col)) const
	Opera la función func usando como entrada cada columna de la matriz. Más...

Pds::Matrix	Pds::Matrix::Scale (double minval, double maxval) const
	Rescala linearmente los datos desde minval a maxval. Más...

Pds::Matrix	Pds::Matrix::Round (unsigned int decimal=0) const
	Retorna una matriz con los valores redondeados. Más...

Métodos con regiones con Pds::Matrix.
Herramientas genéricas
bool	Pds::Matrix::CopyRegion (const Pds::RegionRect &Rin, const Pds::RegionRect &Rout, Pds::Matrix &Mout) const
	Copia la región Rin de la matriz a la región Rout de la matriz Mout. Más...

bool	Pds::Matrix::InitRegion (Pds::RegionRect R, double val)
	Inicializa la región R de la matriz con el valor val. Más...

Pds::RegionRect	Pds::Matrix::GetRegion (void) const
	Retorna una variable Pds::RegionRect desde la posicion (0,0), con ancho y alto (Mat.Nlin(),Mat.Ncol()). Más...

bool	Pds::Matrix::MeanOfRegion (const Pds::RegionRect &Rin, double *mean) const
	Calcula la media de los elementos en la region, pero para que sea calculado debe existir una interseccion diferente de zero con la matriz. Los valores fuera de la matriz son considerados cero. Más...

double	Pds::Matrix::MeanOfRegion (const Pds::RegionRect &Rin) const
	Calcula la media de los elementos en la region, pero para que sea calculado debe existir una interseccion diferente de zero con la matriz. Los valores fuera de la matriz son considerados cero. Más...

bool	Pds::Matrix::MeanSquareOfRegion (const Pds::RegionRect &Rin, double *mean) const
	Calcula la media del cuadrado de los elementos en la region, pero para que sea calculado debe existir una interseccion diferente de zero con la matriz. Los valores fuera de la matriz son considerados cero. Más...

double	Pds::Matrix::MeanSquareOfRegion (const Pds::RegionRect &Rin) const
	Calcula la media del cuadrado de los elementos en la region, pero para que sea calculado debe existir una interseccion diferente de zero con la matriz. Los valores fuera de la matriz son considerados cero. Más...

bool	Pds::Matrix::StdAndMeanOfRegion (const Pds::RegionRect &Rin, double std, double mean) const
	Calcula el desvío padrón y la media de los elementos de la intersección de la región con la matriz. Más...

bool	Pds::Matrix::CorrNormRegions (const Pds::Matrix &M1, const Pds::RegionRect &R0, const Pds::RegionRect &R1, double *corrn) const
	Calcula correlación normalizada entre los elementos de la intersección de la regiones con sus matrices. Más...

bool	Pds::Matrix::CorrNormRegions (const Pds::Matrix &M1, const Pds::RegionRect &R0, const Pds::RegionRect &R1, double means0, double means1, double *corrn) const
	Calcula correlación normalizada entre los elementos de la intersección de la regiones con sus matrices. Más...

bool	Pds::Matrix::CorrPearsonRegions (const Pds::Matrix &M1, const Pds::RegionRect &R0, const Pds::RegionRect &R1, double *pcc) const
	Calcula el coeficiente de correlación de Pearson (PCC) entre los elementos de la intersección de la regiones con sus matrices. Más...

bool	Pds::Matrix::CorrPearsonRegions (const Pds::Matrix &M1, const Pds::RegionRect &R0, const Pds::RegionRect &R1, double mean0, double mean1, double std0, double std1, double *pcc) const
	Calcula el coeficiente de correlación de Pearson (PCC) entre los elementos de la intersección de la regiones con sus matrices. Más...

Métodos variados con Pds::Matrix.
Herramientas genéricas
std::string	Pds::Matrix::ToString (void) const
	Convierte los datos de la matriz en un std::string. Más...

void	Pds::Matrix::Print (std::string str) const
	Imprime en pantalla el contenido de la matriz después del texto indicado en str. Más...

void	Pds::Matrix::Print (void) const
	Imprime en pantalla el contenido de la matriz. Más...

Métodos para reordenar memoria con Pds::Matrix.
Herramientas genéricas
void	Pds::Matrix::MakeEmpty (void)
	libera los datos internos de la matriz y la convierte en una matriz nula. es decir con lineas y columnas cero. Más...

bool	Pds::Matrix::Reshape (unsigned int Nlin, unsigned int Ncol)
	Remodela los datos internos de la array y la convierte en una array de tamaño diferente, los datos que faltan se rellenan con cero. Más...

bool	Pds::Matrix::FusionVer (std::list< Pds::Matrix > &list)
	Concatena verticalmente varias matrices. Si las matrices no tienen el mismo número de columnas se considera um error. Destruye las matrices en list. Este metodo es mas rapido que Pds::MergeVer(list) pues transplanta memoria. Más...

Métodos para exportar e importar datos con Pds::Matrix.
Herramientas genéricas que pueden ser usadas desde Pds::Matrix
bool	Pds::Matrix::SaveInStream (std::ofstream &myfile) const
	Escribe en un archivo de texto el contenido de la matriz. Más...

bool	Pds::Matrix::LoadFromStream (std::ifstream &ifs, unsigned int Nlin, unsigned int Ncol)
	Lee de un archivo una matriz de Nlin lineas y Ncol columnas. Si la lectura es satisfactoria el contenido actual de la matriz es liberado, en caso de error la matriz queda vacia, esdecir .IsEmpty() retorna true. Más...

bool	Pds::Matrix::LoadLineFromStream (std::ifstream &ifs)
	Lee una linea de un archivo y crea una matriz de Nlin=1 y Ncol columnas. Si la lectura es satisfactoria el contenido actual de la matriz es liberado, en caso de error la matriz queda vacia, esdecir .IsEmpty() retorna true. Más...

bool	Pds::Matrix::Save (const std::string &filepath) const
	Escribe en un archivo de texto el contenido de la matriz. Más...

bool	Pds::Matrix::Load (const std::string &filepath)
	Lee de un archivo una matriz de Nlin lineas y Ncol columnas. Si la lectura es satisfactoria el contenido actual de la matriz es liberado, en caso de error la matriz queda vacia, esdecir .IsEmpty() retorna true. Más...

bool	Pds::Matrix::ExportCsvFile (const std::string &filepath, char delimitador=',') const
	Escribe en un archivo de texto el contenido de la matriz usando un formato Csv (Comma Separated Values). Más...

bool	Pds::Matrix::ExportCsvFile (const std::string &filepath, std::vector< std::string > titles, char delimitador=',') const
	Escribe en un archivo de texto el contenido de la matriz usando un formato Csv (Comma Separated Values). Más...

bool	Pds::Matrix::ExportMatFile (const std::string &pname, const std::string &filepath) const
	Escribe en un archivo binario en formato de octave la matriz. Es necesario dar un nombre como identificador de matriz. Más...

bool	Pds::Matrix::ExportBmpFile (const unsigned char colormap[256][3], const std::string &filepath) const
	Escribe en una matriz en un archivo binario en formato BMP. Losdatos deben ir de 0 a 255, valores superiores o inferiores serán truncados. Más...

Métodos Static con Matrices con Pds::Matrix.
Herramientas genéricas que pueden ser usadas desde Pds::Matrix
static Pds::Matrix	Pds::Matrix::GetSamples (const std::vector< Pds::Matrix > &Block)
	Convierte las muestras de un bloque (std::vector<Pds::Matrix>) de N matrices (Pds::Matrix) de L elementos, en una matriz Pds::Matrix(L,N). Lee los datos de la columna actual y pasa a la siguiente, desde la columna 0. Más...

static Pds::Matrix	Pds::Matrix::GetSamples (const std::vector< Pds::Matrix > &Block, const std::vector< unsigned int > Id)
	Convierte M muestras de un bloque (std::vector<Pds::Matrix>) de N matrices (Pds::Matrix) de L elementos, en una matriz Pds::Matrix(M,N). Más...

static Pds::Matrix	Pds::Matrix::FromString (const std::string &str)
	Convierte un sdt::string a una Matriz de Nlin lineas y Ncol columnas. Más...

static bool	Pds::Matrix::ExportBmpFile (const Pds::Matrix &R, const Pds::Matrix &G, const Pds::Matrix &B, const std::string &bmpfilename)
	Escribe en una matriz en un archivo binario en formato BMP. Losdatos deben ir de 0 a 255, valores superiores o inferiores serán truncados. Más...

static std::vector< Pds::Matrix >	Pds::Matrix::ImportBmpFile (const std::string &bmpfilename)
	Lee matrices de un archivo binario en formato BMP. Más...

static Pds::Matrix	Pds::Matrix::MeanBlock (const std::vector< Pds::Matrix > &Block)
	Calcula A,la matriz media de un conjunto de N matrizes agrupadas en un std::vector. Más...

Operadores unarios y sus métodos equivalentes con Pds::Matrix.
Descripción de algunos operadores habilitados a trabajar con Pds::Matrix.
Pds::Matrix	Pds::Matrix::T (void) const
	Transpuesta de si mismo (A), el resultado es cargado en B. Más...

Pds::Matrix	Pds::Matrix::MtM (void) const
	Retorna A.T()*A cargado en B. Más...

Pds::Matrix	Pds::Matrix::Inv (double *rcond=NULL) const
	Retorna la matriz inversa. Más...

Pds::Matrix	Pds::Matrix::PInv (double *rcond=NULL) const
	Procesa esta matriz A y retorna B la matriz pseudo inversa de Moore Penrose. Más...

Pds::Matrix	Pds::Matrix::operator- (void) const
	Cambia de signo a si mismo (A), el resultado es cargado en B. Este operador es similar al método unario Minus. Más...

Pds::Matrix	Pds::Matrix::Minus (void) const
	Cambia de signo a si mismo (A), el resultado es cargado en B. Este método es similar al operador unario -. Más...

Pds::Matrix	Pds::Matrix::operator+ (void) const
	Asigna el signo + a si mismo (A), el resultado es cargado en B. Este operador es similar al método unario Plus. Más...

Pds::Matrix	Pds::Matrix::Plus (void) const
	Asigna el signo + a si mismo (A), el resultado es cargado en B. Este método es similar al operador unario +. Más...

Operadores binarios y sus métodos equivalentes con Pds::Matrix.
Descripción de algunos operadores habilitados a trabajar con Pds::Matrix.
Pds::Matrix	Pds::Matrix::operator* (double b) const
	Multiplica con sigo mismo (A), un valor b y el resultado es cargado en C. Este operador es similar al método Mul() Más...

Pds::Matrix	Pds::Matrix::operator* (const Pds::Matrix &B) const
	Multiplica con sigo mismo (A), una matriz B y el resultado es cargado en C. Este operador es similar al método Mul() Más...

Pds::Matrix	Pds::Matrix::Mul (double b) const
	Multiplica con sigo mismo (A), un valor b y el resultado es cargado en C. Este método es similar al operador *. Más...

Pds::Matrix	Pds::Matrix::Mul (const Pds::Matrix &B) const
	Multiplica con sigo mismo (A), una matriz B y el resultado es cargado en C. Este método es similar al operador *. Más...

Pds::Matrix	Pds::Matrix::Mul (const Pds::Vector &B) const
	Multiplica con sigo mismo (A), un vector B y el resultado es cargado en C. Este método es similar al operador *. Más...

Pds::Matrix	Pds::Matrix::MulComp (double b, const Pds::Vector &B) const
	Multiplica con sigo mismo (A), un vector [b;B] y el resultado es cargado en C. Este método es similar al operador *. Más...

bool	Pds::Matrix::MulComp (double b, const Pds::Vector &B, Pds::Vector &Out) const
	Multiplica con sigo mismo (A), un vector [b;B] y el resultado es cargado en Out. Este método es similar al operador *. Más...

Pds::Matrix	Pds::Matrix::MulT (const Pds::Matrix &B) const
	Multiplica con sigo mismo (A), la transpuesta de una matriz B y el resultado es cargado en C. Este método es similar al operador *. Más...

Pds::Matrix	Pds::Matrix::TMul (const Pds::Matrix &B) const
	Multiplica con la transpuesta de sí mismo (A^T), la matriz B y el resultado es cargado en C. Este método es similar al operador *. Más...

Pds::Matrix	Pds::Matrix::operator+ (double b) const
	[Elemento a elemento] Suma con sigo mismo (A), un valor b y el resultado es cargado en C. Este operador es similar al método Add() Más...

Pds::Matrix	Pds::Matrix::operator+ (const Pds::Matrix &B) const
	[Elemento a elemento] Suma con sigo mismo (A), una matriz B y el resultado es cargado en C. Este operador es similar al método Add() Más...

Pds::Matrix	Pds::Matrix::Add (double b) const
	[Elemento a elemento] Suma con sigo mismo (A), una valor b y el resultado es cargado en C. Este método es similar al operador + Más...

Pds::Matrix	Pds::Matrix::Add (const Pds::Matrix &B) const
	[Elemento a elemento] Suma con sigo mismo (A), una matriz B y el resultado es cargado en C. Este metodo es similar al operador + Más...

Pds::Matrix	Pds::Matrix::operator- (double b) const
	[Elemento a elemento] Resta con sigo mismo (A), un valor b y el resultado es cargado en C. Este operador es similar al método Sub() Más...

Pds::Matrix	Pds::Matrix::operator- (const Pds::Matrix &B) const
	[Elemento a elemento] Resta con sigo mismo (A), una matriz B y el resultado es cargado en C. Este operador es similar al método Sub Más...

Pds::Matrix	Pds::Matrix::Sub (double b) const
	[Elemento a elemento] Resta con sigo mismo (A), una valor b y el resultado es cargado en C. Este método es similar al operador - Más...

Pds::Matrix	Pds::Matrix::Sub (const Pds::Matrix &B) const
	[Elemento a elemento] Resta con sigo mismo (A), una matriz B y el resultado es cargado en C. Este método es similar al operador - Más...

Pds::Matrix	Pds::Matrix::AddRowMatrix (const Pds::Matrix &B) const
	Suma con sigo mismo (A), una matriz B linea y el resultado es cargado en C. La unica linea de B es sumada a cada linea de A. Más...

Pds::Matrix	Pds::Matrix::SubRowMatrix (const Pds::Matrix &B) const
	Resta con sigo mismo (A), una matriz B linea y el resultado es cargado en C. La unica linea de B es restada a cada linea de A. Más...

Pds::Matrix	Pds::Matrix::operator/ (double b) const
	[Elemento a elemento] Divide con sigo mismo (A), un valor b y el resultado es cargado en C. Este operador es similar al método Div() Más...

Pds::Matrix	Pds::Matrix::operator/ (const Pds::Matrix &B) const
	[Elemento a elemento] Divide con sigo mismo (A), elemento a elemento, una matriz B y el resultado es cargado en C. Este método es similar al método .Div() Más...

Pds::Matrix	Pds::Matrix::Div (double b) const
	[Elemento a elemento] Divide con sigo mismo (A), un valor b y el resultado es cargado en C. Este método es similar al operador / Más...

Pds::Matrix	Pds::Matrix::Div (const Pds::Matrix &B) const
	[Elemento a elemento] Divide con sigo mismo (A), elemento a elemento, una matriz B y el resultado es cargado en C. Este método es similar al operador / Más...

Pds::Matrix	Pds::Matrix::DivBelow (double b) const
	[Elemento a elemento] Divide con sigo mismo (A), un valor b y el resultado es cargado en C. Este método es similar al operador / Más...

Pds::Matrix	Pds::Matrix::operator& (const Pds::Matrix &B) const
	[Elemento a elemento] Multiplica con sigo mismo (A), elemento a elemento, una matriz B y el resultado es cargado en C. Este método es similar al método .Product() Más...

Pds::Matrix	Pds::Matrix::Product (const Pds::Matrix &B) const
	[Elemento a elemento] Multiplica con sigo mismo (A), elemento a elemento, una matriz B y el resultado es cargado en C. Este método es similar al operador & Más...

Pds::Matrix	Pds::Matrix::Product (double(*func)(double), const Pds::Matrix &B) const
	[Elemento a elemento] Multiplica con sigo mismo (A), elemento a elemento, una matriz func(B) y el resultado es cargado en C. Este método es similar al operador & Más...

bool	Pds::Matrix::ProductSelf (double b)
	Multiplica con sigo mismo (A), un valor b y el resultado es cargado en A. Más...

bool	Pds::Matrix::ProductSelf (const Pds::Matrix &B)
	[Elemento a elemento] Multiplica con sigo mismo (A), elemento a elemento, una matriz B y el resultado es cargado en A. Más...

bool	Pds::Matrix::ProductSelf (double(*func)(double), const Pds::Matrix &B)
	[Elemento a elemento] Multiplica con sigo mismo (A), elemento a elemento, una matriz func(B) y el resultado es cargado en A. Más...

bool	Pds::Matrix::ProductSelfMinus (double b, const Pds::Matrix &B)
	[Elemento a elemento] Multiplica con sigo mismo (A), elemento a elemento, una matriz (b-B) y el resultado es cargado en A. Más...

bool	Pds::Matrix::ProductSelfMinus (const Pds::Matrix &B, double b)
	[Elemento a elemento] Multiplica con sigo mismo (A), elemento a elemento, una matriz (B-b) y el resultado es cargado en A. Más...

bool	Pds::Matrix::ProductSelfPlus (double b, const Pds::Matrix &B)
	[Elemento a elemento] Multiplica con sigo mismo (A), elemento a elemento, una matriz (b+B) y el resultado es cargado en A. Más...

Pds::Matrix	Pds::Matrix::Pow (const Pds::Matrix &B) const
	[Elemento a elemento]Potencia asi mismo (A), elemento a elemento, con una matriz B y el resultado es cargado en C. Este método es similar al operador Más...

Pds::Matrix	Pds::Matrix::Pow (double val) const
	[Elemento a elemento] Potencia asi mismo (A), elemento a elemento, con un valor val y el resultado es cargado en C. Este método es similar al operador Más...

Pds::Matrix	Pds::Matrix::Geq (double b) const
	[Elemento a elemento] Calcula con sigo mismo (A), si (A) es mayor que un valor b y el resultado es cargado en C. Este método es similar al operador >= Más...

Pds::Matrix	Pds::Matrix::Geq (Pds::Matrix B) const
	[Elemento a elemento] Calcula con sigo mismo (A), si (A) es mayor que un valor (B) y el resultado es cargado en C. Este método es similar al operador >= Más...

Pds::Matrix	Pds::Matrix::Leq (double b) const
	[Elemento a elemento] Calcula con sigo mismo (A), si (A) es menor que un valor b y el resultado es cargado en C. Este método es similar al operador <= Más...

Pds::Matrix	Pds::Matrix::Leq (const Pds::Matrix &B) const
	[Elemento a elemento] Calcula con sigo mismo (A), si (A) es menor que un valor B y el resultado es cargado en C. Este método es similar al operador <= Más...

Pds::Matrix	Pds::Matrix::EqualTo (double b) const
	[Elemento a elemento] Calcula con sigo mismo (A), si (A) es identico a un valor b y el resultado es cargado en C. Este método es similar al operador == Más...

Pds::Matrix	Pds::Matrix::EqualTo (const Pds::Matrix &B) const
	[Elemento a elemento] Calcula con sigo mismo (A), si (A) es identico a un valor B y el resultado es cargado en C. Este método es similar al operador == Más...

Pds::Matrix	Pds::Matrix::NotEqualTo (double b) const
	[Elemento a elemento] Calcula con sigo mismo (A), si (A) no es identico a un valor b y el resultado es cargado en C. Este método es similar al operador != Más...

Pds::Matrix	Pds::Matrix::NotEqualTo (const Pds::Matrix &B) const
	[Elemento a elemento] Calcula con sigo mismo (A), si (A) no es identico a un valor B y el resultado es cargado en C. Este método es similar al operador != Más...

Pds::Matrix	Pds::Matrix::EqualToInf (void) const
	Verifica si la matriz tiene elementos con valores infinitos. Más...

Pds::Matrix	Pds::Matrix::EqualToNan (void) const
	Verifica si la matriz tiene elementos con valores NAN (Not A Number). Más...

Pds::Matrix	Pds::Matrix::EqualToFinite (void) const
	Verifica si la matriz tiene elementos con valores finitos (no +inf, no -inf y no NAN). Más...

Operadores binarios acumuladores y sus métodos equivalentes con Pds::Matrix.
Descripción de algunos operadores habilitados a trabajar con Pds::Matrix.
Pds::Matrix &	Pds::Matrix::operator-= (double b)
	Resta y acumula en si mismo (A), un valor b. Este operador es similar al método SubAssig() Más...

Pds::Matrix &	Pds::Matrix::operator-= (const Pds::Matrix &B)
	Resta y acumula en si mismo (A), una matriz B. Este operador es similar al método SubAssig() Más...

bool	Pds::Matrix::SubAssig (double b)
	Resta y acumula en si mismo (A), un valor b. Este es similar al operador -=. Más...

bool	Pds::Matrix::SubAssig (const Pds::Matrix &B)
	Resta y acumula en si mismo (A), una matriz B. Este es similar al operador -=. Más...

Pds::Matrix &	Pds::Matrix::operator+= (double b)
	Suma y acumula en si mismo (A), un valor b. Este operador es similar al método AddAssig() Más...

Pds::Matrix &	Pds::Matrix::operator+= (const Pds::Matrix &B)
	Suma y acumula en si mismo (A), una matriz B. Este operador es similar al método AddAssig() Más...

bool	Pds::Matrix::AddAssig (double b)
	Suma y acumula en si mismo (A), un valor b. Este es similar al perador +=. Más...

bool	Pds::Matrix::AddAssig (const Pds::Matrix &B)
	Suma y acumula en si mismo (A), una matriz B. Este es similar al perador +=. Más...

bool	Pds::Matrix::AddAssig (double alpha, const Pds::Matrix &B)
	Suma y acumula en si mismo (A), una matriz B. Más...

bool	Pds::Matrix::AddAssig (double alpha, const Pds::Matrix &B, double beta, const Pds::Matrix &C)
	Suma y acumula en si mismo (A), una matriz B. Más...

bool	Pds::Matrix::AddAssigAt (unsigned int lin, unsigned int col, const Pds::Matrix &B)
	Suma y acumula en si mismo (A), una matriz B desde un punto (lin,col) haciendo una intersección. Más...

Pds::Matrix &	Pds::Matrix::operator*= (double b)
	Multiplica y acumula en si mismo (A), un valor b. Este operador es similar al método MulAssig() Más...

Pds::Matrix &	Pds::Matrix::operator*= (const Pds::Matrix &B)
	Multiplica y acumula en si mismo (A), una matriz B. Este operador es similar al método MulAssig() Más...

bool	Pds::Matrix::MulAssig (double b)
	Multiplica y acumula en si mismo (A), un valor b. Este es similar al operador *=. Más...

bool	Pds::Matrix::MulAssig (const Pds::Matrix &B)
	Multiplica y acumula en si mismo (A), una matriz B. Este es similar al operador *=. Más...

Pds::Matrix &	Pds::Matrix::operator= (const Pds::Matrix &B)
	Copia en si mismo (A), una matriz B. Este operador es similar al método Copy(). No importa el tamaño de A, sus datos son liberados y un nuevo arreglo de datos es reservado. Más...

bool	Pds::Matrix::Copy (const Pds::Matrix &B)
	Copia en si mismo (A), el contenido de una matriz B. Este método es similar a usar el operador = . No importa el tamaño de A, sus datos son liberados y un nuevo arreglo de datos es reservado. Más...

Pds::Matrix &	Pds::Matrix::operator= (double val)
	Copia en si mismo (A), el valor val. Este operador es similar al método Copy(). No importa el tamaño de A, sus datos son liberados y un nuevo arreglo de datos de 1x1 es reservado. Más...

bool	Pds::Matrix::Copy (double val)
	Copia en si mismo (A), el valor val. Este método es similar a usar el operador = . No importa el tamaño de A, sus datos son liberados y un nuevo arreglo de datos de 1x1 es reservado. Más...

template<class Datum >
Pds::Matrix &	Pds::Matrix::operator= (const Pds::Array< Datum > &B)
	Copia en si mismo (A), una array B. Este operador es similar al método Copy(). No importa el tamaño de A, sus datos son liberados y un nuevo arreglo de datos es reservado. Más...

template<class Datum >
bool	Pds::Matrix::Copy (const Pds::Array< Datum > &B)
	Copia en si mismo (A), el contenido de una Array B. Este método es similar a usar el operador = . No importa el tamaño de A, sus datos son liberados y un nuevo arreglo de datos es reservado. Más...

Métodos exoticos con Pds::Matrix
Descripción de algunos operadores habilitados a trabajar con Pds::Matrix.
Pds::Matrix	Pds::Matrix::MultipleMse (const Pds::Matrix &B) const
	Calcula el error quadrático medio de cada linea de A con cada linea de B. Más...

Pds::Matrix	Pds::Matrix::MultipleMse (const std::vector< Pds::Matrix > &Block) const
	Calcula el error quadrático medio de cada linea de A con cada muestra en el bloque Block. Más...

Pds::Array< unsigned int >	Pds::Matrix::IdInMultipleMse (const Pds::Matrix &B) const
	Calcula que linea de A es mas cercana a cada linea de B. Más...

Pds::Array< unsigned int >	Pds::Matrix::IdInMultipleMse (const std::vector< Pds::Matrix > &Block) const
	Calcula que linea de A es mas cercana a cada muestra de Block. Más...

Métodos Static con arrays
Herramientas genéricas que pueden ser usadas desde Pds::Matrix
static double **	Pds::Matrix::ArrayAllocate (double(*func)(double), const Pds::Matrix &A)
	crea dinámicamente un arreglo de A.Nlin() lineas y A.Ncol() columnas, con los datos copiados de aplicar func(A). Más...

static double **	Pds::Matrix::ArrayAllocate (double(*func)(double, double), const Pds::Matrix &A, double var)
	crea dinámicamente un arreglo de A.Nlin() lineas y A.Ncol() columnas, con los datos copiados de aplicar func(A,var). Más...

static double **	Pds::Matrix::ArrayAllocate (double(*func)(double, double), const Pds::Matrix &A, const Pds::Matrix &B)
	crea dinámicamente un arreglo de A.Nlin() lineas y A.Ncol() columnas, con los datos copiados de aplicar func(A,B). Los tamaño de A y B son similares. Más...

static double **	Pds::Matrix::ArrayAllocate (double(*func)(double, double, double), const Pds::Matrix &A, const Pds::Matrix &B, double var)
	crea dinámicamente un arreglo de A.Nlin() lineas y A.Ncol() columnas, con los datos copiados de aplicar func(A,B,var). Los tamaño de A y B son similares. Más...

static double **	Pds::Matrix::ArrayAllocate (double(*func)(double, double, double), const Pds::Matrix &A, const Pds::Matrix &B, const Pds::Matrix &C)
	crea dinámicamente un arreglo de A.Nlin() lineas y A.Ncol() columnas, con los datos copiados de aplicar func(A,B,C). Los tamaño de A, B y C son similares. Más...

static double **	Pds::Matrix::ArrayAllocate (double(*func)(double, double, double, double), const Pds::Matrix &A, const Pds::Matrix &B, const Pds::Matrix &C, double var)
	crea dinámicamente un arreglo de A.Nlin() lineas y A.Ncol() columnas, con los datos copiados de aplicar func(A,B,C,var). Los tamaño de A, B y C son similares. Más...

static double **	Pds::Matrix::ArrayAllocate (double(*func)(double, double, double, double), const Pds::Matrix &A, const Pds::Matrix &B, const Pds::Matrix &C, const Pds::Matrix &D)
	crea dinámicamente un arreglo de A.Nlin() lineas y A.Ncol() columnas, con los datos copiados de aplicar func(A,B,C,D). Los tamaño de A, B, C y D son similares. Más...

Operadores no miembros
Descripcion de algunos operadores habilitados a trabajar con Pds::Matrix.
std::ostream &	operator<< (std::ostream &out, const Pds::Matrix &mat)
	Retorna el contenido de la matriz por la salida estándar. Más...

Pds::Matrix	operator+ (double b, const Pds::Matrix &A)
	Suma b con (A), el resultado es cargado en C. Este operador es similar al método Add() Más...

Pds::Matrix	operator- (double b, const Pds::Matrix &A)
	Resta b con (A), el resultado es cargado en C. Este operador es similar al método Add() Más...

Pds::Matrix	operator* (double b, const Pds::Matrix &A)
	Multiplica b con (A), el resultado es cargado en C. Este operador es similar al método Mul() Más...

Pds::Matrix	operator/ (double b, const Pds::Matrix &A)
	Divide b con (A), elemento a elemento y el resultado es cargado en C. Este operador es similar al método DivSelf() Más...

Descripción detallada

Métodos de la clase Pds::Matrix, una matriz.

#include <Pds/Matrix>

Estas funciones trabajan con una matriz de la forma.

$\mathbf{A}=\left(\begin{matrix} a_{00} & a_{01} & \cdots & a_{0(Ncol-1)}\\ a_{10} & a_{11} & \cdots & a_{1(Ncol-1)}\\ \vdots & \vdots & \vdots & \vdots \\ a_{(Nlin-2)0} & a_{(Nlin-2)1} & \cdots & a_{(Nlin-2)(Ncol-1)}\\ a_{(Nlin-1)0} & a_{(Nlin-1)1} & \cdots & a_{(Nlin-1)(Ncol-1)}\\ \end{matrix}\right)$

$A\equiv [a_{i,j}]$

Nlin es el número de lineas y Ncol es el número de columnas.

Información adicional puede ser encontrada en [1]

Documentación de las funciones

◆ Matrix() [1/17]

Pds::Matrix::Matrix ( void )

Crea un objeto de tipo Pds::Matrix vacio.

$\mathbf{A}\equiv []$

Para crear una matriz vacia:

Pds::Matrix A;
 
if(A.IsEmpty()) std::cout<<"Yes,always\n";

◆ Matrix() [2/17]

Pds::Matrix::Matrix ( unsigned int N )

Crea un objeto de tipo Pds::Matrix de N lineas y N columnas, con elementos inicializados con cero.

$\mathbf{A}=\left(\begin{matrix} 0 & 0 & \cdots & 0\\ 0 & 0 & \cdots & 0\\ \vdots & \vdots & \vdots & \vdots \\ 0 & 0 & \cdots & 0\\ 0 & 0 & \cdots & 0\\ \end{matrix}\right)$

$A_{N,N}\equiv [0]$

Para crear una matriz A de 4 filas y 4 columnas:

Pds::Matrix A(4);
 
if(A.IsEmpty()) std::cout<<"Yes,possible memory allocation problem\n";
else            std::cout<<"No,all fine\n";

Parámetros

[in] N El numero de lineas y columnas de la matriz.

◆ Matrix() [3/17]

Pds::Matrix::Matrix ( const Pds::Size & S )

Crea un objeto de tipo Pds::Matrix con elementos inicializados con cero.

$\mathbf{A}=\left(\begin{matrix} 0 & 0 & \cdots & 0\\ 0 & 0 & \cdots & 0\\ \vdots & \vdots & \vdots & \vdots \\ 0 & 0 & \cdots & 0\\ 0 & 0 & \cdots & 0\\ \end{matrix}\right)$

$A\equiv [0]$

Para crear una matriz A de 4 filas y 3 columnas:

Pds::Matrix B(4,3);
Pds::Matrix A(B.Size);
 
if(A.IsEmpty()) std::cout<<"Yes,possible memory allocation problem\n";
else            std::cout<<"No,all fine\n";

Parámetros

[in] S El tamaño de la matriz.

◆ Matrix() [4/17]

Pds::Matrix::Matrix ( const Pds::Matrix & B )

Crea un objeto de tipo Pds::Matrix copiando datos desde otra matriz. Este es un Copy assignment constructor.

$B\equiv [b_{i,j}]$

$\mathbf{A} \leftarrow \mathbf{B}$

Para crear una matriz A con copia de datos de una matriz B:

Pds::Matrix B(4,3,-1.0);
Pds::Matrix A(B);
 
if(A.IsEmpty()) std::cout<<"Yes,possible memory allocation problem\n";
else            std::cout<<"No,all fine\n";

Parámetros

[in] B Matriz a copiar.

◆ Matrix() [5/17]

template<class Datum >

Pds::Matrix::Matrix ( const Pds::Array< Datum > & B )

Crea un objeto de tipo Pds::Matrix copiando datos desde un arreglo.

$B\equiv [b_{i,j}]$

$\mathbf{A} \leftarrow \mathbf{B}$

Parámetros

[in] B Array a copiar.

◆ Matrix() [6/17]

Pds::Matrix::Matrix ( const char * str )

Crea un objeto de tipo Pds::Matrix copiando datos desde una cadena.

Para crear una matriz A con los datos de una cadena:

Pds::Matrix A="1 2 3\n4 5 6\n";
 
if(A.IsEmpty()) std::cout<<"Yes,possible memory allocation problem\n";
else            std::cout<<"No,all fine\n";

Parámetros

[in] str Cadena a leer.

◆ Matrix() [7/17]

Pds::Matrix::Matrix ( const std::string & str )

Crea un objeto de tipo Pds::Matrix copiando datos desde una std::string.

Para crear una matriz A con los datos de una cadena:

std::string str=="1 2 3\n4 5 6\n";
Pds::Matrix A(str);
 
if(A.IsEmpty()) std::cout<<"Yes,possible memory allocation problem\n";
else            std::cout<<"No,all fine\n";

Parámetros

[in] str Cadena a leer.

◆ Matrix() [8/17]

Pds::Matrix::Matrix	(	unsigned int	Nlin,
		unsigned int	Ncol
	)

Crea un objeto de tipo Pds::Matrix con elementos inicializados con cero.

$\mathbf{A}=\left(\begin{matrix} 0 & 0 & \cdots & 0\\ 0 & 0 & \cdots & 0\\ \vdots & \vdots & \vdots & \vdots \\ 0 & 0 & \cdots & 0\\ 0 & 0 & \cdots & 0\\ \end{matrix}\right)$

$A\equiv [0]$

Para crear una matriz A de 4 filas y 3 columnas:

Pds::Matrix A(4,3);
 
if(A.IsEmpty()) std::cout<<"Yes,possible memory allocation problem\n";
else            std::cout<<"No,all fine\n";

Parámetros

[in]	Nlin	El numero de lineas de la matriz.
[in]	Ncol	El numero de columnas de la matriz.

◆ Matrix() [9/17]

Pds::Matrix::Matrix	(	unsigned int	Nlin,
		unsigned int	Ncol,
		double	val
	)

Crea un objeto de tipo Pds::Matrix con elementos inicializados con val.

$\mathbf{A}=\left(\begin{matrix} val & val & \cdots & val\\ val & val & \cdots & val\\ \vdots & \vdots & \vdots & \vdots \\ val & val & \cdots & val\\ val & val & \cdots & val\\ \end{matrix}\right)$

$A\equiv [val]$

Para crear una matriz A de 4 filas y 3 columnas inicializado con -1:

Pds::Matrix A(4,3,-1.0);
 
if(A.IsEmpty()) std::cout<<"Yes,possible memory allocation problem\n";
else            std::cout<<"No,all fine\n";

Parámetros

[in]	Nlin	El numero de lineas de la matriz.
[in]	Ncol	El numero de columnas de la matriz.
[in]	val	El valor a usar.

◆ Matrix() [10/17]

Pds::Matrix::Matrix	(	double(*)(double)	func,
		const Pds::Matrix &	B
	)

Crea un objeto de tipo Pds::Matrix, evaluando mediante una función, los datos de otra matriz.

$B\equiv [b_{i,j}]$

$\mathbf{A} \leftarrow func(\mathbf{B})$

Para crear una matriz A , copia de sin(B):

Pds::Matrix B(4,3,1.0);
Pds::Matrix A(sin,B);
 
if(A.IsEmpty()) std::cout<<"Yes,possible memory allocation problem\n";
else            std::cout<<"No,all fine\n";

Parámetros

[in]	func	Función a aplicar, esta debe tener a forma double func(double).
[in]	B	Matriz a evaluar para copiar los resultados.

◆ Matrix() [11/17]

Pds::Matrix::Matrix	(	double(*)(double, double)	func,
		const Pds::Matrix &	B,
		double	var
	)

Crea un objeto de tipo Pds::Matrix, evaluando mediante una función, los datos de otra matriz.

$B\equiv [b_{i,j}]$

$\mathbf{A} \leftarrow func(\mathbf{B},var)$

Para crear una matriz A , copia de pow(B,3):

Pds::Matrix B(4,3,2.0);
Pds::Matrix A(pow,B,3);
 
if(A.IsEmpty()) std::cout<<"Yes,possible memory allocation problem\n";
else            std::cout<<"No,all fine\n";

Parámetros

[in]	func	Función a aplicar, esta debe tener a forma double func(double,double).
[in]	B	Matriz a evaluar para copiar los resultados.
[in]	var	Segunda variable de la función.

◆ Matrix() [12/17]

Pds::Matrix::Matrix	(	double(*)(double, double)	func,
		const Pds::Matrix &	B,
		const Pds::Matrix &	C
	)

Crea un objeto de tipo Pds::Matrix, evaluando mediante una función, los datos de otra matriz.

$B\equiv [b_{ij}], \qquad C\equiv [c_{ij}]$

$\mathbf{A} \leftarrow func(\mathbf{B},\mathbf{C})$

$\mathbf{a}_{ij} \leftarrow func(\mathbf{b}_{ij},\mathbf{c}_{ij})$

Para crear una matriz A , copia de pow(B,C):

Pds::Matrix B(2,3,2.0);
Pds::Matrix C(2,3,3.0);
Pds::Matrix A(pow,B,C);
 
if(A.IsEmpty()) std::cout<<"Yes,possible memory allocation problem\n";
else            std::cout<<"No,all fine\n";

Parámetros

[in]	func	Función a aplicar elemento a elemento en las matrices, esta debe tener a forma double func(double,double).
[in]	B	Matriz a evaluar para copiar los resultados.
[in]	C	Matriz a evaluar para copiar los resultados.

◆ Matrix() [13/17]

Pds::Matrix::Matrix	(	double(*)(double, double, double)	func,
		const Pds::Matrix &	B,
		const Pds::Matrix &	C,
		double	var
	)

Crea un objeto de tipo Pds::Matrix, evaluando mediante una función, los datos de otra matriz.

$B\equiv [b_{ij}], \qquad C\equiv [c_{ij}]$

$\mathbf{A} \leftarrow func(\mathbf{B},\mathbf{C},var)$

$\mathbf{a}_{ij} \leftarrow func(\mathbf{b}_{ij},\mathbf{c}_{ij},var)$

Para crear una matriz A , copia de func(B,C,var):

Pds::Matrix B(2,3,2.0);
Pds::Matrix C(2,3,3.0);
double var=2;
Pds::Matrix A(func,B,C,var);
 
if(A.IsEmpty()) std::cout<<"Yes,possible memory allocation problem\n";
else            std::cout<<"No,all fine\n";

Parámetros

[in]	func	Función a aplicar elemento a elemento en las matrices, esta debe tener a forma double func(double,double,double).
[in]	B	Matriz a evaluar para copiar los resultados.
[in]	C	Matriz a evaluar para copiar los resultados.
[in]	var	Tercera variable de la función.

◆ Matrix() [14/17]

Pds::Matrix::Matrix	(	double(*)(double, double, double)	func,
		const Pds::Matrix &	X,
		const Pds::Matrix &	Y,
		const Pds::Matrix &	Z
	)

Crea un objeto de tipo Pds::Matrix, evaluando mediante una función, los datos de otra matriz.

$X\equiv [x_{ij}], \qquad Y\equiv [y_{ij}], \qquad Z\equiv [z_{ij}]$

$\mathbf{A} \leftarrow func(\mathbf{X},\mathbf{Y},\mathbf{Z})$

$\mathbf{a}_{ij} \leftarrow func(\mathbf{x}_{ij},\mathbf{y}_{ij},\mathbf{z}_{ij})$

Para crear una matriz A , copia de func(X,Y,Z):

Pds::Matrix X(2,3,2.0);
Pds::Matrix Y(2,3,3.0);
Pds::Matrix Z(2,3,1.0);
Pds::Matrix A(func,X,Y,Z);
 
if(A.IsEmpty()) std::cout<<"Yes,possible memory allocation problem\n";
else            std::cout<<"No,all fine\n";

Parámetros

[in]	func	Función a aplicar elemento a elemento en las matrices, esta debe tener a forma double func(double,double,double).
[in]	X	Matriz a evaluar para copiar los resultados.
[in]	Y	Matriz a evaluar para copiar los resultados.
[in]	Z	Matriz a evaluar para copiar los resultados.

◆ Matrix() [15/17]

Pds::Matrix::Matrix	(	double(*)(double, double, double, double)	func,
		const Pds::Matrix &	X,
		const Pds::Matrix &	Y,
		const Pds::Matrix &	Z,
		double	var
	)

Crea un objeto de tipo Pds::Matrix, evaluando mediante una función, los datos de otra matriz.

$X\equiv [x_{ij}], \qquad Y\equiv [y_{ij}], \qquad Z\equiv [z_{ij}]$

$\mathbf{A} \leftarrow func(\mathbf{X},\mathbf{Y},\mathbf{Z},var)$

$\mathbf{a}_{ij} \leftarrow func(\mathbf{x}_{ij},\mathbf{y}_{ij},\mathbf{z}_{ij},var)$

Para crear una matriz A , copia de func(X,Y,Z,var):

Pds::Matrix X(2,3,2.0);
Pds::Matrix Y(2,3,3.0);
Pds::Matrix Z(2,3,1.0);
double var=2;
Pds::Matrix A(func,X,Y,Z,var);
 
if(A.IsEmpty()) std::cout<<"Yes,possible memory allocation problem\n";
else            std::cout<<"No,all fine\n";

Parámetros

[in]	func	Función a aplicar elemento a elemento en las matrices, esta debe tener a forma double func(double,double,double,double).
[in]	X	Matriz a evaluar para copiar los resultados.
[in]	Y	Matriz a evaluar para copiar los resultados.
[in]	Z	Matriz a evaluar para copiar los resultados.
[in]	var	Cuarto valor a evaluar.

◆ Matrix() [16/17]

Pds::Matrix::Matrix	(	double(*)(double, double, double, double)	func,
		const Pds::Matrix &	X,
		const Pds::Matrix &	Y,
		const Pds::Matrix &	Z,
		const Pds::Matrix &	W
	)

Crea un objeto de tipo Pds::Matrix, evaluando mediante una función, los datos de otra matriz.

$X\equiv [x_{ij}], \qquad Y\equiv [y_{ij}], \qquad Z\equiv [z_{ij}], \qquad W\equiv [w_{ij}]$

$\mathbf{A} \leftarrow func(\mathbf{X},\mathbf{Y},\mathbf{Z},\mathbf{W})$

$\mathbf{a}_{ij} \leftarrow func(\mathbf{x}_{ij},\mathbf{y}_{ij},\mathbf{z}_{ij},\mathbf{w}_{ij})$

Para crear una matriz A , copia de func(X,Y,Z,W):

Pds::Matrix X(2,3,2.0);
Pds::Matrix Y(2,3,3.0);
Pds::Matrix Z(2,3,1.0);
Pds::Matrix W(2,3,1.0);
Pds::Matrix A(func,X,Y,Z,W);
 
if(A.IsEmpty()) std::cout<<"Yes,possible memory allocation problem\n";
else            std::cout<<"No,all fine\n";

Parámetros

[in]	func	Función a aplicar elemento a elemento en las matrices, esta debe tener a forma double func(double,double,double,double).
[in]	X	Matriz a evaluar para copiar los resultados.
[in]	Y	Matriz a evaluar para copiar los resultados.
[in]	Z	Matriz a evaluar para copiar los resultados.
[in]	W	Matriz a evaluar para copiar los resultados.

◆ Matrix() [17/17]

Pds::Matrix::Matrix	(	Pds::Ra::FormatType	Type,
		std::string	filepath
	)

Crea un objeto de tipo Pds::Matrix copiando datos desde un archivo.

Pds::Matrix A(Pds::Ra::TextFormat,"textfile.txt");
 
if(A.IsEmpty()) std::cout<<"Yes,possible memory allocation problem\n";
else            std::cout<<"No,all fine\n";

Parámetros

[in]

Type

Tipo de archivo de fuente de datos. Los tipos aceptados son:

Pds::Ra::TextFormat

Lee en formato de texto.

[in] filepath Path del archivo cargado.

◆ IsEmpty()

bool Pds::Matrix::IsEmpty ( void ) const

Verifica si la matriz es nula es decir con lineas o columnas cero o arreglo NULL.

Una matriz $\mathbf{A}$ está vacía si $\mathbf{A}=[]$ .

Devuelve: Retorna true si es nula e false si no.

◆ IsNotEmpty()

bool Pds::Matrix::IsNotEmpty ( void ) const

Verifica si la matriz NO es nula, es decir con lineas y columnas diferentes cero y arreglo diferente de NULL.

Una matriz $\mathbf{A}$ está vacía si $\mathbf{A}=[]$ .

Devuelve: Retorna true si NO es nula e false si lo es.

◆ IsSimilarTo()

bool Pds::Matrix::IsSimilarTo ( const Pds::Matrix & B ) const

Verifica si las matrices son similares en tamaño.

Una matriz $A_{M,N}$ es similar a $B_{P,Q}$ si y .

Parámetros

[in] B Matriz en consulta.

Devuelve: Retorna true si son similares y false si no.

◆ IsNotSimilarTo()

bool Pds::Matrix::IsNotSimilarTo ( const Pds::Matrix & B ) const

Verifica si las matrices son similares en tamaño.

Una matriz $A_{M,N}$ es similar a $B_{P,Q}$ si y .

Parámetros

[in] B Matriz en consulta.

Devuelve: Retorna false si son similares y true si no.

◆ IsMulBy()

bool Pds::Matrix::IsMulBy ( const Pds::Matrix & B ) const

Verifica si las matrices son multiplicables.

Una matriz $A_{M,N}$ es multiplicable por $B_{P,Q}$ si y ambas son no vacías.

Parámetros

[in] B Matriz en consulta.

Devuelve: Retorna true si son multiplicables y false si no.

◆ IsNotMulBy()

bool Pds::Matrix::IsNotMulBy ( const Pds::Matrix & B ) const

Verifica si las matrices son multiplicables.

Una matriz $A_{M,N}$ es multiplicable por $B_{P,Q}$ si y ambas son no vacías.

Parámetros

[in] B Matriz en consulta.

Devuelve: Retorna false si son multiplicables y true si no.

◆ IsInRange()

bool Pds::Matrix::IsInRange	(	unsigned int	lin,
		unsigned int	col
	)		const

Verifica si la posición pertenece a la matriz.

Dada una matriz $A_{M,N}$ ; la posición está en rango de $\mathbf{A}$ si cualquier valor entero de $0\leq lin \leq M-1$ y cualquier valor entero de $0\leq col \leq N-1$ .

Parámetros

[in]	lin	Linea en consulta.
[in]	col	columna en consulta.

Devuelve: Retorna true si pertenece y false si no.

◆ IsNotInRange()

bool Pds::Matrix::IsNotInRange	(	unsigned int	lin,
		unsigned int	col
	)		const

Verifica si la posición NO pertenece a la matriz.

Dada una matriz $A_{M,N}$ ; la posición está en rango de $\mathbf{A}$ si cualquier valor entero de $0\leq lin \leq M-1$ y cualquier valor entero de $0\leq col \leq N-1$ .

Parámetros

[in]	lin	Linea en consulta.
[in]	col	columna en consulta.

Devuelve: Retorna false si pertenece y true si no.

◆ IsInSizeRange()

bool Pds::Matrix::IsInSizeRange	(	double	lin,
		double	col
	)		const

Verifica si la posición (lin,col) pertenece al rango de la matriz.

Dada una matriz $A_{M,N}$ ; la posición está en rango de $\mathbf{A}$ si cualquier valor real de $0\leq lin \leq M-1$ y cualquier valor real de $0\leq col \leq N-1$ .

Parámetros

[in]	lin	Linea en consulta.
[in]	col	columna en consulta.

Devuelve: Retorna true si pertenece y false si no.

◆ IsRowMatrix()

bool Pds::Matrix::IsRowMatrix ( void ) const

Verifica si la matriz tiene solo una linea.

Devuelve: Retorna true si la matriz tiene solo una linea o false si no. Si la matriz está vacia se retorna false.

◆ IsColMatrix()

bool Pds::Matrix::IsColMatrix ( void ) const

Verifica si la matriz tiene solo una columna.

Devuelve: Retorna true si la matriz tiene solo una columna o false si no. Si la matriz está vacia se retorna false.

◆ IsZero()

bool Pds::Matrix::IsZero ( void ) const

Verifica si la matriz está llena de zeros.

$true \overleftarrow{IsZero} \left(\begin{matrix} 0 & 0 & \cdots & 0\\ 0 & 0 & \cdots & 0\\ \vdots & \vdots & \vdots & \vdots \\ 0 & 0 & \cdots & 0\\ 0 & 0 & \cdots & 0\\ \end{matrix}\right)$

Devuelve: Retorna true si la matriz está llena de zeros o false si no. Si la matriz está vacia se retorna false.

◆ IsLeq() [1/2]

bool Pds::Matrix::IsLeq ( double val ) const

Verifica si cada elemento de la matriz es menor a el valor val.

$\mathbf{A}~<=~val$

Parámetros

[in] val El valor a comparar.

Devuelve: Retorna true si todos los elementos son menores que val y false si no.

◆ IsLeq() [2/2]

bool Pds::Matrix::IsLeq ( const Pds::Matrix & B ) const

Verifica si cada elemento de la matriz es menor igual a cada elemento de la matriz B.

$\mathbf{A}~<=~\mathbf{B}$

Parámetros

[in] B Matriz a comparar.

Devuelve: Retorna true si todos los elementos son menores y false si no.

◆ IsGeq() [1/2]

bool Pds::Matrix::IsGeq ( double val ) const

Verifica si cada elemento de la matriz es mayor a el valor val.

$\mathbf{A}~>=~val$

Parámetros

[in] val El valor a comparar.

Devuelve: Retorna true si todos los elementos son mayores que val y false si no.

◆ IsGeq() [2/2]

bool Pds::Matrix::IsGeq ( const Pds::Matrix & B ) const

Verifica si cada elemento de la matriz es mayor igual a cada elemento de la matriz B.

$\mathbf{A}~>=~\mathbf{B}$

Parámetros

[in] B Matriz a comparar.

Devuelve: Retorna true si todos los elementos son mayores y false si no.

◆ IsEqualTo() [1/2]

bool Pds::Matrix::IsEqualTo ( double val ) const

Verifica si cada elemento de la matriz es igual a el valor val.

$\mathbf{A}~==~val$

Parámetros

[in] val El valor a comparar.

Devuelve: Retorna true si todos los elementos son iguale a val y false si no.

◆ IsEqualTo() [2/2]

bool Pds::Matrix::IsEqualTo ( const Pds::Matrix & B ) const

Verifica si cada elemento de la matriz es igual a cada elemento de la matriz B.

$\mathbf{A}~==~\mathbf{B}$

Parámetros

[in] B Matriz a comparar.

Devuelve: Retorna true si todos los elementos son iguales y false si no.

◆ HasInf()

bool Pds::Matrix::HasInf ( void ) const

Verifica si la matriz tiene algun valor infinito.

Los valores infinitos pueden producirse con $+\frac{1}{0},-\frac{1}{0} y \frac{1}{0}$ .

$true\qquad \overleftarrow{HasInf()}\qquad \left(\begin{matrix} 1 & NaN & NaN\\ 0 & 2 & -\infty\\ \infty & 0 & 0\\ 3 & -\infty & NaN\\ \end{matrix}\right)$

Devuelve: Retorna true si tiene algun elemento infinito y false si no lo tiene.

◆ HasNan()

bool Pds::Matrix::HasNan ( void ) const

Verifica si la matriz tiene algun valor NAN (Not A Number).

Los valores NAN pueden producirse con $\frac{0}{0}$ .

$true\qquad \overleftarrow{EqualToNan()}\qquad \left(\begin{matrix} 1 & NaN & NaN\\ 0 & 2 & -\infty\\ \infty & 0 & 0\\ 3 & -\infty & NaN\\ \end{matrix}\right)$

Devuelve: Retorna true si tiene NAN y false si no lo tiene.

◆ HasNotFinite()

bool Pds::Matrix::HasNotFinite ( void ) const

Verifica si la matriz tiene elementos no finitos (+inf, -inf y NAN).

$true\qquad \overleftarrow{EqualToFinite()}\qquad \left(\begin{matrix} 1 & NaN & NaN\\ 0 & 2 & -\infty\\ \infty & 0 & 0\\ 3 & -\infty & NaN\\ \end{matrix}\right)$

Devuelve: Retorna true si tiene un valor no finito y false si no lo tiene.

◆ FillRandC()

bool Pds::Matrix::FillRandC ( double p1 )

Inicializa la matriz con números aleatórios unos y ceros, la probabilidad de 1 es p1.

Atención: La función usa internamente la función rand(), si se desea esta puede ser aleatoriamente inicializada usando la funcíón Pds::Ra::Randomize(), de lo contrario los números pseudo aleatórios siempre seguirán la misma secuencia.

Parámetros

[in] p1 Probabilidad de acontecer un 1.

Devuelve: Retorna true si todo fue bien o false si no.

◆ FillRandN() [1/2]

bool Pds::Matrix::FillRandN ( void )

Inicializa la matriz con números aleatórios, distribuidos usando una distribución Gaussiana normalizada con media 0 y desvío padrón 1.0.

Atención: La función usa internamente la función rand(), si se desea esta puede ser aleatoriamente inicializada usando la funcíón Pds::Ra::Randomize(), de lo contrario los números pseudo aleatórios siempre seguirán la misma secuencia.

$f_{X}(x)=\frac {1}{\sqrt {2\pi }} e^{-{\frac {1}{2}}x^{2}},~~x \in R$

$\mathbf{A}\equiv [a_{i,j}]_{M,N}$

$a_{i,j}\leftarrow X_{l} \in X$

Devuelve: Retorna true si todo fue bien o false si no.

◆ FillRandN() [2/2]

bool Pds::Matrix::FillRandN	(	double	U,
		double	Sigma
	)

Inicializa la matriz con números aleatórios, distribuidos usando una distribución Gaussiana con media U y desvío padrón Sigma.

Atención: La función usa internamente la función rand(), si se desea esta puede ser aleatoriamente inicializada usando la funcíón Pds::Ra::Randomize(), de lo contrario los números pseudo aleatórios siempre seguirán la misma secuencia.

$f_{X}(x)=\frac {1}{\sigma \sqrt {2\pi }} e^{-{\frac {(x-\mu)^{2}}{2\sigma^2}}},~~x \in R$

$\mathbf{A}\equiv [a_{i,j}]_{M,N}$

$a_{i,j}\leftarrow X_{l} \in X$

Parámetros

[in]	U	Valor da media $\mu$ .
[in]	Sigma	Valor do desvio padron $\sigma$ .

Devuelve: Retorna true si todo fue bien o false si no.

◆ FillRandU() [1/3]

bool Pds::Matrix::FillRandU ( void )

Inicializa la matriz con números aleatórios, distribuidos uniformemente, desde 0 a 1.0, incluyendo 0 y excluyendo 1.0.

Atención: La función usa internamente la función rand(), si se desea esta puede ser aleatoriamente inicializada usando la funcíón Pds::Ra::Randomize(), de lo contrario los números pseudo aleatórios siempre seguirán la misma secuencia.

$f_{X}(x)= 1,~~0\leq x<1, x \in R$

$\mathbf{A}\equiv [a_{i,j}]_{M,N}$

$a_{i,j}\leftarrow X_{l} \in X$

Devuelve: Retorna true si todo fue bien o false si no.

Ejemplos: example_matrix_fill.cpp.

◆ FillRandU() [2/3]

bool Pds::Matrix::FillRandU	(	int	a,
		int	b
	)

Inicializa la matriz con números aleatórios, distribuidos uniformemente, desde a a b, incluyendo a y b.

Atención: La función usa internamente la función rand(), si se desea esta puede ser aleatoriamente inicializada usando la funcíón Pds::Ra::Randomize(), de lo contrario los números pseudo aleatórios siempre seguirán la misma secuencia.

$f_{X}(x)= 1,~~min(a,b)\leq x\leq max(a,b), x \in R$

$\mathbf{A}\equiv [a_{i,j}]_{M,N}$

$a_{i,j}\leftarrow X_{l} \in X$

Parámetros

[in]	a	Valor mínimo posible.
[in]	b	Valor máximo posible.

Devuelve: Retorna true si todo fue bien o false si no.

◆ FillRandU() [3/3]

bool Pds::Matrix::FillRandU	(	double	a,
		double	b
	)

Inicializa la matriz con números aleatórios, distribuidos uniformemente, desde a a b, incluyendo a y b.

Atención: La función usa internamente la función rand(), si se desea esta puede ser aleatoriamente inicializada usando la funcíón Pds::Ra::Randomize(), de lo contrario los números pseudo aleatórios siempre seguirán la misma secuencia.

$f_{X}(x)= 1,~~min(a,b)\leq x\leq max(a,b), x \in R$

$\mathbf{A}\equiv [a_{i,j}]_{M,N}$

$a_{i,j}\leftarrow X_{l} \in X$

Parámetros

[in]	a	Valor mínimo posible.
[in]	b	Valor máximo posible.

Devuelve: Retorna true si todo fue bien o false si no.

◆ FillId()

bool Pds::Matrix::FillId ( void )

Inicializa la matriz con el valor de la posición de cada elemento.

En el caso de una matriz A de 4 lineas y 3 columnas:

$\mathbf{A} \leftarrow \left(\begin{matrix} 0 & 4 & 8\\ 1 & 5 & 9\\ 2 & 6 & 10\\ 3 & 7 & 11\\ \end{matrix}\right)$

Devuelve: Retorna true si todo fue bien o false si no.

Ejemplos: example_matrix_export.cpp, example_matrix_fill.cpp, example_matrix_getset.cpp y example_ra_indices.cpp.

◆ Fill()

bool Pds::Matrix::Fill ( double val )

Inicializa la matriz con un valor constante.

$\mathbf{A} \leftarrow \left(\begin{matrix} val & val & \cdots & val\\ val & val & \cdots & val\\ \vdots & \vdots & \vdots & \vdots \\ val & val & \cdots & val\\ val & val & \cdots & val\\ \end{matrix}\right)$

Parámetros

[in] val El valor a ser usado.

Devuelve: Retorna true si todo fue bien o false si no.

Ejemplos: example_matrix_fill.cpp y example_matrix_getset_extras.cpp.

◆ FillLinSpace()

bool Pds::Matrix::FillLinSpace	(	double	a,
		double	b
	)

Inicializa la matriz con un espacio linear entre begin y end. Se inicializa primero una columna ante de pasar ala siguiente.

En el caso de una matriz A de Nlin=4 lineas y Ncol=3 columnas:

$\alpha= \frac{b-a}{Nlin~Ncol- 1}$

$\mathbf{A} \leftarrow \left(\begin{matrix} a & 4\alpha+a & 8\alpha+a\\ \alpha+a & 5\alpha+a & 9\alpha+a\\ 2\alpha+a & 6\alpha+a & 10\alpha+a\\ 3\alpha+a & 7\alpha+a & 11\alpha+a\\ \end{matrix}\right)$

Parámetros

[in]	a	El valor inicial.
[in]	b	El valor final.

Devuelve: Retorna true si todo fue bien o false si no.

Ejemplos: example_matrix_fill.cpp.

◆ Nlin()

unsigned int Pds::Matrix::Nlin ( void ) const

Retorna el numero de lineas de la matriz.

Devuelve: Retorna el numero de lineas de la matriz.

◆ Ncol()

unsigned int Pds::Matrix::Ncol ( void ) const

Retorna el numero de columnas de la matriz.

Devuelve: Retorna el numero de columnas de la matriz.

◆ Nel()

unsigned int Pds::Matrix::Nel ( void ) const

Retorna el numero de elementos de la matriz (Nlin x Ncol).

Devuelve: Retorna el numero de elementos de la matriz.

◆ Size()

Pds::Size Pds::Matrix::Size ( void ) const

Retorna un objeto de tipo Pds::Size con el numero de lineas y columans.

Devuelve: Retorna el tamano de la matriz.

Ejemplos: example_vector_create.cpp y example_vector_poly.cpp.

◆ LinEnd()

unsigned int Pds::Matrix::LinEnd ( void ) const

Retorna el identificador de la ultima linea de la matriz.

Devuelve: Retorna Nlin-1.

Ejemplos: example_matrix_getset.cpp.

◆ ColEnd()

unsigned int Pds::Matrix::ColEnd ( void ) const

Retorna el identificador de la ultima columna de la matriz.

Devuelve: Retorna Ncol-1.

Ejemplos: example_matrix_getset.cpp.

◆ End()

unsigned int Pds::Matrix::End ( void ) const

Retorna el identificador del ultimo elemento de la matriz.

Devuelve: Retorna ((Nlin x Ncol)-1).

◆ Get() [1/2]

double Pds::Matrix::Get ( unsigned int id ) const

Retorna el valor en la posición del índice id, hace una verificación si la posición existe.

Parámetros

[in] id índice de un elemento de la matriz.

Devuelve: Retorna el valor en la posición (id%Nlin,id/Nlin) o cero si la posición no existe.

Ejemplos: example_matrix_getset.cpp.

◆ Get() [2/2]

double Pds::Matrix::Get	(	unsigned int	lin,
		unsigned int	col
	)		const

Retorna el valor en la posición (lin,col), hace una verificación si la posición existe.

Parámetros

[in]	lin	La linea en consulta.
[in]	col	La columna en consulta.

Devuelve: Retorna el valor en la posición (lin,col) o cero si la posición no existe.

◆ GetRaw()

const double& Pds::Matrix::GetRaw	(	unsigned int	lin,
		unsigned int	col
	)		const

inline

Retorna una variable double en la posición (lin,col) de la array.

Atención: NO hace una verificación para evitar leer fuera de la memoria, por lo que dará errores de acceso si pedimos una posición inexistente.

Parámetros

[in]	lin	La linea en consulta.
[in]	col	La columna en consulta.

Devuelve: Retorna una variable double en la posición (lin,col).

Definición en la línea 1043 del archivo Matrix.hpp.

     {
         return this->array[lin][col];
     }

◆ SetRaw()

void Pds::Matrix::SetRaw	(	unsigned int	lin,
		unsigned int	col,
		const double &	val
	)

inline

Establece una variable double en la posición (lin,col) de la array.

Atención: NO hace una verificación para evitar leer fuera de la memoria, por lo que dará errores de acceso si pedimos una posición inexistente.

Parámetros

[in]	lin	La linea en consulta.
[in]	col	La columna en consulta.
[in]	val	valor a escribir.

Definición en la línea 1057 del archivo Matrix.hpp.

     {
         this->array[lin][col]=val;
     }

◆ Set() [1/2]

bool Pds::Matrix::Set	(	unsigned int	id,
		double	val
	)

Escribe el valor en la posición del índice id, hace una verificación si la posición existe.

Parámetros

[in]	val	valor a escribir.
[in]	id	índice de un elemento de la matriz.

Devuelve: Retorna true si consiguió escribir el valor en la posición (id%Nlin,id/Nlin) o false si no.

◆ Set() [2/2]

bool Pds::Matrix::Set	(	unsigned int	lin,
		unsigned int	col,
		double	val
	)

Escribe el valor en la posición (lin,col), hace una verificación si la posición existe.

Parámetros

[in]	val	valor a escribir.
[in]	lin	La linea en consulta.
[in]	col	La columna en consulta.

Devuelve: Retorna true si consiguió escribir el valor en la posicion (lin,col) o false si no.

◆ At() [1/2]

double& Pds::Matrix::At	(	unsigned int	lin,
		unsigned int	col
	)

Retorna una variable double en la posición (lin,col) de la matriz. Hace una verificación para evitar leer o escribir fuera de la memoria, con este fin hace lin=linNlin y col=colNcol.

Parámetros

[in]	lin	La linea en consulta.
[in]	col	La columna en consulta.

Devuelve: Retorna una variable double en la posición (lin,col).

Ejemplos: example_matrix_getset.cpp.

◆ At() [2/2]

double& Pds::Matrix::At ( unsigned int id )

Retorna una variable double en la posición (id) de la matriz. Hace una verificación para evitar leer o escribir fuera de la memoria, con este fin hace id=id%(Nlin*Ncol).

Parámetros

[in] id La posicion en consulta.

Devuelve: Retorna una variable double en la posición (id).

◆ Bilinear()

double Pds::Matrix::Bilinear	(	double	lin,
		double	col
	)		const

Retorna el valor en la posición (lin,col), usando una interpolación bilinear, valores fuera del rango de la matriz retornan cero.

Matrix A

$A(P) \leftarrow (1-\beta)(1-\alpha)A(P_1)+(1-\beta)\alpha A(P_2)+\beta(1-\alpha)A(P_3)+ \beta \alpha A(P_4)$

Parámetros

[in]	lin	La linea en consulta.
[in]	col	La columna en consulta.

Devuelve: Retorna el valor en la posición P=(lin,col) o cero si lin<0 o col<0 o lin>(Nlin-1) o col>(Ncol-1).

Ejemplos: example_matrix_getset.cpp.

◆ GetDiagonal()

Pds::Vector Pds::Matrix::GetDiagonal ( void ) const

Retorna un vector columna copia de los valores de la diagonal de la matriz.

Devuelve: Retorna el vector columna en la posición (col) o un vector vacío en caso de error.

Ejemplos: example_matrix_getset_extras.cpp.

◆ SetDiagonal()

bool Pds::Matrix::SetDiagonal ( const Pds::Vector V )

Copia un vector columna en una diagonal de la matriz. Si los tamaños son diferentes, se interceptan las matrices y se copia solamente en la intersección.

Parámetros

[in] V El vector a copiar.

Devuelve: Retorna true si la copia fue hecha o false si hubo algún problema. En caso de retornar false no se modifica la matriz.

◆ GetMatrix() [1/2]

Pds::Matrix Pds::Matrix::GetMatrix	(	unsigned int	lin_init,
		unsigned int	col_init,
		unsigned int	lin_end,
		unsigned int	col_end
	)		const

Retorna una sub matriz desde la posición (lin_init,col_init) hasta (lin_end,col_end), inclusive. Hace una verificación si la posición existe, si no existe llena con ceros.

Parámetros

[in]	lin_init	La linea inicial en consulta.
[in]	col_init	La columna inicial en consulta.
[in]	lin_end	La linea final en consulta.
[in]	col_end	La columna final en consulta.

Devuelve: Retorna una sub matriz. Si no existe interseccion entre la matriz y las cordenadas pedidas, entonces se retorna una matriz vacia.

Ejemplos: example_matrix_getset.cpp.

◆ GetMatrix() [2/2]

Pds::Matrix Pds::Matrix::GetMatrix	(	unsigned int	lin_init,
		unsigned int	col_init,
		Pds::Size	size
	)		const

Retorna una sub matriz desde la posición (lin_init,col_init) hasta (lin_end,col_end), inclusive. Hace una verificación si la posición existe, si no existe llena con ceros.

Parámetros

[in]	lin_init	La linea inicial en consulta.
[in]	col_init	La columna inicial en consulta.
[in]	size	Tamaño de la matriz a recibir.

Devuelve: Retorna una sub matriz. Si no existe interseccion entre la matriz y las cordenadas pedidas, entonces se retorna una matriz vacia.

◆ SetMatrix()

bool Pds::Matrix::SetMatrix	(	unsigned int	lin,
		unsigned int	col,
		const Pds::Matrix &	B
	)

Copia en si mismo (A) en la posicion (lin,col), el contenido de una matriz B. Si a matriz B no cabe em A se retorna false.

Parámetros

[in]	lin	Linea donde se inicia a copia.
[in]	col	Columna donde se inicia a copia.
[in]	B	la matriz a copiar

Devuelve: Retorna true si todo fue bien o false si no. Si se retorna false no se copia nada. Si IsEmpty() iguala true retorna false.

◆ GetRow()

Pds::Matrix Pds::Matrix::GetRow ( unsigned int lin ) const

Retorna una matriz linea escojida en la linea lin. Hace una verificación si la linea existe, si no existe devuelve una matriz vacia.

Parámetros

[in] lin La linea en consulta.

Devuelve: Retorna una matriz linea. Si no existe la linea, entonces se retorna una matriz vacia.

◆ GetCol()

Pds::Matrix Pds::Matrix::GetCol ( unsigned int col ) const

Retorna una matriz columna escojida en la columna col. Hace una verificación si la columna existe, si no existe devuelve una matriz vacia.

Parámetros

[in] col La columna en consulta.

Devuelve: Retorna una matriz columna. Si no existe la columna, entonces se retorna una matriz vacia.

◆ GetRows() [1/3]

Pds::Matrix Pds::Matrix::GetRows	(	unsigned int	lin_init,
		unsigned int	lin_end
	)		const

Retorna una sub matriz escojida desde la linea lin_init hasta lin_end, inclusive. Hace una verificación si la linea existe, si no existe llena esta con ceros.

Parámetros

[in]	lin_init	La linea inicial en consulta.
[in]	lin_end	La linea final en consulta.

Devuelve: Retorna una sub matriz. Si no existe interseccion entre la matriz y las lineas pedidas, entonces se retorna una matriz vacia.

Ejemplos: example_ra_indices.cpp.

◆ GetCols() [1/3]

Pds::Matrix Pds::Matrix::GetCols	(	unsigned int	col_init,
		unsigned int	col_end
	)		const

Retorna una sub matriz escojida desde la columna col_init hasta col_end, inclusive. Hace una verificación si la columna existe, si no existe llena esta con ceros.

Parámetros

[in]	col_init	La columna inicial en consulta.
[in]	col_end	La columna final en consulta.

Devuelve: Retorna una sub matriz. Si no existe interseccion entre la matriz y las columnas pedidas, entonces se retorna una matriz vacia.

Ejemplos: example_ra_indices.cpp.

◆ GetRows() [2/3]

Pds::Matrix Pds::Matrix::GetRows ( std::list< unsigned int > List ) const

Retorna una sub matriz escojida desde una lista de indices de lineas. Hace una verificación si los indices existen, si alguno no existe devuelve una matriz vacia.

Parámetros

[in] List La lista de indices de lineas.

Devuelve: Retorna una sub matriz. Si no existe algun elemento en la lista se devuelve una matriz vacia.

◆ GetCols() [2/3]

Pds::Matrix Pds::Matrix::GetCols ( std::list< unsigned int > List ) const

Retorna una sub matriz escojida desde una lista de indices de columnas. Hace una verificación si los indices existen, si alguno no existe devuelve una matriz vacia.

Parámetros

[in] List La lista de indices de columnas.

Devuelve: Retorna una sub matriz. Si no existe algun elemento en la lista se devuelve una matriz vacia.

◆ GetRows() [3/3]

Pds::Matrix Pds::Matrix::GetRows ( std::vector< unsigned int > Vec ) const

Retorna una sub matriz escojida desde una lista de indices de lineas. Hace una verificación si los indices existen, si alguno no existe devuelve una matriz vacia.

Parámetros

[in] Vec El vector de indices de lineas.

Devuelve: Retorna una sub matriz. Si no existe algun elemento en la lista se devuelve una matriz vacia.

◆ GetCols() [3/3]

Pds::Matrix Pds::Matrix::GetCols ( std::vector< unsigned int > Vec ) const

Retorna una sub matriz escojida desde una lista de indices de columnas. Hace una verificación si los indices existen, si alguno no existe devuelve una matriz vacia.

Parámetros

[in] Vec El vector de indices de columnas.

Devuelve: Retorna una sub matriz. Si no existe algun elemento en la lista se devuelve una matriz vacia.

◆ GetRowsRand()

Pds::Matrix Pds::Matrix::GetRowsRand ( unsigned int N ) const

Retorna una sub matriz escojiendo N lineas aleatoriamente (sin repetición).

Atención: La función usa internamente la función rand(), si se desea esta puede ser aleatoriamente inicializada usando la funcíón Pds::Ra::Randomize(), de lo contrario los números pseudo aleatórios siempre seguirán la misma secuencia.

Parámetros

[in] N El número de lineas a escojer.

Devuelve: Retorna una sub matriz. Si N=0 o N>Nlin entonces se retorna una matriz vacia.

◆ GetColsRand()

Pds::Matrix Pds::Matrix::GetColsRand ( unsigned int N ) const

Retorna una sub matriz escojiendo N columnas aleatoriamente (sin repetición).

Atención: La función usa internamente la función rand(), si se desea esta puede ser aleatoriamente inicializada usando la funcíón Pds::Ra::Randomize(), de lo contrario los números pseudo aleatórios siempre seguirán la misma secuencia.

Parámetros

[in] N El número de columnas a escojer.

Devuelve: Retorna una sub matriz. Si N=0 o N>Ncol entonces se retorna una matriz vacia.

◆ SetRowValue()

bool Pds::Matrix::SetRowValue	(	unsigned int	lin,
		double	value
	)

Copia un valor en una linea de la matriz.

Parámetros

[in]	value	El valor a copiar.
[in]	lin	La linea en consulta.

Devuelve: Retorna true si la copia fue hecha y la posición (lin) existe o false si hubo algún problema. En caso de retornar false no se modifica la matriz.

◆ SetRowVector()

bool Pds::Matrix::SetRowVector	(	unsigned int	lin,
		const Pds::Vector &	X
	)

Copia un vector en una linea de la matriz.

Parámetros

[in]	lin	La linea en consulta.
[in]	X	El vector a copiar.

Devuelve: Retorna true si la copia fue hecha y la posición (lin) existe o false si hubo algún problema. En caso de retornar false no se modifica la matriz.

◆ SetColValue()

bool Pds::Matrix::SetColValue	(	unsigned int	col,
		double	value
	)

Copia un valor en una columna de la matriz.

Parámetros

[in]	value	El valor a copiar.
[in]	col	La columna en consulta.

Devuelve: Retorna true si la copia fue hecha y la posición (col) existe o false si hubo algún problema. En caso de retornar false no se modifica la matriz.

◆ GetRowAsColVector() [1/2]

Pds::Vector Pds::Matrix::GetRowAsColVector ( unsigned int lin ) const

Retorna un vector columna copia de una linea de la matriz.

Parámetros

[in] lin La linea en consulta.

Devuelve: Retorna un vector columna correspondiente a la linea (lin) o un vector vacío si la posición no existe.

Ejemplos: example_matrix_getset_extras.cpp.

◆ GetRowAsColVector() [2/2]

bool Pds::Matrix::GetRowAsColVector	(	unsigned int	lin,
		Pds::Vector &	V
	)		const

Retorna un vector columna copia de una linea de la matriz.

Parámetros

[in]	lin	La linea en consulta.
[out]	V	Vector donde se copian los datos de la linea.

Devuelve: Retorna true si la linea existe y el tamañp de V corresponde a número de columnas de la matriz o false en caso contrario.

◆ GetColVector()

Pds::Vector Pds::Matrix::GetColVector ( unsigned int col ) const

Retorna un vector columna copia de una columna de la matriz.

Parámetros

[in] col La columna en consulta.

Devuelve: Retorna el vector columna en la posición (col) o un vector vacío si la posición no existe.

Ejemplos: example_matrix_getset_extras.cpp.

◆ SetColVector() [1/3]

bool Pds::Matrix::SetColVector	(	unsigned int	col,
		const Pds::Vector	V
	)

Copia un vector columna en una columna de la matriz. Si los tamaños son diferentes, se interceptan las matrices y se copia solamente en la intersección.

Parámetros

[in]	V	El vector a copiar.
[in]	col	La columna en consulta.

Devuelve: Retorna true si la copia fue hecha y la posición (col) existe o false si hubo algún problema. En caso de retornar false no se modifica la matriz.

Ejemplos: example_matrix_getset_extras.cpp.

◆ SetColVector() [2/3]

bool Pds::Matrix::SetColVector	(	unsigned int	col,
		double(*)(double)	func,
		const Pds::Vector	V
	)

Copia un vector columna en una columna de la matriz, despues de evaluar el vector en una funcion. Si los tamaños son diferentes, se interceptan las matrices y se copia solamente en la intersección.

Parámetros

[in]	func	funcion a evaluar.
[in]	V	El vector a evaluar y copiar.
[in]	col	La columna en consulta.

Devuelve: Retorna true si la copia fue hecha y la posición (col) existe o false si hubo algún problema. En caso de retornar false no se modifica la matriz.

◆ SetColVector() [3/3]

bool Pds::Matrix::SetColVector	(	unsigned int	col,
		double(*)(double, double)	func,
		const Pds::Vector	V,
		double	var
	)

Copia un vector columna en una columna de la matriz, despues de evaluar el vector en una funcion. Si los tamaños son diferentes, se interceptan las matrices y se copia solamente en la intersección.

Parámetros

[in]	func	funcion a evaluar.
[in]	V	El vector a evaluar y copiar.
[in]	var	Segunda variable a evaluar.
[in]	col	La columna en consulta.

Devuelve: Retorna true si la copia fue hecha y la posición (col) existe o false si hubo algún problema. En caso de retornar false no se modifica la matriz.

◆ RowAddAssig()

bool Pds::Matrix::RowAddAssig	(	unsigned int	lin1,
		unsigned int	lin2,
		double	alpha
	)

Multiplica los valores de la linea lin2 por alfa y el resultado es sumado a los valores de la linea lin1.

$row[lin1] \leftarrow row[lin1]+\alpha ~ row[lin2]$

Parámetros

[in]	lin1	Lineas a intercambiar.
[in]	lin2	Lineas a intercambiar.
[in]	alpha	Factor multiplicador.

Devuelve: Retorna true si todo fue bien o false si no.

◆ RowMulAssig()

bool Pds::Matrix::RowMulAssig	(	unsigned int	lin,
		double	alpha
	)

Multiplica la linea lin por alpha.

$row[lin] \leftarrow \alpha ~ row[lin]$

Parámetros

[in]	lin	Linea a multiplicar.
[in]	alpha	Factor multiplicador.

Devuelve: Retorna true si todo fue bien o false si no.

◆ RowDivAssig()

bool Pds::Matrix::RowDivAssig	(	unsigned int	lin,
		double	alpha
	)

Divide la linea lin por alpha.

$row[lin] \leftarrow row[lin]/\alpha$

Parámetros

[in]	lin	Linea a dividir.
[in]	alpha	Factor multiplicador.

Devuelve: Retorna true si todo fue bien o false si no.

◆ RowSwap()

bool Pds::Matrix::RowSwap	(	unsigned int	lin1,
		unsigned int	lin2
	)

Intercambia los valores de las lineas de una matriz.

Parámetros

[in]	lin1	Lineas a intercambiar.
[in]	lin2	Lineas a intercambiar.

Devuelve: Retorna true si todo fue bien o false si no.

◆ RowSwapBelow()

int Pds::Matrix::RowSwapBelow ( unsigned int n )

Si el n-avo elemento de la diagonal es cero entonces intercambia la linea n de la matriz con cualquier linea inferior con elemento diferente de cero en la columna n.

Parámetros

[in] n Linea a intercambiar.

Devuelve: Retorna el numero de la fila con quien intercambio o -1 en caso de error. Si el n-avo elemento de la diagonal ja es diferente de cero no se hace nada y se retorna n.

◆ RowReduction()

bool Pds::Matrix::RowReduction ( void )

Convierte la matriz en una matriz reducida.

Devuelve: Retorna true si todo fue bien o false si no. Si retorna false la matriz es modificada hasta donde consiguió avanzar el proceso de reducción.

◆ RowDivByAbsMax()

bool Pds::Matrix::RowDivByAbsMax ( void )

Normaliza cada linea de la matriz dividiendola por el maximo valor absoluto de la linea. Si la linea tiene solo ceros esta no es modificada.

Devuelve: Retorna true si todo fue bien o false si no. Retorna false quando a matriz esta vazia.

◆ Sum()

double Pds::Matrix::Sum ( void ) const

Calcula el valor de la suma de elementos de la matriz.

Devuelve: Retorna el valor de la suma de elementos de la matriz. En caso de que la matriz sea vacía se retorna Pds::Ra::Nan.

◆ Mean()

double Pds::Matrix::Mean ( void ) const

Calcula el valor medio de la matriz.

Devuelve: Retorna el valor medio de la matriz. En caso de que la matriz sea vacía se retorna Pds::Ra::Nan.

◆ MeanInCols()

Pds::Matrix Pds::Matrix::MeanInCols ( void ) const

Calcula el valor medio de las columnas de la matriz.

Devuelve: Retorna una matriz linea con el valor medio de cada columna de la matriz. En caso de que la matriz sea vacía se retorna Pds::Matrix().

◆ MeanInRows()

Pds::Vector Pds::Matrix::MeanInRows ( void ) const

Calcula la media de cada linea de la matriz.

Devuelve: Retorna un vector con la media de cada linea de la matriz.

◆ Std()

double Pds::Matrix::Std ( double * mean = NULL ) const

Calcula el valor del desvío padrón de la matriz.

Devuelve: Retorna el valor del desvío padrón de la matriz. En caso de que la matriz sea vacía se retorna Pds::Ra::Nan.

◆ StdInRows()

Pds::Vector Pds::Matrix::StdInRows ( void ) const

Calcula el standard deviation de cada linea de la matriz.

Devuelve: Retorna un vector con el standard deviation de cada linea de la matriz.

◆ MeanStdInRows()

bool Pds::Matrix::MeanStdInRows	(	Pds::Vector &	Mean,
		Pds::Vector &	Std
	)		const

Calcula la media y el standard deviation de cada linea de la matriz.

Parámetros

[out]	Mean	Vector con la media de cada linea. El vector debe tener el mismo número de lineas que la matriz caso contrario se retorna false.
[out]	Std	Vector con es standard deviation de cada linea. El vector debe tener el mismo número de lineas que la matriz caso contrario se retorna false.

Devuelve: Retorna tue si todo fue bien o false si no. si se rtorna false, tambien se libera la memoria de Std y Mean.

◆ MeanStdInCols()

bool Pds::Matrix::MeanStdInCols	(	Pds::Matrix &	Mean,
		Pds::Matrix &	Std
	)		const

Calcula la media y el standard deviation de cada linea de la matriz.

Parámetros

[out]	Mean	Vector con la media de cada columna. El vector debe tener el mismo número de lineas que la matriz caso contrario se retorna false.
[out]	Std	Vector con es standard deviation de cada columna. El vector debe tener el mismo número de lineas que la matriz caso contrario se retorna false.

Devuelve: Retorna tue si todo fue bien o false si no. si se rtorna false, tambien se libera la memoria de Std y Mean.

◆ Var()

double Pds::Matrix::Var ( double * mean = NULL ) const

Calcula el valor de la varianza de la matriz.

Devuelve: Retorna el valor de la varianza de la matriz. En caso de que la matriz sea vacía se retorna Pds::Ra::Nan.

◆ Max()

double Pds::Matrix::Max ( unsigned int * id = NULL ) const

Calcula el máximo valor de la matriz.

Parámetros

[in] id Se retorna el id do valor máximo.

Devuelve: Retorna el máximo valor de la matriz. En caso de que la matriz sea vacía se retorna Pds::Ra::Nan.

◆ MaxAbs()

double Pds::Matrix::MaxAbs ( unsigned int * id = NULL ) const

Calcula el máximo valor del valor absoluto de la matriz.

Parámetros

[in] id Se retorna el id do valor máximo.

Devuelve: Retorna el máximo valor del valor absoluto de la matriz. En caso de que la matriz sea vacía se retorna Pds::Ra::Nan.

◆ MaxAbsInRows()

Pds::Vector Pds::Matrix::MaxAbsInRows ( void ) const

Retorna un vector con el maximo valor absoluto de cada linea.

Devuelve: Retorna un vector con el maximo valor absoluto de cada linea.

◆ Min()

double Pds::Matrix::Min ( unsigned int * id = NULL ) const

Calcula el mínimo valor de la matriz.

Parámetros

[in] id Se retorna el id do valor mínimo.

Devuelve: Retorna el mínimo valor de la matriz. En caso de que la matriz sea vacía se retorna Pds::Ra::Nan.

◆ MinAbs()

double Pds::Matrix::MinAbs ( unsigned int * id = NULL ) const

Calcula el mínimo valor del valor absoluto de la matriz.

Parámetros

[in] id Se retorna el id do valor mínimo.

Devuelve: Retorna el mínimo valor del valor absoluto de la matriz. En caso de que la matriz sea vacía se retorna Pds::Ra::Nan.

◆ MinInCols() [1/2]

Pds::Matrix Pds::Matrix::MinInCols ( std::vector< unsigned int > & Lin ) const

Calcula el mínimo en cada columna de la matriz.

Parámetros

[in] Lin La linea del valor mínimo en cada columna.

Devuelve: Retorna el mínimo valor en cada columna de la matriz. En caso de que la matriz sea vacía se retorna Pds::Matrix() y Lin tiene tamaño cero.

◆ MinInCols() [2/2]

Pds::Matrix Pds::Matrix::MinInCols ( Pds::Array< unsigned int > & Lin ) const

Calcula el mínimo en cada columna de la matriz.

Parámetros

[in] Lin La linea del valor mínimo en cada columna.

Devuelve: Retorna el mínimo valor en cada columna de la matriz. En caso de que la matriz sea vacía se retorna Pds::Matrix() y Lin tiene tamaño cero.

◆ NormalizeCols()

bool Pds::Matrix::NormalizeCols	(	Pds::Vector &	Mean,
		Pds::Vector &	Std
	)

Calcula la media y el standard deviation de cada columna de la matriz. Si el std de la columna es cero esta no es normalizada.

$Col[i] \leftarrow \frac{Col[i]-Mean[i]}{Std[i]}$

Parámetros

[out]	Mean	Vector con la media de cada columna. El vector debe tener el mismo número de lineas que la matriz caso contrario se retorna false.
[out]	Std	Vector con es standard deviation de cada columna. El vector debe tener el mismo número de lineas que la matriz caso contrario se retorna false.

Devuelve: Retorna tue si todo fue bien o false si no. si se retorna false (incompatibilidad de tamaños), también se libera la memoria de Std, Mean y de la propia matriz.

◆ NormalizeColsWith()

bool Pds::Matrix::NormalizeColsWith	(	const Pds::Vector &	Mean,
		const Pds::Vector &	Std
	)

Normaliza cada columna de la matriz usando la media y el standard deviation de cada columna de la matriz. Si el std de la columna es cero esta no es normalizada.

$Col[i] \leftarrow \frac{Col[i]-Mean[i]}{Std[i]}$

Parámetros

[out]	Mean	Vector con la media de cada columna. El vector debe tener el mismo número de lineas que la matriz caso contrario se retorna false.
[out]	Std	Vector con es standard deviation de cada columna. El vector debe tener el mismo número de lineas que la matriz caso contrario se retorna false.

Devuelve: Retorna tue si todo fue bien o false si no. si se retorna false (incompatibilidad de tamaños), también se libera la memoria de Std, Mean y de la propia matriz.

◆ Accuracy()

double Pds::Matrix::Accuracy	(	const Pds::Matrix &	B,
		double	Umbral
	)		const

Calcula el valor de la Accuracy entre los elementos de las matrices A (Self) y B. Antes de comprarar las matrices se binarizan con el umbral Umbral. A>Umbral, B>Umbral.

$Accuracy=\frac{TP+TN}{TP+TN+FP+FN}=\frac{Number~of~A==B}{Number~of~elements~in~A}$

TP=True positive TN=True negative FP=False positive FN=False negative

Parámetros

[in]	B	Matriz a procesar.
[in]	Umbral	Umbral de binarización.

Devuelve: Retorna el valor de la Accuracy entre los elementos de las matrices A y B. En caso de que la matriz sea vacía se retorna Pds::Ra::Nan.

◆ R2()

double Pds::Matrix::R2 ( const Pds::Matrix & Y ) const

Calcula el coeficiente de determinación o .

$R^2\equiv A.R2(Y)\quad =\quad 1-\frac{\sigma_r^2}{\sigma^2}\quad =\quad 1-\frac{\frac{1}{L}|| \mathbf{A}_{ij}-\mathbf{Y}_{ij}||^2}{Var(\mathbf{A})}$

$-\infty < R^2 < 1$

Varianza $\sigma^2$ , varianza residual $\sigma_r^2$ .

Devuelve: Retorna el coeficiente de determinación entre A e Y. En caso de que la matriz sea vacía se retorna Pds::Ra::Nan.

◆ Rf()

double Pds::Matrix::Rf ( const Pds::Matrix & Y ) const

Calcula o .

$Rf\equiv A.Rf(Y)\quad =\quad \frac{\sigma_r}{\sigma}$

$Rf\equiv A.Rf(Y)\quad =\quad \frac{\sqrt{\frac{1}{L}|| \mathbf{A}_{ij}-\mathbf{Y}_{ij}||^2}}{Std(\mathbf{A})}$

$0 < Rf < \infty$

Varianza $\sigma^2$ , varianza residual $\sigma_r^2$ .

Devuelve: RetornaRF entre A e Y. En caso de que la matriz sea vacía se retorna Pds::Ra::Nan.

◆ Mape()

double Pds::Matrix::Mape ( const Pds::Matrix & B ) const

Calcula el error absoluto medio porcentual (Mean Absolute Percentage Error) de una matriz.

$A.Mape()=\frac{100}{N_{total}}\sum \limits_{i} \sum \limits_{j} \left|\frac{a_{ij}-b_{ij}}{a_{ij}}\right|$

$N_{total}$ es el número de elementos no cero en $\mathbf{A}$ . Solo son sumados elementos no cero en $\mathbf{A}$ .

Devuelve: Retorna el error absoluto medio porcentual. En caso de que la matriz sea vacía se retorna Pds::Ra::Nan.

◆ InformationGain()

double Pds::Matrix::InformationGain	(	const std::vector< Pds::Matrix > &	A,
		double	Umbral = `0.5`
	)		const

Retorna el Information Gain entre si mismo B y {A[0],A[1],...,A[N-1]}. Antes de comprarar las matrices se binarizan con el umbral Umbral. A[n]>Umbral, B>Umbral.

$h_b(p)=- p log_2(p)- (1-p) log_2(1-p)$

$IG=h_b(p_{\mathbf{B}})-\sum_{n=0}^{N-1} \frac{N_{\mathbf{A[n]}}}{N_{\mathbf{B}}}h_b(p_{\mathbf{A[n]}})$

Parámetros

[in]	A	vector de matrices. Estas seran binarizadas con Umbral.
[in]	Umbral	Umbral de binarización. A>Umbral.

Devuelve: Retorna el Information Gain entre si mismo B y {A[0],A[1],...,A[N-1]}. En caso de que la matriz sea vacía o algun otro problema se retorna Pds::Ra::Nan.

◆ BinaryEntropy()

double Pds::Matrix::BinaryEntropy ( double umbral ) const

Calcula la entropia binaria de la estadistica de {p0,p1}, la probabilidade de unos y ceros en la matriz despues de ubralizar con >=umbral.

Parámetros

[in] umbral Umbral de binarización (mayor igual).

Devuelve: Retorna el valor de la entropia binaria. En caso de que la matriz sea vacía se retorna Pds::Ra::Nan.

◆ P1Probability()

double Pds::Matrix::P1Probability ( double umbral ) const

Calcula la probabilidad binaria {p1}, la probabilidade en relación a los unos y ceros en la matriz despues de ubralizar con >=umbral.

Parámetros

[in] umbral Umbral de binarización (mayor igual).

Devuelve: Retorna el valor de la probabilidad p1. En caso de que la matriz sea vacía se retorna Pds::Ra::Nan.

◆ BalancedBinaryWeight()

Pds::Matrix Pds::Matrix::BalancedBinaryWeight ( double umbral ) const

Retorna una matriz de pesos para balancear la cantidad de 1s y 0s en la matriz. Los unos y ceros en la matriz son obtenidos despues de ubralizar con >=umbral.

Parámetros

[in] umbral Umbral de binarización (mayor igual).

Devuelve: Retorna una matriz de pesos para balancear la cantidad de 1s y 0s en la matriz.

◆ HistogramNorm()

Pds::Vector Pds::Matrix::HistogramNorm	(	int	min = `0`,
		int	max = `255`
	)		const

Retorna un vector con el histograma desde min hasta max (valores enteros). Elementos con valores menores a min o mayores a max no son computados en el histograma. El histograma és normalizado para que la suma sea igual a 1 de modo que pueda ser usada como una relación de probabilidades.

Parámetros

[in]	min	Valor mínimo a ser tomado en cuenta en el histograma.
[in]	max	Valor máximo a ser tomado en cuenta en el histograma.

Devuelve: Retorna una vector con un histograma.

◆ Corr()

double Pds::Matrix::Corr ( const Pds::Matrix & B ) const

Calcula la correlación de Pearson con la matriz.

Devuelve: Retorna el valor de la correlación. En caso de que la matriz sea vacía se retorna Pds::Ra::Nan.

◆ XCorr()

Pds::Matrix Pds::Matrix::XCorr	(	const Pds::Matrix &	B,
		bool	Same = `false`
	)		const

Calcula la correlacion cruzada entre A y B.

$\mathbf{A}\equiv [a_{i,j}] \overset{func}{\equiv} a(i,j),\qquad \mathbf{A}.Size()\equiv \{L_A,C_A\}$

$\mathbf{B}\equiv [b_{i,j}] \overset{func}{\equiv} b(i,j),\qquad \mathbf{B}.Size()\equiv \{L_B,C_B\}$

$\mathbf{D}\equiv [d_{i,j}] \overset{func}{\equiv} d(i-(L_B-1),j-(C_B-1)),\qquad \mathbf{D}.Size()\equiv \{L_B+L_A-1,C_B+C_A-1\}$

De modo que

$d(k,l) = \sum \limits_{q=-\infty}^{+\infty} \sum \limits_{r=-\infty}^{+\infty} a(q,r) b(q-k,r-l) \equiv \sum \limits_{q=max(0,k)}^{min(L_A-1,L_B-1+k)}~~ \sum \limits_{r=max(0,l)}^{min(C_A-1,C_B-1+l)} a(q,r) b(q-k,r-l)$

XCorr
Image	Formulation
	$d(k,l)=\sum \limits_{q=-\infty}^{+\infty} \sum \limits_{r=-\infty}^{+\infty} a(q,r) b(q-k,r-l)$ $d(k,l)=\sum \limits_{q=-\infty}^{+\infty} \sum \limits_{r=-\infty}^{+\infty} a(q+k,r+l) b(q,r)$

Exemplo:

$\mathbf{A}.Size()\equiv \{6,6\} \quad \mathbf{B}.Size()\equiv \{3,3\}$

$\mathbf{D}=\left(\begin{array}{cc|cccccc} d(-2,-2) & d(-2,-1) & d(-2,0) & d(-2,1) & d(-2,2) & d(-2,3) & d(-2,4) & d(-2,5) \\ d(-1,-2) & d(-1,-1) & d(-1,0) & d(-1,1) & d(-1,2) & d(-1,3) & d(-1,4) & d(-1,5) \\ \hline d(0,-2) & d(0,-1) & d(0,0) & d(0,1) & d(0,2) & d(0,3) & d(0,4) & d(0,5) \\ d(1,-2) & d(1,-1) & d(1,0) & d(1,1) & d(1,2) & d(1,3) & d(1,4) & d(1,5) \\ d(2,-2) & d(2,-1) & d(2,0) & d(2,1) & d(2,2) & d(2,3) & d(2,4) & d(2,5) \\ d(3,-2) & d(3,-1) & d(3,0) & d(3,1) & d(3,2) & d(3,3) & d(3,4) & d(3,5) \\ d(4,-2) & d(4,-1) & d(4,0) & d(4,1) & d(4,2) & d(4,3) & d(4,4) & d(4,5) \\ d(5,-2) & d(5,-1) & d(5,0) & d(5,1) & d(5,2) & d(5,3) & d(5,4) & d(5,5) \\ \end{array}\right)$

$d(k,l) =\sum \limits_{q=-\infty}^{+\infty} \sum \limits_{r=-\infty}^{+\infty} a(q,r) b(q-k,r-l) \equiv \sum \limits_{q=-\infty}^{+\infty} \sum \limits_{r=-\infty}^{+\infty} a(q+k,r+l) b(q,r)$

Atención: Esta funcion no usa FFT para economizar el tiempo.

Parámetros

[in]	B	Matriz a aplicar la correlacion cruzada.
[in]	Same	indica si la correlación cruzada tendrá el mismo tamaño que A, si Same es igual a true entonces, $[c_{i,j}] \overset{func}{\equiv} d(i,j), \quad \mathbf{C}.Size()\equiv \{Nlin,Ncol\}$ . Por defecto Same es igual a false.

Devuelve: retorna la correlacion cruzada.

◆ FilterMean()

Pds::Matrix Pds::Matrix::FilterMean ( unsigned int r ) const

Procesa la matriz A usando un filtro mean de radio r.

$B[i,j]=\frac{1}{(2 r+1)^2} \left( \begin{matrix} 1 & 1 & ... & 1 & 1\\ 1 & 1 & ... & 1 & 1\\ \vdots & \vdots & ... & \vdots & \vdots \\ 1 & 1 & ... & 1 & 1\\ 1 & 1 & ... & 1 & 1 \end{matrix} \right)$

Atención: Este filtro tambien es llamado: Mean filtering, Smoothing, Averaging, Box filtering

Parámetros

[in] r Radio de accion de la media, es decir kernel de tamaño (2r+1)x(2r+1).

Devuelve: Retorna la matriz B resultado de procesar la matriz A con un filtro mean de radio 1.

◆ FilterMean3()

Pds::Matrix Pds::Matrix::FilterMean3 ( void ) const

Procesa la matriz A usando un filtro mean de radio 1.

$B[i,j]=\frac{1}{9} \left( \begin{matrix} A[i-1,j-1]&+&A[i-1,j]&+&A[i-1,j+1]&+\\ A[i ,j-1]&+&A[i ,j]&+&A[i ,j+1]&+\\ A[i+1,j-1]&+&A[i+1,j]&+&A[i+1,j+1]&~ \end{matrix} \right)$

Atención: Este filtro tambien es llamado: Mean filtering, Smoothing, Averaging, Box filtering

Devuelve: Retorna la matriz B resultado de procesar la matriz A con un filtro mean de radio 1.

◆ FilterMean3b()

Pds::Matrix Pds::Matrix::FilterMean3b ( void ) const

Procesa la matriz A usando un filtro mean de radio 1.

$B[i,j]=\frac{1}{10} \left( \begin{matrix} A[i-1,j-1]&+&A[i-1,j]&+&A[i-1,j+1]&+\\ A[i ,j-1]&+&2~A[i ,j]&+&A[i ,j+1]&+\\ A[i+1,j-1]&+&A[i+1,j]&+&A[i+1,j+1]&~ \end{matrix} \right)$

Atención: Este filtro tambien es llamado: Mean filtering, Smoothing, Averaging, Box filtering

Devuelve: Retorna la matriz B resultado de procesar la matriz A con un filtro mean de radio 1.

◆ Resize()

Pds::Matrix Pds::Matrix::Resize ( double factor ) const

Retorna una matriz B (size: NlinB,NcolB) resultado de aplicar un subsampling de la matriz A (size: Nlin,Ncol) por un factor.

$1 \leq factor \leq 2$

$NlinB=\left\lfloor\frac{Nlin}{factor}\right\rfloor,\qquad NcolB=\left\lfloor\frac{Ncol}{factor}\right\rfloor.$

Es aplicado el método de bilinear y luego linear entre la aproximacion espacial y la version reduzida por 2.

Parámetros

[in] factor Este factor debe estar entre 1 y 2 inclusive, de lo contrario da error.

Devuelve: Retorna la matriz B resultado de procesar la matriz A. o una vacia en caso de error.

◆ Det()

double Pds::Matrix::Det ( void ) const

Calcula la determinante.

$A.Det() = |A|$

Devuelve: Retorna la determinante de un vector. En caso de que la matriz sea vacía se retorna Pds::Ra::Nan.

Ejemplos: example_matrix_algebra.cpp.

◆ Dot()

double Pds::Matrix::Dot ( const Pds::Matrix & B ) const

Calcula el producto punto entre dos matrices.

$A.Dot(B) = \sum \limits_{i,j} a_{i,j}b_{i,j}$

Parámetros

[in] B Matriz a multiplicar.

Devuelve: Retorna el producto punto. En caso de que la matriz sea vacía se retorna Pds::Ra::Nan.

◆ Rms()

double Pds::Matrix::Rms ( void ) const

Calcula valor raiz quadrático medio de una matriz.

$A.Rms()=\sqrt{\frac{1}{Nlin~Ncol}\sum \limits_{i}^{Nlin} \sum \limits_{j}^{Ncol} {|a_{ij}|}^2}$

Devuelve: Retorna el valor raiz cuadrático medio. En caso de que la matriz sea vacía se retorna Pds::Ra::Nan.

◆ MeanAbsolute()

double Pds::Matrix::MeanAbsolute ( void ) const

Calcula valor absoluto medio de una matriz.

$A.MeanAbsolute()=\frac{1}{Nlin~Ncol}\sum \limits_{i}^{Nlin} \sum \limits_{j}^{Ncol} {|a_{ij}|}$

Devuelve: Retorna el valor absoluto medio. En caso de que la matriz sea vacía se retorna Pds::Ra::Nan.

◆ MeanSquare()

double Pds::Matrix::MeanSquare ( void ) const

Calcula valor quadrático medio de una matriz.

$A.MeanSquare()=\frac{1}{Nlin~Ncol}\sum \limits_{i}^{Nlin} \sum \limits_{j}^{Ncol} {|a_{ij}|}^2$

Devuelve: Retorna el valor cuadrático medio. En caso de que la matriz sea vacía se retorna Pds::Ra::Nan.

◆ SumSquare()

double Pds::Matrix::SumSquare ( void ) const

Calcula valor de la suma quadrática de una matriz.

$A.SumSquare()=\sum \limits_{i} \sum \limits_{j} {|a_{ij}|}^2$

Devuelve: Retorna la suma cuadrática. En caso de que la matriz sea vacía se retorna Pds::Ra::Nan.

◆ Norm()

double Pds::Matrix::Norm ( void ) const

Calcula la 2-norm de una matriz (Frobenius norm).

$||A||_2=\sqrt{\sum \limits_{i} \sum \limits_{j} {|a_{ij}|}^2}$

Devuelve: Retorna la norma de un vector. En caso de que la matriz sea vacía se retorna Pds::Ra::Nan.

◆ PNorm1()

double Pds::Matrix::PNorm1 ( void ) const

Calcula la 1-norm de un vector.

$||A||_1=\max \limits_{j} \sum \limits_{i} {|a_{ij}|}$

Devuelve: Retorna la norma de un vector. En caso de que la matriz sea vacía se retorna Pds::Ra::Nan.

◆ PNormInf()

double Pds::Matrix::PNormInf ( void ) const

Calcula la inf-norm de una matriz.

$||A||_{\infty}=\max \limits_{i} \sum \limits_{j} {|a_{ij}|}$

Devuelve: Retorna la norma de un vector. En caso de que la matriz sea vacía se retorna Pds::Ra::Nan.

◆ Multiindex()

Pds::Vector Pds::Matrix::Multiindex ( const Pds::Vector & d ) const

Dada una matriz $\mathbf{X}=\left[\mathbf{x}_1,\quad \mathbf{x}_2,\quad ...,\quad \mathbf{x}_n,\quad ...,\quad \mathbf{x}_N\right]$ es calculado el vector $\mathbf{\overline{X}}^{\mathbf{d}}$ .

$\mathbf{\overline{X}}^{\mathbf{d}}\equiv \mathbf{x}_1^{d_1} \mathbf{x}_2^{d_2} \mathbf{x}_3^{d_3} ... \mathbf{x}_N^{d_N}$

Parámetros

[in] d Vector de indices $\mathbf{d}=\left[d_1,\quad d_2,\quad ...,\quad d_n,\quad ...,\quad d_N\right]$ .

Devuelve: Retorna el vector $\mathbf{\overline{X}}^{\mathbf{d}}$ . En caso de error se retorna una matriz vazia.

Ejemplos: example_matrix_algebra.cpp.

◆ Find()

std::vector<unsigned int> Pds::Matrix::Find ( void ) const

Retorna una lista de indices donde existe un 1 en la matriz A.

Devuelve: Retorna una lista de indices donde existe un 1 en la matriz A.

◆ FindRows() [1/2]

Pds::Matrix Pds::Matrix::FindRows ( const Pds::Vector & B ) const

Retorna una nueva matriz con las lineas donde existe un 1 en la matriz B. En verdad B es binarizado internamente con (B>0.5). La matriz debe tener el mismo numero de lineas de B caso contrario se retorna una matriz vacia.

Parámetros

[in] B Vector con datos de lineas utiles.

Devuelve: Retorna una nueva matriz con las lineas donde existe un 1 en la matriz B.

◆ FindRows() [2/2]

Pds::Matrix Pds::Matrix::FindRows	(	const Pds::Vector &	B,
		double	b
	)		const

Retorna una nueva matriz con las lineas donde existe un 1 en la matriz B. En verdad B es binarizado internamente con (B>b). La matriz debe tener el mismo numero de lineas de B caso contrario se retorna una matriz vacia.

Parámetros

[in]	B	Vector con datos de lineas utiles.
[in]	b	Umbral de binarización de un vector B.

Devuelve: Retorna una nueva matriz con las lineas donde existe un 1 en la matriz B.

◆ FindRowsBlock()

std::vector<Pds::Matrix> Pds::Matrix::FindRowsBlock ( const Pds::Vector & B ) const

Retorna dos nuevas matrices con las lineas donde existe un 0 (mat0) y un 1 (mat1) en la matriz B. En verdad B es binarizado internamente con (B>0.5). La matriz debe tener el mismo numero de lineas de B caso contrario se retorna una matriz vacia.

Parámetros

[in] B Vector con datos de lineas utiles.

Devuelve: Retorna una std::vector<Pds::Matrix> con dos matrices con las lineas donde existe un 0 y un 1 en la matriz B.

◆ Apply() [1/3]

bool Pds::Matrix::Apply ( double(*)(double) func )

Aplica la función func a cada elemento de la matriz.

$A \leftarrow func(A)$

Parámetros

[in] func Función a aplicar, esta debe tener a forma double func(double).

Devuelve: true si todo fue bien o false si la matriz era vacia.

◆ Apply() [2/3]

bool Pds::Matrix::Apply	(	double(*)(double)	func,
		const Pds::Matrix &	B
	)

Aplica la función func a cada elemento de la matriz.

$A \leftarrow func(B)$

Parámetros

[in]	func	Función a aplicar, esta debe tener a forma double func(double).
[in]	B	Matriz a evaluar con func.

Devuelve: true si todo fue bien o false si la matriz era vacia o si no tiene el mismo tamaño que B.

◆ Apply() [3/3]

bool Pds::Matrix::Apply	(	double(*)(double, double)	func,
		double	var
	)

Aplica la función func a cada elemento de la matriz.

$A \leftarrow func(A,var)$

Parámetros

[in]	func	Función a aplicar, esta debe tener a forma double func(double,double).
[in]	var	Variable a usar em func(double,var).

Devuelve: true si todo fue bien o false si la matriz era vacia.

◆ ApplySub() [1/2]

bool Pds::Matrix::ApplySub	(	double(*)(double)	func,
		const Pds::Matrix &	B,
		const Pds::Matrix &	C
	)

Aplica la función func a cada elemento de la diferencia de matrices.

$A \leftarrow func(B-C)$

Parámetros

[in]	func	Función a aplicar, esta debe tener a forma double double func(double).
[in]	B	Matriz a evaluar con func.
[in]	C	Matriz a evaluar con func.

Devuelve: true si todo fue bien o false si la matriz era vacia o si no tiene el mismo tamaño que B.

◆ ApplySub() [2/2]

bool Pds::Matrix::ApplySub	(	const Pds::Matrix &	B,
		const Pds::Matrix &	C
	)

Aplica la función func a cada elemento de la diferencia de matrices.

$A \leftarrow B-C$

Parámetros

[in]	B	Matriz a evaluar con func.
[in]	C	Matriz a evaluar con func.

Devuelve: true si todo fue bien o false si la matriz era vacia o si no tiene el mismo tamaño que B.

◆ ApplyInCol() [1/2]

bool Pds::Matrix::ApplyInCol	(	unsigned int	col,
		double(*)(double)	func
	)

Aplica la función func a cada elemento de la columna col de la matriz.

Parámetros

[in]	col	Columna a aplicar la función.
[in]	func	Función a aplicar, esta debe tener a forma double func(double).

Devuelve: true si todo fue bien o false si la matriz era vacia.

◆ ApplyInCol() [2/2]

bool Pds::Matrix::ApplyInCol	(	unsigned int	col,
		double(*)(double, double)	func,
		double	var
	)

Aplica la función func a cada elemento de la columna col de la matriz.

Parámetros

[in]	col	Columna a aplicar la función.
[in]	func	Función a aplicar, esta debe tener a forma double func(double,double).
[in]	var	Variable a usar em func(double,var).

Devuelve: true si todo fue bien o false si la matriz era vacia.

◆ OperateRows()

Pds::Matrix Pds::Matrix::OperateRows ( double(*)(const Pds::Matrix &Row) func ) const

Opera la función func usando como entrada cada fila de la matriz.

Parámetros

[in] func Función a aplicar, esta debe tener a forma double func(const Pds::Matrix &Row).

Devuelve: Una matriz columna si todo fue bien o una vacia en caso de error.

◆ OperateCols()

Pds::Matrix Pds::Matrix::OperateCols ( double(*)(const Pds::Matrix &Col) func ) const

Opera la función func usando como entrada cada columna de la matriz.

Parámetros

[in] func Función a aplicar, esta debe tener a forma double func(const Pds::Matrix &Col).

Devuelve: Una matriz linea si todo fue bien o una vacia en caso de error.

◆ Scale()

Pds::Matrix Pds::Matrix::Scale	(	double	minval,
		double	maxval
	)		const

Rescala linearmente los datos desde minval a maxval.

Parámetros

[in]	minval	Valor menor de la escala.
[in]	maxval	Valor maior de la escala.

Devuelve: Retorna la matriz escalada si todo fue bien o una vacia si no.

◆ Round()

Pds::Matrix Pds::Matrix::Round ( unsigned int decimal = 0 ) const

Retorna una matriz con los valores redondeados.

Parámetros

[in] decimal Núros decimales usados.

Devuelve: Retorna la matriz con los valores redondeados si todo fue bien o una vacia si no.

◆ CopyRegion()

bool Pds::Matrix::CopyRegion	(	const Pds::RegionRect &	Rin,
		const Pds::RegionRect &	Rout,
		Pds::Matrix &	Mout
	)		const

Copia la región Rin de la matriz a la región Rout de la matriz Mout.

Ambas regiones deben estar dentro de las matrices y tener el mismo tamaño para que la copia sea realizada.

Parámetros

[in]	Rin	Región en donde se leerán los datos.
[in]	Rout	Región en donde se escribirá.
[out]	Mout	La matriz donde se escribirá.

Devuelve: true si las matrices existen y son copiables o false si no.

◆ InitRegion()

bool Pds::Matrix::InitRegion	(	Pds::RegionRect	R,
		double	val
	)

Inicializa la región R de la matriz con el valor val.

Parámetros

[in]	R	La region a inicializar.
[in]	val	valor a ser usado en la inicialización.

Devuelve: true si todo fue bien o false si no.

Ejemplos: example_matrix_fill.cpp.

◆ GetRegion()

Pds::RegionRect Pds::Matrix::GetRegion ( void ) const

Retorna una variable Pds::RegionRect desde la posicion (0,0), con ancho y alto (Mat.Nlin(),Mat.Ncol()).

Devuelve: La region si todo fue bien, sino se retorna una region donde IsEmpty() == true.

◆ MeanOfRegion() [1/2]

bool Pds::Matrix::MeanOfRegion	(	const Pds::RegionRect &	Rin,
		double *	mean
	)		const

Calcula la media de los elementos en la region, pero para que sea calculado debe existir una interseccion diferente de zero con la matriz. Los valores fuera de la matriz son considerados cero.

$R=Rin\cap R_{A}$

$mean=\mu_{R}= \frac{\sum \limits_{i\in R} Mat\{i\}}{card(R)}$

Parámetros

[in]	Rin	La region a calcular.
[out]	mean	Media.

Devuelve: true si todo fue bien o false si no (ej: mean==NULL).

◆ MeanOfRegion() [2/2]

double Pds::Matrix::MeanOfRegion ( const Pds::RegionRect & Rin ) const

Calcula la media de los elementos en la region, pero para que sea calculado debe existir una interseccion diferente de zero con la matriz. Los valores fuera de la matriz son considerados cero.

$R=Rin\cap R_{A}$

$mean=\mu_{R}= \frac{\sum \limits_{i\in R} Mat\{i\}}{card(R)}$

Parámetros

[in] Rin La region a calcular.

Devuelve: la media o Pds::Ra::Nan si hubo un error (ej: IsEmpty()==true).

◆ MeanSquareOfRegion() [1/2]

bool Pds::Matrix::MeanSquareOfRegion	(	const Pds::RegionRect &	Rin,
		double *	mean
	)		const

Calcula la media del cuadrado de los elementos en la region, pero para que sea calculado debe existir una interseccion diferente de zero con la matriz. Los valores fuera de la matriz son considerados cero.

$R=Rin\cap R_{A}$

$mean=\mu_{R}= \frac{\sum \limits_{i\in R} Mat\{i\}^2}{card(R)}$

Parámetros

[in]	Rin	La region a calcular.
[out]	mean	Media.

Devuelve: true si todo fue bien o false si no (ej: mean==NULL).

◆ MeanSquareOfRegion() [2/2]

double Pds::Matrix::MeanSquareOfRegion ( const Pds::RegionRect & Rin ) const

Calcula la media del cuadrado de los elementos en la region, pero para que sea calculado debe existir una interseccion diferente de zero con la matriz. Los valores fuera de la matriz son considerados cero.

$R=Rin\cap R_{A}$

$mean=\mu_{R}= \frac{\sum \limits_{i\in R} Mat\{i\}^2}{card(R)}$

Parámetros

[in] Rin La region a calcular.

Devuelve: la media o Pds::Ra::Nan si hubo un error (ej: IsEmpty()==true).

◆ StdAndMeanOfRegion()

bool Pds::Matrix::StdAndMeanOfRegion	(	const Pds::RegionRect &	Rin,
		double *	std,
		double *	mean
	)		const

Calcula el desvío padrón y la media de los elementos de la intersección de la región con la matriz.

$R=Rin\cap R_{A}$

$mean=\mu_{R}= \frac{\sum \limits_{i\in R} Mat\{i\}}{card(R)}, \quad std=\sigma_{R}= \sqrt{\frac{\sum \limits_{i\in R} \left(Mat\{i\}-\mu_{R}\right)^2}{card(R)}}$

Parámetros

[in]	Rin	La región a calcular.
[out]	std	Desvío padrón.
[out]	mean	Media.

Devuelve: true si todo fue bien o false si no (ej: IsEmpty()==true).

◆ CorrNormRegions() [1/2]

bool Pds::Matrix::CorrNormRegions	(	const Pds::Matrix &	M1,
		const Pds::RegionRect &	R0,
		const Pds::RegionRect &	R1,
		double *	corrn
	)		const

Calcula correlación normalizada entre los elementos de la intersección de la regiones con sus matrices.

Para que la correlacion sea ejecutada se debe cumplir que ademas que $R_0 \subset M_0$ y $R_1 \subset M_1$ . Con estas condiciones obtenemos las submatrices y .

$S_0 \equiv {M_0}_{R_0}, \qquad S_1 \equiv {M_1}_{R_1}$

$CORR=\frac{E[S_0~S_1]}{\sqrt{MS\{S_0\}~MS\{S_1\}}}$

Parámetros

[in]	M1	Una matriz de la correlación.
[in]	R0	La región a analizar en la matriz M0, el tamaño de R0 debe ser igual al tamaño de R1.
[in]	R1	La región a analizar en la matriz M1, el tamaño de R0 debe ser igual al tamaño de R1.
[out]	corrn	Correlación normalizada.

Devuelve: true si todo fue bien o false si no (ej: pcc==NULL). Retorna false cuando algún lado de las regiones a analizar son cero.

◆ CorrNormRegions() [2/2]

bool Pds::Matrix::CorrNormRegions	(	const Pds::Matrix &	M1,
		const Pds::RegionRect &	R0,
		const Pds::RegionRect &	R1,
		double	means0,
		double	means1,
		double *	corrn
	)		const

Calcula correlación normalizada entre los elementos de la intersección de la regiones con sus matrices.

Para que la correlacion sea ejecutada se debe cumplir que ademas que $R_0 \subset M_0$ y $R_1 \subset M_1$ . Con estas condiciones obtenemos las submatrices y .

$S_0 \equiv {M_0}_{R_0}, \qquad S_1 \equiv {M_1}_{R_1}$

$CORR=\frac{E[S_0~S_1]}{\sqrt{MS\{S_0\}~MS\{S_1\}}}$

Parámetros

[in]	M1	Una matriz de la correlación.
[in]	R0	La región a analizar en la matriz M0, el tamaño de R0 debe ser igual al tamaño de R1.
[in]	R1	La región a analizar en la matriz M1, el tamaño de R0 debe ser igual al tamaño de R1.
[in]	means0	Valor cuadrático medio de la region R0, $MS\{S_0\}$ .
[in]	means1	Valor cuadrático medio de la region R1, $MS\{S_1\}$ .
[out]	corrn	Correlación normalizada.

Devuelve: true si todo fue bien o false si no (ej: pcc==NULL). Retorna false cuando algún lado de las regiones a analizar son cero.

◆ CorrPearsonRegions() [1/2]

bool Pds::Matrix::CorrPearsonRegions	(	const Pds::Matrix &	M1,
		const Pds::RegionRect &	R0,
		const Pds::RegionRect &	R1,
		double *	pcc
	)		const

Calcula el coeficiente de correlación de Pearson (PCC) entre los elementos de la intersección de la regiones con sus matrices.

Para que la correlacion sea ejecutada se debe cumplir que ademas que $R_0 \subset M_0$ y $R_1 \subset M_1$ . Con estas condiciones obtenemos las submatrices y .

$S_0 \equiv {M_0}_{R_0}, \qquad S_1 \equiv {M_1}_{R_1}$

$PCC=\frac{E[(S_0-\mu_{S_0})(S_1-\mu_{S_1})]}{\sigma_{S_0}\sigma_{S_1}}$

Si algun desvío padrón es cero entonces existen casos especiales para el valor de PCC.

Casos especiales para PCC
PCC	sigma0	sigma1	mean0	mean1
0.0	Zero	NonZero	?	?
0.0	NonZero	Zero	?	?
1.0	Zero	Zero	Positive	Positive
1.0	Zero	Zero	Negative	Negative
-1.0	Zero	Zero	Positive	Negative
-1.0	Zero	Zero	Negative	Positive
0.0	Zero	Zero	Zero	NonZero
0.0	Zero	Zero	NonZero	Zero
1.0	Zero	Zero	Zero	Zero

Parámetros

[in]	M1	Una matriz de la correlación.
[in]	R0	La región a analizar en la matriz M0, el tamaño de R0 debe ser igual al tamaño de R1.
[in]	R1	La región a analizar en la matriz M1, el tamaño de R0 debe ser igual al tamaño de R1.
[out]	pcc	Coeficiente de correlación de Pearson.

Devuelve: true si todo fue bien o false si no (ej: pcc==NULL). Retorna false cuando algún lado de las regiones a analizar son cero.

◆ CorrPearsonRegions() [2/2]

bool Pds::Matrix::CorrPearsonRegions	(	const Pds::Matrix &	M1,
		const Pds::RegionRect &	R0,
		const Pds::RegionRect &	R1,
		double	mean0,
		double	mean1,
		double	std0,
		double	std1,
		double *	pcc
	)		const

Calcula el coeficiente de correlación de Pearson (PCC) entre los elementos de la intersección de la regiones con sus matrices.

Para que la correlacion sea ejecutada se debe cumplir que ademas que $R_0 \subset M_0$ y $R_1 \subset M_1$ . Con estas condiciones obtenemos las submatrices y .

$S_0 \equiv {M_0}_{R_0}, \qquad S_1 \equiv {M_1}_{R_1}$

$PCC=\frac{E[(S_0-\mu_{S_0})(S_1-\mu_{S_1})]}{\sigma_{S_0}\sigma_{S_1}}$

Si algun desvío padrón es cero entonces existen casos especiales para el valor de PCC.

Casos especiales para PCC
PCC	sigma0	sigma1	mean0	mean1
0.0	Zero	NonZero	?	?
0.0	NonZero	Zero	?	?
1.0	Zero	Zero	Positive	Positive
1.0	Zero	Zero	Negative	Negative
-1.0	Zero	Zero	Positive	Negative
-1.0	Zero	Zero	Negative	Positive
0.0	Zero	Zero	Zero	NonZero
0.0	Zero	Zero	NonZero	Zero
1.0	Zero	Zero	Zero	Zero

Parámetros

[in]	M1	Una matriz de la correlación.
[in]	R0	La región a analizar en la matriz M0, el tamaño de R0 debe ser igual al tamaño de R1.
[in]	R1	La región a analizar en la matriz M1, el tamaño de R0 debe ser igual al tamaño de R1.
[in]	mean0	La media de la region R0.
[in]	mean1	La media de la region R1.
[in]	std0	El desvio padron de la region R0.
[in]	std1	El desvio padron de la region R1.
[out]	pcc	Coeficiente de correlación de Pearson.

Devuelve: true si todo fue bien o false si no (ej: pcc==NULL). Retorna false cuando algún lado de las regiones a analizar son cero.

◆ ToString()

std::string Pds::Matrix::ToString ( void ) const

Convierte los datos de la matriz en un std::string.

Devuelve: Retorna un std::string. Si la matriz es nula retorna un string sin caracteres.

◆ Print() [1/2]

void Pds::Matrix::Print ( std::string str ) const

Imprime en pantalla el contenido de la matriz después del texto indicado en str.

Parámetros

str	Texto a mostrar antes de imprimir.

Ejemplos: example_matrix_algebra.cpp, example_matrix_assignment.cpp, example_matrix_create.cpp, example_matrix_export.cpp, example_matrix_fill.cpp, example_matrix_getset.cpp, example_matrix_getset_extras.cpp, example_ra_indices.cpp, example_vector_create.cpp, example_vector_poly.cpp y example_vector_statistics.cpp.

◆ Print() [2/2]

void Pds::Matrix::Print ( void ) const

Imprime en pantalla el contenido de la matriz.

◆ MakeEmpty()

void Pds::Matrix::MakeEmpty ( void )

libera los datos internos de la matriz y la convierte en una matriz nula. es decir con lineas y columnas cero.

Una matriz $\mathbf{A}$ está vacía si $\mathbf{A}=[]_{0,0}$ .

◆ Reshape()

bool Pds::Matrix::Reshape	(	unsigned int	Nlin,
		unsigned int	Ncol
	)

Remodela los datos internos de la array y la convierte en una array de tamaño diferente, los datos que faltan se rellenan con cero.

Parámetros

[in]	Nlin	Número de lineas. Da error si el valor es cero.
[in]	Ncol	Número de columnas. Da error si el valor es cero.

◆ SaveInStream()

bool Pds::Matrix::SaveInStream ( std::ofstream & myfile ) const

Escribe en un archivo de texto el contenido de la matriz.

Parámetros

[in] myfile Stream del archivo donde se escribirán los datos.

Devuelve: Retorna true si todo fue bien o false en caso de error.

◆ LoadFromStream()

bool Pds::Matrix::LoadFromStream	(	std::ifstream &	ifs,
		unsigned int	Nlin,
		unsigned int	Ncol
	)

Lee de un archivo una matriz de Nlin lineas y Ncol columnas. Si la lectura es satisfactoria el contenido actual de la matriz es liberado, en caso de error la matriz queda vacia, esdecir .IsEmpty() retorna true.

Parámetros

[in]	ifs	Stream del archivo donde se leerán los datos.
[in]	Nlin	El numero de lineas en el arreglo.
[in]	Ncol	El numero de columnas en el arreglo.

Devuelve: Retorna true si todo fue bien o false en caso de error.

◆ LoadLineFromStream()

bool Pds::Matrix::LoadLineFromStream ( std::ifstream & ifs )

Lee una linea de un archivo y crea una matriz de Nlin=1 y Ncol columnas. Si la lectura es satisfactoria el contenido actual de la matriz es liberado, en caso de error la matriz queda vacia, esdecir .IsEmpty() retorna true.

Parámetros

[in] ifs Stream del archivo donde se leerán los datos.

Devuelve: Retorna true si todo fue bien o false en caso de error.

◆ Save()

bool Pds::Matrix::Save ( const std::string & filepath ) const

Escribe en un archivo de texto el contenido de la matriz.

Parámetros

[in] filepath El archivo donde se escribirán los datos.

Devuelve: Retorna true si todo fue bien o false en caso de error.

Ejemplos: example_matrix_create.cpp y example_matrix_export.cpp.

◆ Load()

bool Pds::Matrix::Load ( const std::string & filepath )

Lee de un archivo una matriz de Nlin lineas y Ncol columnas. Si la lectura es satisfactoria el contenido actual de la matriz es liberado, en caso de error la matriz queda vacia, esdecir .IsEmpty() retorna true.

Parámetros

[in] filepath El archivo donde se leerán los datos.

Devuelve: Retorna true si todo fue bien o false en caso de error.

◆ ExportCsvFile() [1/2]

bool Pds::Matrix::ExportCsvFile	(	const std::string &	filepath,
		char	delimitador = `','`
	)		const

Escribe en un archivo de texto el contenido de la matriz usando un formato Csv (Comma Separated Values).

Parámetros

[in]	filepath	El archivo donde se escribirán los datos.
[in]	delimitador	Delimitador separador de elementos, ',' por defecto.

Devuelve: Retorna true si todo fue bien o false en caso de error.

Ejemplos: example_matrix_export.cpp.

◆ ExportCsvFile() [2/2]

bool Pds::Matrix::ExportCsvFile	(	const std::string &	filepath,
		std::vector< std::string >	titles,
		char	delimitador = `','`
	)		const

Escribe en un archivo de texto el contenido de la matriz usando un formato Csv (Comma Separated Values).

Parámetros

[in]	filepath	El archivo donde se escribirán los datos.
[in]	titles	Titulos al inicio del archivo. Solo es escrito si el número de elementos es igual a Ncol.
[in]	delimitador	Delimitador separador de elementos, ',' por defecto.

Devuelve: Retorna true si todo fue bien o false en caso de error.

◆ ExportMatFile()

bool Pds::Matrix::ExportMatFile	(	const std::string &	pname,
		const std::string &	filepath
	)		const

Escribe en un archivo binario en formato de octave la matriz. Es necesario dar un nombre como identificador de matriz.

Para cargar los datos en OCTAVE se puede usar el siguiente código

% Load all the variables in "matfile.mat" in the workspace.
load("-v4","matfile.mat");

% Load the B variable in a STRUCTURE
STRUCTURE=load("-v4","matfile.mat","B");

Version 4 MAT-File Format:Documento externo Documento oficial

Parámetros

[in]	pname	El nombre de la matriz.
[in]	filepath	El archivo donde se escribirán los datos.

Devuelve: Retorna true si todo fue bien o false si no.

Ejemplos: example_matrix_export.cpp.

◆ ExportBmpFile() [1/2]

bool Pds::Matrix::ExportBmpFile	(	const unsigned char	colormap[256][3],
		const std::string &	filepath
	)		const

Escribe en una matriz en un archivo binario en formato BMP. Losdatos deben ir de 0 a 255, valores superiores o inferiores serán truncados.

Parámetros

[in]	colormap	Mapa de colores. Ejemplo: Pds::Colormap::Jet, Pds::Colormap::Bone,
[in]	filepath	Nombre del archivo donde se escribirán los datos Pds::Colormap::Hot,Pds::Colormap::Jolly.

Devuelve: Retorna true si todo fue bien o false si no.

Ejemplos: example_matrix_fill.cpp.

◆ GetSamples() [1/2]

static Pds::Matrix Pds::Matrix::GetSamples ( const std::vector< Pds::Matrix > & Block )

static

Convierte las muestras de un bloque (std::vector<Pds::Matrix>) de N matrices (Pds::Matrix) de L elementos, en una matriz Pds::Matrix(L,N). Lee los datos de la columna actual y pasa a la siguiente, desde la columna 0.

Parámetros

[in] Block Un bloque (std::vector<Pds::Matrix>) de N matrices (Pds::Matrix) de L elementos.

Devuelve: Retorna una matriz de L lineas y N columnas. en caso de error se retorna una matriz vacía.

◆ GetSamples() [2/2]

static Pds::Matrix Pds::Matrix::GetSamples	(	const std::vector< Pds::Matrix > &	Block,
		const std::vector< unsigned int >	Id
	)

static

Convierte M muestras de un bloque (std::vector<Pds::Matrix>) de N matrices (Pds::Matrix) de L elementos, en una matriz Pds::Matrix(M,N).

Parámetros

[in]	Block	Un bloque (std::vector<Pds::Matrix>) de N matrices (Pds::Matrix) de L elementos.
[in]	Id	Vector con M indices que representan las muestras a ser seleccionadas.

Devuelve: Retorna una matriz de M lineas y N columnas. en caso de error se retorna una matriz vacía.

◆ FromString()

static Pds::Matrix Pds::Matrix::FromString ( const std::string & str )

static

Convierte un sdt::string a una Matriz de Nlin lineas y Ncol columnas.

Parámetros

[in] str Cadena a leer.

Devuelve: Retorna una matriz. en caso de error se retorna una matriz vacía.

◆ ExportBmpFile() [2/2]

static bool Pds::Matrix::ExportBmpFile	(	const Pds::Matrix &	R,
		const Pds::Matrix &	G,
		const Pds::Matrix &	B,
		const std::string &	bmpfilename
	)

static

Escribe en una matriz en un archivo binario en formato BMP. Losdatos deben ir de 0 a 255, valores superiores o inferiores serán truncados.

Parámetros

[in]	R	Matriz con colores red 0<=r<=255.
[in]	G	Matriz con colores green 0<=r<=255.
[in]	B	Matriz con colores blue 0<=r<=255.
[in]	bmpfilename	Nombre del archivo donde se escribirán los datos.

Devuelve: Retorna true si todo fue bien o false si no.

◆ ImportBmpFile()

static std::vector<Pds::Matrix> Pds::Matrix::ImportBmpFile ( const std::string & bmpfilename )

static

Lee matrices de un archivo binario en formato BMP.

Atención

Solo lee matrices con :

Suported bmp files
Without compression
Number of planes equal to 1
8,16,24 o 32 bits by pixel.

Parámetros

[in] bmpfilename Nombre del archivo donde se leeran los datos.

Devuelve: Retorna un vector de matrices, una matriz por cada byte en un pixel.

◆ MeanBlock()

static Pds::Matrix Pds::Matrix::MeanBlock ( const std::vector< Pds::Matrix > & Block )

static

Calcula A,la matriz media de un conjunto de N matrizes agrupadas en un std::vector.

$A=\frac{Block[0]+Block[1]+...+Block[N-1]}{N}$

Parámetros

[in] Block Vector std::vector con N elementos Pds::Matrix.

Devuelve: Retorna la matriz media de un conjunto de N matrizes agrupadas en un std::vector.

◆ T()

Pds::Matrix Pds::Matrix::T ( void ) const

Transpuesta de si mismo (A), el resultado es cargado en B.

$B \leftarrow transpose(A)$

Pds::Matrix A(4,4);
Pds::Matrix B;
 
A.FillRandU();
 
B=A.T();
 
std::cout<<B;

Devuelve: Retorna un nuevo objeto con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

Ejemplos: example_matrix_algebra.cpp, example_vector_create.cpp, example_vector_poly.cpp y example_vector_statistics.cpp.

◆ MtM()

Pds::Matrix Pds::Matrix::MtM ( void ) const

Retorna A.T()*A cargado en B.

$B \leftarrow A^{T}A$

Pds::Matrix A(4,4);
Pds::Matrix B;
 
A.FillRandU();
 
B=A.MtM();
 
std::cout<<B;

Devuelve: Retorna un nuevo objeto con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ Inv()

Pds::Matrix Pds::Matrix::Inv ( double * rcond = NULL ) const

Retorna la matriz inversa.

rcond es:

$rcond \leftarrow \frac{1.0}{||A||_1 ||A^{-1}||_1}$

Atención: Internamente es usado el método de eliminación Gaussiana para obtener la inversa.

Parámetros

[out] rcond Esta variable es cargada con el valor del reciproco del condicional de la matriz. Si esta es la matriz A. Si la matriz esta bien condicionada entonces rcond es próximo a 1.0 y si la matriz esta pobremente condicionada este valor estará proximo a 0.0. Si la variable rcond no es entregada entonces sera mostrado un mensaje de advertencia por consola si el valor de rcond es menor a Pds::Ra::WarningRCond.

Devuelve: Retorna la matriz inversa si todo fue bien o una matriz vacia (.IsEmpty()==true) si no es posible calcular la inversa.

◆ PInv()

Pds::Matrix Pds::Matrix::PInv ( double * rcond = NULL ) const

Procesa esta matriz A y retorna B la matriz pseudo inversa de Moore Penrose.

$B \leftarrow (A^T A)^{-1}A^T$

$rcond \leftarrow \frac{1.0}{||A^T A||_1 ||(A^T A)^{-1}||_1}$

Atención: Internamente es usado el método de eliminación Gaussiana para en el cáculo de la inversa.

Parámetros

[out] rcond Esta variable es cargada con el valor del reciproco del condicional de la matriz . Si la matriz está bien condicionada entonces rcond es próximo a 1.0 y si la matriz esta pobremente condicionada este valor estará proximo a 0.0. Si la variable rcond no es entregada entonces sera mostrado un mensaje de advertencia por consola si el valor de rcond es menor a Pds::Ra::WarningRCond.

Devuelve: Retorna la matriz inversa si todo fue bien o una matriz vacia (.IsEmpty()==true) si no es posible calcular la inversa.

◆ operator-() [1/4]

Pds::Matrix Pds::Matrix::operator- ( void ) const

Cambia de signo a si mismo (A), el resultado es cargado en B. Este operador es similar al método unario Minus.

$B \leftarrow -A$

Pds::Matrix A(4,4);
Pds::Matrix B;
 
A.Fill(2.0);
 
B=-A;
 
std::cout<<B;

Devuelve: Retorna un nuevo objeto con el resultado, o una matriz vazia (this->IsEmpty() igual a true) en caso de error.

◆ Minus()

Pds::Matrix Pds::Matrix::Minus ( void ) const

Cambia de signo a si mismo (A), el resultado es cargado en B. Este método es similar al operador unario -.

$B \leftarrow -A$

Pds::Matrix A(4,4);
Pds::Matrix B;
 
A.Fill(2.0);
 
B=A.Minus();
 
std::cout<<B;

Devuelve: Retorna un nuevo objeto con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ operator+() [1/4]

Pds::Matrix Pds::Matrix::operator+ ( void ) const

Asigna el signo + a si mismo (A), el resultado es cargado en B. Este operador es similar al método unario Plus.

$B \leftarrow +A$

Pds::Matrix A(4,4);
Pds::Matrix B;
 
A.Fill(2.0);
 
B=+A;
 
std::cout<<B;

Devuelve: Retorna un nuevo objeto con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ Plus()

Pds::Matrix Pds::Matrix::Plus ( void ) const

Asigna el signo + a si mismo (A), el resultado es cargado en B. Este método es similar al operador unario +.

$B \leftarrow +A$

Pds::Matrix A(4,4);
Pds::Matrix B;
 
A.Fill(2.0);
 
B=A.Plus();
 
std::cout<<B;

Devuelve: Retorna un nuevo objeto con el resultado, o una matriz vazia (this->IsEmpty() igual a true) en caso de error.

◆ operator*() [1/3]

Pds::Matrix Pds::Matrix::operator* ( double b ) const

Multiplica con sigo mismo (A), un valor b y el resultado es cargado en C. Este operador es similar al método Mul()

$C \leftarrow A*b$

Pds::Matrix A(4,4);
Pds::Matrix C;
 
A.Fill(2.0);
 
C=A*2.0;
 
std::cout<<C;

Parámetros

[in] b el valor a multiplicar

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

Ver también: Mul

◆ operator*() [2/3]

Pds::Matrix Pds::Matrix::operator* ( const Pds::Matrix & B ) const

Multiplica con sigo mismo (A), una matriz B y el resultado es cargado en C. Este operador es similar al método Mul()

$C \leftarrow A*B$

Pds::Matrix A(4,4);
Pds::Matrix B(4,4);
Pds::Matrix C;
 
A.Fill(2.0);
B.Fill(1.0);
 
C=A*B;
 
std::cout<<C;

Parámetros

[in] B la matriz a multiplicar

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

Ver también: Mul

◆ Mul() [1/3]

Pds::Matrix Pds::Matrix::Mul ( double b ) const

Multiplica con sigo mismo (A), un valor b y el resultado es cargado en C. Este método es similar al operador *.

$C \leftarrow A*b$

Pds::Matrix A(4,4);
Pds::Matrix C;
 
A.Fill(2.0);
 
C=A.Mul(2.0);
 
std::cout<<C;

Parámetros

[in] b el valor a multiplicar

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ Mul() [2/3]

Pds::Matrix Pds::Matrix::Mul ( const Pds::Matrix & B ) const

Multiplica con sigo mismo (A), una matriz B y el resultado es cargado en C. Este método es similar al operador *.

$C \leftarrow A*B$

Pds::Matrix A(4,4);
Pds::Matrix B(4,4);
Pds::Matrix C;
 
A.Fill(2.0);
B.Fill(1.0);
 
C=A.Mul(B);
 
std::cout<<C;

Parámetros

[in] B la matriz a multiplicar

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ Mul() [3/3]

Pds::Matrix Pds::Matrix::Mul ( const Pds::Vector & B ) const

Multiplica con sigo mismo (A), un vector B y el resultado es cargado en C. Este método es similar al operador *.

$C \leftarrow A*B$

Pds::Matrix A(4,4);
Pds::Vector B(4);
Pds::Matrix C;
 
A.Fill(2.0);
B.Fill(1.0);
 
C=A.Mul(B);
 
std::cout<<C;

Parámetros

[in] B El vector a multiplicar

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ MulComp() [1/2]

Pds::Matrix Pds::Matrix::MulComp	(	double	b,
		const Pds::Vector &	B
	)		const

Multiplica con sigo mismo (A), un vector [b;B] y el resultado es cargado en C. Este método es similar al operador *.

$C \leftarrow A*[b;B]$

Pds::Matrix A(4,4);
Pds::Vector B(3);
Pds::Matrix C;
 
A.Fill(2.0);
B.Fill(1.0);
 
C=A.MulComp(3,B);
 
std::cout<<C;

Parámetros

[in]	b	El pedazo de arriba del vector a multiplicar
[in]	B	El pedazo de abajo del vector a multiplicar

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ MulComp() [2/2]

bool Pds::Matrix::MulComp	(	double	b,
		const Pds::Vector &	B,
		Pds::Vector &	Out
	)		const

Multiplica con sigo mismo (A), un vector [b;B] y el resultado es cargado en Out. Este método es similar al operador *.

$Out \leftarrow A*[b;B]$

Pds::Matrix A(4,4);
Pds::Vector B(3);
Pds::Vector Out(4);
 
A.Fill(2.0);
B.Fill(1.0);
 
A.MulComp(-1,B,Out);
 
std::cout<<Out;

Parámetros

[in]	b	El pedazo de arriba del vector a multiplicar
[in]	B	El pedazo de abajo del vector a multiplicar
[out]	Out	El vector resultante de la multiplicación.

Devuelve: Retorna tru si todo fue bien y false si no. El método verifica los tamaños de B y Out, si son incorrectos se retorna false y no se hace nada.

◆ MulT()

Pds::Matrix Pds::Matrix::MulT ( const Pds::Matrix & B ) const

Multiplica con sigo mismo (A), la transpuesta de una matriz B y el resultado es cargado en C. Este método es similar al operador *.

$C \leftarrow A*B^T$

Pds::Matrix A(4,4);
Pds::Matrix B(4,4);
Pds::Matrix C;
 
A.Fill(2.0);
B.Fill(1.0);
 
C=A.MulT(B);
 
std::cout<<C;

Parámetros

[in] B la matriz a multiplicar

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ TMul()

Pds::Matrix Pds::Matrix::TMul ( const Pds::Matrix & B ) const

Multiplica con la transpuesta de sí mismo (A^T), la matriz B y el resultado es cargado en C. Este método es similar al operador *.

$C \leftarrow A^T*B$

Pds::Matrix A(4,2);
Pds::Matrix B(4,2);
Pds::Matrix C;
 
A.Fill(2.0);
B.Fill(1.0);
 
C=A.TMul(B);
 
std::cout<<C;

Parámetros

[in] B la matriz a multiplicar

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ operator+() [2/4]

Pds::Matrix Pds::Matrix::operator+ ( double b ) const

[Elemento a elemento] Suma con sigo mismo (A), un valor b y el resultado es cargado en C. Este operador es similar al método Add()

$C \leftarrow A+b$

Pds::Matrix A(4,4);
Pds::Matrix C;
 
A.Fill(2.0);
 
C=A+2.0;
 
std::cout<<C;

Parámetros

[in] b El valor a sumar

Devuelve: Retorna un nuevo objeto con el resultado, o una matriz vazia (this->IsEmpty() igual a true) en caso de error.

Ver también: Add

◆ operator+() [3/4]

Pds::Matrix Pds::Matrix::operator+ ( const Pds::Matrix & B ) const

[Elemento a elemento] Suma con sigo mismo (A), una matriz B y el resultado es cargado en C. Este operador es similar al método Add()

$C \leftarrow A+B$

Pds::Matrix A(4,4);
Pds::Matrix B(4,4);
Pds::Matrix C;
 
A.Fill(2.0);
B.Fill(1.0);
 
C=A+B;
 
std::cout<<C;

Parámetros

[in] B la matriz a sumar

Devuelve: Retorna un nuevo objeto con el resultado, o una matriz vazia (this->IsEmpty() igual a true) en caso de error.

Ver también: Add

◆ Add() [1/2]

Pds::Matrix Pds::Matrix::Add ( double b ) const

[Elemento a elemento] Suma con sigo mismo (A), una valor b y el resultado es cargado en C. Este método es similar al operador +

$C \leftarrow A+b$

Pds::Matrix A(4,4);
Pds::Matrix C;
 
A.Fill(2.0);
 
C=A.Add(2.0);
 
std::cout<<C;

Parámetros

[in] b El valor a sumar

Devuelve: Retorna un nuevo objeto con el resultado, o una matriz vazia (this->IsEmpty() igual a true) en caso de error.

◆ Add() [2/2]

Pds::Matrix Pds::Matrix::Add ( const Pds::Matrix & B ) const

[Elemento a elemento] Suma con sigo mismo (A), una matriz B y el resultado es cargado en C. Este metodo es similar al operador +

$C \leftarrow A+B$

Pds::Matrix A(4,4);
Pds::Matrix B(4,4);
Pds::Matrix C;
 
A.Fill(2.0);
B.Fill(1.0);
 
C=A.Add(B);
 
std::cout<<C;

Parámetros

[in] B la matriz a sumar

Devuelve: Retorna un nuevo objeto con el resultado, o una matriz vazia (this->IsEmpty() igual a true) en caso de error.

◆ operator-() [2/4]

Pds::Matrix Pds::Matrix::operator- ( double b ) const

[Elemento a elemento] Resta con sigo mismo (A), un valor b y el resultado es cargado en C. Este operador es similar al método Sub()

$C \leftarrow A-b$

Pds::Matrix A(4,4);
Pds::Matrix C;
 
A.Fill(2.0);
 
C=A-2.0;
 
std::cout<<C;

Parámetros

[in] b El valor a restar

Devuelve: Retorna un nuevo objeto con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

Ver también: Add

◆ operator-() [3/4]

Pds::Matrix Pds::Matrix::operator- ( const Pds::Matrix & B ) const

[Elemento a elemento] Resta con sigo mismo (A), una matriz B y el resultado es cargado en C. Este operador es similar al método Sub

$C \leftarrow A-B$

Pds::Matrix A(4,4);
Pds::Matrix B(4,4);
Pds::Matrix C;
 
A.Fill(2.0);
B.Fill(1.0);
 
C=A-B;
 
std::cout<<C;

Parámetros

[in] B la matriz que resta

Devuelve: Retorna un nuevo objeto con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ Sub() [1/2]

Pds::Matrix Pds::Matrix::Sub ( double b ) const

[Elemento a elemento] Resta con sigo mismo (A), una valor b y el resultado es cargado en C. Este método es similar al operador -

$C \leftarrow A-b$

Pds::Matrix A(4,4);
Pds::Matrix C;
 
A.Fill(2.0);
 
C=A.Sub(2.0);
 
std::cout<<C;

Parámetros

[in] b El valor a restar

Devuelve: Retorna un nuevo objeto con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ Sub() [2/2]

Pds::Matrix Pds::Matrix::Sub ( const Pds::Matrix & B ) const

[Elemento a elemento] Resta con sigo mismo (A), una matriz B y el resultado es cargado en C. Este método es similar al operador -

$C \leftarrow A-B$

Pds::Matrix A(4,4);
Pds::Matrix B(4,4);
Pds::Matrix C;
 
A.Fill(2.0);
B.Fill(1.0);
 
C=A.Sub(B);
 
std::cout<<C;

Parámetros

[in] B la matriz que resta

Devuelve: Retorna un nuevo objeto con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ AddRowMatrix()

Pds::Matrix Pds::Matrix::AddRowMatrix ( const Pds::Matrix & B ) const

Suma con sigo mismo (A), una matriz B linea y el resultado es cargado en C. La unica linea de B es sumada a cada linea de A.

$C \leftarrow A+B$

Pds::Matrix A(4,4);
Pds::Matrix B(1,4);
Pds::Matrix C;
 
A.Fill(2.0);
B.Fill(1.0);
 
C=A.AddRowMatrix(B);
 
std::cout<<C;

Parámetros

[in] B la matriz que suma

Devuelve: Retorna un nuevo objeto con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error. Existe error si B esta vacio o si B no es una matri linea.

◆ SubRowMatrix()

Pds::Matrix Pds::Matrix::SubRowMatrix ( const Pds::Matrix & B ) const

Resta con sigo mismo (A), una matriz B linea y el resultado es cargado en C. La unica linea de B es restada a cada linea de A.

$C \leftarrow A-B$

Pds::Matrix A(4,4);
Pds::Matrix B(1,4);
Pds::Matrix C;
 
A.Fill(2.0);
B.Fill(1.0);
 
C=A.SubRowMatrix(B);
 
std::cout<<C;

Parámetros

[in] B la matriz que resta

Devuelve: Retorna un nuevo objeto con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error. Existe error si B esta vacio o si B no es una matri linea.

◆ operator/() [1/3]

Pds::Matrix Pds::Matrix::operator/ ( double b ) const

[Elemento a elemento] Divide con sigo mismo (A), un valor b y el resultado es cargado en C. Este operador es similar al método Div()

$C \leftarrow A/b$

Pds::Matrix A(4,4);
Pds::Matrix C;
 
A.Fill(2.0);
 
C=A/2.0;
 
std::cout<<C;

Parámetros

[in] b el valor a dividir

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

Ver también: Mul

◆ operator/() [2/3]

Pds::Matrix Pds::Matrix::operator/ ( const Pds::Matrix & B ) const

[Elemento a elemento] Divide con sigo mismo (A), elemento a elemento, una matriz B y el resultado es cargado en C. Este método es similar al método .Div()

$C \leftarrow A / B$

Pds::Matrix A(4,4);
Pds::Matrix B(4,4);
Pds::Matrix C;
 
A.Fill(1.0);
B.Fill(2.0);
 
C=A/B;
 
std::cout<<C;

Parámetros

[in] B la matriz a dividir

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ Div() [1/2]

Pds::Matrix Pds::Matrix::Div ( double b ) const

[Elemento a elemento] Divide con sigo mismo (A), un valor b y el resultado es cargado en C. Este método es similar al operador /

$C \leftarrow A/b$

Pds::Matrix A(4,4);
Pds::Matrix C;
 
A.Fill(2.0);
 
C=A.Div(2.0);
 
std::cout<<C;

Parámetros

[in] b el valor a dividir

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ Div() [2/2]

Pds::Matrix Pds::Matrix::Div ( const Pds::Matrix & B ) const

[Elemento a elemento] Divide con sigo mismo (A), elemento a elemento, una matriz B y el resultado es cargado en C. Este método es similar al operador /

$C \leftarrow A / B$

Pds::Matrix A(4,4);
Pds::Matrix B(4,4);
Pds::Matrix C;
 
A.Fill(1.0);
B.Fill(2.0);
 
C=A.Div(B);
 
std::cout<<C;

Parámetros

[in] B la matriz a dividir

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ DivBelow()

Pds::Matrix Pds::Matrix::DivBelow ( double b ) const

[Elemento a elemento] Divide con sigo mismo (A), un valor b y el resultado es cargado en C. Este método es similar al operador /

$C \leftarrow b/A$

Pds::Matrix A(4,4);
Pds::Matrix C;
 
A.Fill(2.0);
 
C=A.DivBelow(1.0);
 
std::cout<<C;

Parámetros

[in] b El valor del numerador en la division

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ operator&()

Pds::Matrix Pds::Matrix::operator& ( const Pds::Matrix & B ) const

[Elemento a elemento] Multiplica con sigo mismo (A), elemento a elemento, una matriz B y el resultado es cargado en C. Este método es similar al método .Product()

$C \leftarrow A \& B$

Pds::Matrix A(4,4);
Pds::Matrix B(4,4);
Pds::Matrix C;
 
A.Fill(2.0);
B.Fill(1.0);
 
C=A&B;
 
std::cout<<C;

Atención

El operador & tiene baja precedencia, por lo que recomendamos usar parentesis (A&B).

Operator Precedence
Precedence	Operator
5	a*b a/b ab
6	a+b a-b
7	<< >>
9	> < >= <=
10	== !=
11	&
12	^

Parámetros

[in] B la matriz a multiplicar

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ Product() [1/2]

Pds::Matrix Pds::Matrix::Product ( const Pds::Matrix & B ) const

[Elemento a elemento] Multiplica con sigo mismo (A), elemento a elemento, una matriz B y el resultado es cargado en C. Este método es similar al operador &

$C \leftarrow A\&B$

Pds::Matrix A(4,4);
Pds::Matrix B(4,4);
Pds::Matrix C;
 
A.Fill(2.0);
B.Fill(1.0);
 
C=A.Product(B);
 
std::cout<<C;

Parámetros

[in] B la matriz a multiplicar

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ Product() [2/2]

Pds::Matrix Pds::Matrix::Product	(	double(*)(double)	func,
		const Pds::Matrix &	B
	)		const

[Elemento a elemento] Multiplica con sigo mismo (A), elemento a elemento, una matriz func(B) y el resultado es cargado en C. Este método es similar al operador &

$C \leftarrow A\& func(B)$

Pds::Matrix A(4,4);
Pds::Matrix B(4,4);
Pds::Matrix C;
 
A.Fill(2.0);
B.Fill(1.0);
 
C=A.Product(func,B);
 
std::cout<<C;

Parámetros

[in]	func	Función a evaluar.
[in]	B	la matriz a multiplicar.

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ ProductSelf() [1/3]

bool Pds::Matrix::ProductSelf ( double b )

Multiplica con sigo mismo (A), un valor b y el resultado es cargado en A.

$A \leftarrow b~A$

Pds::Matrix A(4,4);
double b=3;
 
A.Fill(2.0);
 
A.ProductSelf(b);
 
std::cout<<A;

Parámetros

[in] b El valor a multiplicar.

Devuelve: true si todo fue bien o false en caso de error.

◆ ProductSelf() [2/3]

bool Pds::Matrix::ProductSelf ( const Pds::Matrix & B )

[Elemento a elemento] Multiplica con sigo mismo (A), elemento a elemento, una matriz B y el resultado es cargado en A.

$A \leftarrow A\& B$

Pds::Matrix A(4,4);
Pds::Matrix B(4,4);
 
A.Fill(2.0);
B.Fill(1.0);
 
A.ProductSelf(B);
 
std::cout<<A;

Parámetros

[in] B la matriz a multiplicar.

Devuelve: true si todo fue bien o false en caso de error.

◆ ProductSelf() [3/3]

bool Pds::Matrix::ProductSelf	(	double(*)(double)	func,
		const Pds::Matrix &	B
	)

[Elemento a elemento] Multiplica con sigo mismo (A), elemento a elemento, una matriz func(B) y el resultado es cargado en A.

$A \leftarrow A\& func(B)$

Pds::Matrix A(4,4);
Pds::Matrix B(4,4);
 
A.Fill(2.0);
B.Fill(1.0);
 
A.ProductSelf(func,B);
 
std::cout<<A;

Parámetros

[in]	func	Función a evaluar.
[in]	B	la matriz a multiplicar.

Devuelve: true si todo fue bien o false en caso de error.

◆ ProductSelfMinus() [1/2]

bool Pds::Matrix::ProductSelfMinus	(	double	b,
		const Pds::Matrix &	B
	)

[Elemento a elemento] Multiplica con sigo mismo (A), elemento a elemento, una matriz (b-B) y el resultado es cargado en A.

$A \leftarrow A\& (b-B)$

Pds::Matrix A(4,4);
Pds::Matrix B(4,4);
 
A.Fill(2.0);
B.Fill(1.0);
 
A.ProductSelfMinus(1,B);
 
std::cout<<A;

Parámetros

[in]	b	La variable a multiplicar.
[in]	B	La matriz a multiplicar.

Devuelve: true si todo fue bien o false en caso de error.

◆ ProductSelfMinus() [2/2]

bool Pds::Matrix::ProductSelfMinus	(	const Pds::Matrix &	B,
		double	b
	)

[Elemento a elemento] Multiplica con sigo mismo (A), elemento a elemento, una matriz (B-b) y el resultado es cargado en A.

$A \leftarrow A\& (B-b)$

Pds::Matrix A(4,4);
Pds::Matrix B(4,4);
 
A.Fill(2.0);
B.Fill(1.0);
 
A.ProductSelfMinus(B,1);
 
std::cout<<A;

Parámetros

[in]	B	La matriz a multiplicar.
[in]	b	La variable a multiplicar.

Devuelve: true si todo fue bien o false en caso de error.

◆ ProductSelfPlus()

bool Pds::Matrix::ProductSelfPlus	(	double	b,
		const Pds::Matrix &	B
	)

[Elemento a elemento] Multiplica con sigo mismo (A), elemento a elemento, una matriz (b+B) y el resultado es cargado en A.

$A \leftarrow A\& (b+B)$

Pds::Matrix A(4,4);
Pds::Matrix B(4,4);
 
A.Fill(2.0);
B.Fill(1.0);
 
A.ProductSelfMinus(1,B);
 
std::cout<<A;

Parámetros

[in]	b	La variable a multiplicar.
[in]	B	La matriz a multiplicar.

Devuelve: true si todo fue bien o false en caso de error.

◆ Pow() [1/2]

Pds::Matrix Pds::Matrix::Pow ( const Pds::Matrix & B ) const

[Elemento a elemento]Potencia asi mismo (A), elemento a elemento, con una matriz B y el resultado es cargado en C. Este método es similar al operador

$C \leftarrow A^B$

Pds::Matrix A(4,4);
Pds::Matrix B(4,4);
Pds::Matrix C;
 
A.Fill(2.0);
B.Fill(1.0);
 
C=A.Pow(B);
 
std::cout<<C;

Parámetros

[in] B La matriz a exponenciar

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ Pow() [2/2]

Pds::Matrix Pds::Matrix::Pow ( double val ) const

[Elemento a elemento] Potencia asi mismo (A), elemento a elemento, con un valor val y el resultado es cargado en C. Este método es similar al operador

$C \leftarrow A^{val}$

Pds::Matrix A(4,4);
Pds::Matrix val=2;
Pds::Matrix C;
 
A.Fill(2.0);
 
C=A.Pow(val);
 
std::cout<<C;

Parámetros

[in] val Valor a exponenciar

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ Geq() [1/2]

Pds::Matrix Pds::Matrix::Geq ( double b ) const

[Elemento a elemento] Calcula con sigo mismo (A), si (A) es mayor que un valor b y el resultado es cargado en C. Este método es similar al operador >=

$C \leftarrow A>=b$

Pds::Matrix A(4,4);
Pds::Matrix C;
 
A.FillId();
 
C=A.Geq(4);
 
std::cout<<C;

Parámetros

[in] b el valor a comparar

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ Geq() [2/2]

Pds::Matrix Pds::Matrix::Geq ( Pds::Matrix B ) const

[Elemento a elemento] Calcula con sigo mismo (A), si (A) es mayor que un valor (B) y el resultado es cargado en C. Este método es similar al operador >=

$C \leftarrow A>=B$

Pds::Matrix A(4,4);
Pds::Matrix C;
 
A.FillId();
 
C=A.Geq(B);
 
std::cout<<C;

Parámetros

[in] B Matriz a comparar

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ Leq() [1/2]

Pds::Matrix Pds::Matrix::Leq ( double b ) const

[Elemento a elemento] Calcula con sigo mismo (A), si (A) es menor que un valor b y el resultado es cargado en C. Este método es similar al operador <=

$C \leftarrow A<=b$

Pds::Matrix A(4,4);
Pds::Matrix C;
 
A.FillId();
 
C=A.Leq(4);
 
std::cout<<C;

Parámetros

[in] b el valor a comparar

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ Leq() [2/2]

Pds::Matrix Pds::Matrix::Leq ( const Pds::Matrix & B ) const

[Elemento a elemento] Calcula con sigo mismo (A), si (A) es menor que un valor B y el resultado es cargado en C. Este método es similar al operador <=

$C \leftarrow A<=B$

Pds::Matrix A(4,4);
Pds::Matrix C;
 
A.FillId();
 
C=A.Leq(B);
 
std::cout<<C;

Parámetros

[in] B Matriz a comparar

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ EqualTo() [1/2]

Pds::Matrix Pds::Matrix::EqualTo ( double b ) const

[Elemento a elemento] Calcula con sigo mismo (A), si (A) es identico a un valor b y el resultado es cargado en C. Este método es similar al operador ==

$C \leftarrow A==b$

Pds::Matrix A(4,4);
Pds::Matrix C;
 
A.FillId();
 
C=A.EqualTo(4);
 
std::cout<<C;

Parámetros

[in] b el valor a comparar

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ EqualTo() [2/2]

Pds::Matrix Pds::Matrix::EqualTo ( const Pds::Matrix & B ) const

[Elemento a elemento] Calcula con sigo mismo (A), si (A) es identico a un valor B y el resultado es cargado en C. Este método es similar al operador ==

$C \leftarrow A==B$

Pds::Matrix A(4,4);
Pds::Matrix C;
 
A.FillId();
 
C=A.EqualTo(B);
 
std::cout<<C;

Parámetros

[in] B Matriz a comparar

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ NotEqualTo() [1/2]

Pds::Matrix Pds::Matrix::NotEqualTo ( double b ) const

[Elemento a elemento] Calcula con sigo mismo (A), si (A) no es identico a un valor b y el resultado es cargado en C. Este método es similar al operador !=

$C \leftarrow A!=b$

Pds::Matrix A(4,4);
Pds::Matrix C;
 
A.FillId();
 
C=A.NotEqualTo(4);
 
std::cout<<C;

Parámetros

[in] b el valor a comparar

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ NotEqualTo() [2/2]

Pds::Matrix Pds::Matrix::NotEqualTo ( const Pds::Matrix & B ) const

[Elemento a elemento] Calcula con sigo mismo (A), si (A) no es identico a un valor B y el resultado es cargado en C. Este método es similar al operador !=

$C \leftarrow A!=B$

Pds::Matrix A(4,4);
Pds::Matrix C;
 
A.FillId();
 
C=A.NotEqualTo(B);
 
std::cout<<C;

Parámetros

[in] B Matriz a comparar

Devuelve: Retorna C con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

◆ EqualToInf()

Pds::Matrix Pds::Matrix::EqualToInf ( void ) const

Verifica si la matriz tiene elementos con valores infinitos.

Los valores infinitos pueden producirse con $+\frac{1}{0},-\frac{1}{0} y \frac{1}{0}$ .

$\left(\begin{matrix} 0 & 0 & \cdots & 0\\ 0 & 0 & \cdots & 1\\ \vdots & \vdots & \vdots & \vdots \\ 1 & 0 & \cdots & 0\\ 0 & 1 & \cdots & 0\\ \end{matrix}\right) \overleftarrow{EqualToInf} \left(\begin{matrix} 1 & NaN & \cdots & NaN\\ 0 & 2 & \cdots & -\infty\\ \vdots & \vdots & \vdots & \vdots \\ \infty & 0 & \cdots & 0\\ 3 & -\infty & \cdots & NaN\\ \end{matrix}\right)$

Devuelve: Retorna una nueva matriz con 1 donde es infinito y 0 donde no lo es.

◆ EqualToNan()

Pds::Matrix Pds::Matrix::EqualToNan ( void ) const

Verifica si la matriz tiene elementos con valores NAN (Not A Number).

Los valores NAN pueden producirse con $\frac{0}{0}$ .

$\left(\begin{matrix} 0 & 1 & \cdots & 1\\ 0 & 0 & \cdots & 0\\ \vdots & \vdots & \vdots & \vdots \\ 0 & 0 & \cdots & 0\\ 0 & 0 & \cdots & 1\\ \end{matrix}\right) \overleftarrow{EqualToNan} \left(\begin{matrix} 1 & NaN & \cdots & NaN\\ 0 & 2 & \cdots & -\infty\\ \vdots & \vdots & \vdots & \vdots \\ \infty & 0 & \cdots & 0\\ 3 & -\infty & \cdots & NaN\\ \end{matrix}\right)$

Devuelve: Retorna una nueva matriz con 1 donde es NAN y 0 donde no lo es.

◆ EqualToFinite()

Pds::Matrix Pds::Matrix::EqualToFinite ( void ) const

Verifica si la matriz tiene elementos con valores finitos (no +inf, no -inf y no NAN).

$\left(\begin{matrix} 1 & 0 & \cdots & 0\\ 1 & 1 & \cdots & 0\\ \vdots & \vdots & \vdots & \vdots \\ 0 & 1 & \cdots & 1\\ 1 & 0 & \cdots & 0\\ \end{matrix}\right) \overleftarrow{EqualToFinite} \left(\begin{matrix} 1 & NaN & \cdots & NaN\\ 0 & 2 & \cdots & -\infty\\ \vdots & \vdots & \vdots & \vdots \\ \infty & 0 & \cdots & 0\\ 3 & -\infty & \cdots & NaN\\ \end{matrix}\right)$

Devuelve: Retorna una nueva matriz con 1 donde es finito y 0 donde no lo es.

◆ operator-=() [1/2]

Pds::Matrix& Pds::Matrix::operator-= ( double b )

Resta y acumula en si mismo (A), un valor b. Este operador es similar al método SubAssig()

$A \leftarrow A-b$

Pds::Matrix A(4,4);
double b=1.2;
B.Fill(1.0);
A-=b;

Parámetros

[in] b El valor a substraer

Devuelve: Retorna el operador de la izquierda (acumulador) con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

Ver también: SubAssig

◆ operator-=() [2/2]

Pds::Matrix& Pds::Matrix::operator-= ( const Pds::Matrix & B )

Resta y acumula en si mismo (A), una matriz B. Este operador es similar al método SubAssig()

$A \leftarrow A-B$

Pds::Matrix A(4,4);
Pds::Matrix B(4,4);
B.Fill(1.0);
A-=B;

Parámetros

[in] B la matriz a substraer

Devuelve: Retorna el operador de la izquierda (acumulador) con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

Ver también: SubAssig

◆ SubAssig() [1/2]

bool Pds::Matrix::SubAssig ( double b )

Resta y acumula en si mismo (A), un valor b. Este es similar al operador -=.

$A \leftarrow A-b$

Pds::Matrix A(4,4);
double b=1.2;
A.SubAssig(b);

Parámetros

[in] b valor a substraer

Devuelve: Retorna true si todo fue bien o false si no. Si se retorna false el acumulador no altera su contenido.

◆ SubAssig() [2/2]

bool Pds::Matrix::SubAssig ( const Pds::Matrix & B )

Resta y acumula en si mismo (A), una matriz B. Este es similar al operador -=.

$A \leftarrow A-B$

Pds::Matrix A(4,4);
Pds::Matrix B(4,4);
B.Fill(1.0);
A.SubAssig(B);

Parámetros

[in] B la matriz que substrae

Devuelve: Retorna true si todo fue bien o false si no. Si se retorna false el acumulador no altera su contenido.

◆ operator+=() [1/2]

Pds::Matrix& Pds::Matrix::operator+= ( double b )

Suma y acumula en si mismo (A), un valor b. Este operador es similar al método AddAssig()

$A \leftarrow A+b$

Pds::Matrix A(4,4);
double b=1.2;
A+=b;

Parámetros

[in] b El valor a acumular

Devuelve: Retorna el operador de la izquierda (acumulador) con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

Ver también: AddAssig

◆ operator+=() [2/2]

Pds::Matrix& Pds::Matrix::operator+= ( const Pds::Matrix & B )

Suma y acumula en si mismo (A), una matriz B. Este operador es similar al método AddAssig()

$A \leftarrow A+B$

Pds::Matrix A(4,4);
Pds::Matrix B(4,4);
B.Fill(1.0);
A+=B;

Parámetros

[in] B la matriz a acumular

Devuelve: Retorna el operador de la izquierda (acumulador) con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

Ver también: AddAssig

◆ AddAssig() [1/4]

bool Pds::Matrix::AddAssig ( double b )

Suma y acumula en si mismo (A), un valor b. Este es similar al perador +=.

$A \leftarrow A+b$

Pds::Matrix A(4,4);

A.AddAssig(1.2);

Parámetros

[in] b Valor a acumular

Devuelve: Retorna true si todo fue bien o false si no. Si se retorna false el acumulador no altera su contenido.

◆ AddAssig() [2/4]

bool Pds::Matrix::AddAssig ( const Pds::Matrix & B )

Suma y acumula en si mismo (A), una matriz B. Este es similar al perador +=.

$A \leftarrow A+B$

Pds::Matrix A(4,4);
Pds::Matrix B(4,4);
B.Fill(1.0);
A.AddAssig(B);

Parámetros

[in] B la matriz a acumular

Devuelve: Retorna true si todo fue bien o false si no. Si se retorna false el acumulador no altera su contenido.

◆ AddAssig() [3/4]

bool Pds::Matrix::AddAssig	(	double	alpha,
		const Pds::Matrix &	B
	)

Suma y acumula en si mismo (A), una matriz B.

$A \leftarrow A+\alpha B$

Pds::Matrix A(4,4);
double alpha=1.2;
Pds::Matrix B(4,4);
B.Fill(1.0);
A.AddAssig(alpha,B);

Parámetros

[in]	alpha	Factor a acumular
[in]	B	la matriz a acumular

Devuelve: Retorna true si todo fue bien o false si no. Si se retorna false el acumulador no altera su contenido.

◆ AddAssig() [4/4]

bool Pds::Matrix::AddAssig	(	double	alpha,
		const Pds::Matrix &	B,
		double	beta,
		const Pds::Matrix &	C
	)

Suma y acumula en si mismo (A), una matriz B.

$A \leftarrow A+\alpha B+\beta C$

Pds::Matrix A(4,4);
double alpha=1.2;
Pds::Matrix B(4,4);
double beta=0.2;
Pds::Matrix C(4,4);
B.Fill(+1.0);   C.Fill(-1.0);
A.AddAssig(alpha,B,beta,C);

Parámetros

[in]	alpha	Factor a acumular
[in]	B	la matriz a acumular
[in]	beta	Factor a acumular
[in]	C	la matriz a acumular

Devuelve: Retorna true si todo fue bien o false si no. Si se retorna false el acumulador no altera su contenido.

◆ AddAssigAt()

bool Pds::Matrix::AddAssigAt	(	unsigned int	lin,
		unsigned int	col,
		const Pds::Matrix &	B
	)

Suma y acumula en si mismo (A), una matriz B desde un punto (lin,col) haciendo una intersección.

$A(lin:end,col:end) \leftarrow A(lin:end,col:end)+B(0:lin_end,0:col_end)$

Pds::Matrix A(4,4);
Pds::Matrix B(3,3);
B.Fill(1.0);
A.AddAssigAt(2,2,B);

Parámetros

[in]	lin	Suma desde esta linea
[in]	col	Suma desde esta columna
[in]	B	la matriz a acumular

Devuelve: Retorna true si todo fue bien o false si no. Si se retorna false el acumulador no altera su contenido. Retorna false si la intersección no existe o si alguna de las matrices son nulas.

Ejemplos: example_matrix_assignment.cpp.

◆ operator*=() [1/2]

Pds::Matrix& Pds::Matrix::operator*= ( double b )

Multiplica y acumula en si mismo (A), un valor b. Este operador es similar al método MulAssig()

$A \leftarrow A*b$

Pds::Matrix A(4,4);
double b=1.2;
A*=b;

Parámetros

[in] b El valor a acumular

Devuelve: Retorna el operador de la izquierda (acumulador) con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

Ver también: AddAssig

◆ operator*=() [2/2]

Pds::Matrix& Pds::Matrix::operator*= ( const Pds::Matrix & B )

Multiplica y acumula en si mismo (A), una matriz B. Este operador es similar al método MulAssig()

$A \leftarrow A*B$

Pds::Matrix A(4,4);
Pds::Matrix B(4,4);
A*=B;

Parámetros

[in] B El valor a acumular

Devuelve: Retorna el operador de la izquierda (acumulador) con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

Ver también: AddAssig

◆ MulAssig() [1/2]

bool Pds::Matrix::MulAssig ( double b )

Multiplica y acumula en si mismo (A), un valor b. Este es similar al operador *=.

$A \leftarrow A*b$

Pds::Matrix A(4,4);

A.MulAssig(1.2);

Parámetros

[in] b Valor a acumular

Devuelve: Retorna true si todo fue bien o false si no. Si se retorna false el acumulador no altera su contenido.

◆ MulAssig() [2/2]

bool Pds::Matrix::MulAssig ( const Pds::Matrix & B )

Multiplica y acumula en si mismo (A), una matriz B. Este es similar al operador *=.

$A \leftarrow A*B$

Pds::Matrix A(4,4);
Pds::Matrix B(4,4);
A.MulAssig(B);

Parámetros

[in] B Valor a acumular

Devuelve: Retorna true si todo fue bien o false si no. Si se retorna false el acumulador no altera su contenido.

◆ operator=() [1/3]

Pds::Matrix& Pds::Matrix::operator= ( const Pds::Matrix & B )

Copia en si mismo (A), una matriz B. Este operador es similar al método Copy(). No importa el tamaño de A, sus datos son liberados y un nuevo arreglo de datos es reservado.

$A \leftarrow B$

Cuando acontece:

Pds::Matrix B(nlin,ncol);

A=B;

Pds::Matrix::nlin

unsigned int nlin

Definition: Matrix.hpp:91

Pds::Matrix::ncol

unsigned int ncol

Definition: Matrix.hpp:93

Cuando NO acontece:

Pds::Matrix A=Pds::Matrix(nlin,ncol);

Parámetros

[in] B la matriz a copiar

Devuelve: Retorna el operador de la izquierda (acumulador) con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

Ver también: Copy

◆ Copy() [1/3]

bool Pds::Matrix::Copy ( const Pds::Matrix & B )

Copia en si mismo (A), el contenido de una matriz B. Este método es similar a usar el operador = . No importa el tamaño de A, sus datos son liberados y un nuevo arreglo de datos es reservado.

$A \leftarrow B$

Parámetros

[in] B la matriz a copiar

Devuelve: Retorna true si todo fue bien o false si no. Si se retorna false el receptor no altera su contenido.

Ver también: Copy

◆ operator=() [2/3]

Pds::Matrix& Pds::Matrix::operator= ( double val )

Copia en si mismo (A), el valor val. Este operador es similar al método Copy(). No importa el tamaño de A, sus datos son liberados y un nuevo arreglo de datos de 1x1 es reservado.

$A \leftarrow val$

Cuando acontece:

Pds::Matrix B(nlin,ncol);

A=val;

Cuando NO acontece:

Pds::Matrix A=Pds::Matrix(nlin,ncol);

Parámetros

[in] val El valor a copiar

Devuelve: Retorna el operador de la izquierda (acumulador) con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

Ver también: Copy

◆ Copy() [2/3]

bool Pds::Matrix::Copy ( double val )

Copia en si mismo (A), el valor val. Este método es similar a usar el operador = . No importa el tamaño de A, sus datos son liberados y un nuevo arreglo de datos de 1x1 es reservado.

$A \leftarrow val$

Parámetros

[in] val El valor a copiar

Devuelve: Retorna true si todo fue bien o false si no. Si se retorna false el receptor no altera su contenido.

Ver también: Copy

◆ operator=() [3/3]

template<class Datum >

Pds::Matrix& Pds::Matrix::operator= ( const Pds::Array< Datum > & B )

Copia en si mismo (A), una array B. Este operador es similar al método Copy(). No importa el tamaño de A, sus datos son liberados y un nuevo arreglo de datos es reservado.

$A \leftarrow B$

Cuando acontece:

Pds::Matrix A;
Pds::Array<double> B(nlin,ncol);
A=B;

Parámetros

[in] B El array a copiar

Devuelve: Retorna el operador de la izquierda (acumulador) con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

Ver también: Copy

◆ Copy() [3/3]

template<class Datum >

bool Pds::Matrix::Copy ( const Pds::Array< Datum > & B )

Copia en si mismo (A), el contenido de una Array B. Este método es similar a usar el operador = . No importa el tamaño de A, sus datos son liberados y un nuevo arreglo de datos es reservado.

$A \leftarrow B$

Parámetros

[in] B la matriz a copiar

Devuelve: Retorna true si todo fue bien o false si no. Si se retorna false el receptor no altera su contenido.

◆ MultipleMse() [1/2]

Pds::Matrix Pds::Matrix::MultipleMse ( const Pds::Matrix & B ) const

Calcula el error quadrático medio de cada linea de A con cada linea de B.

$C=A.MultipleMse(B) \equiv [c_{ij}]$

El elemento $c_{ij}$ indica el error quadrático medio de la linea de con la linea de .

$c_{ij}=\frac{1}{Ncol} \sum \limits_{k}^{Ncol} {|a_{ik}-b_{jk}|}^2$

Parámetros

[in] B Matriz a comparar.

Devuelve: Retorna una matriz $C\equiv [c_{ij}]$ con los valores de error cuadrático medio de cada linea de A con cada linea de B. En caso de que la matriz sea vacía se retorna una matriz vazia

Ejemplos: example_matrix_algebra.cpp.

◆ MultipleMse() [2/2]

Pds::Matrix Pds::Matrix::MultipleMse ( const std::vector< Pds::Matrix > & Block ) const

Calcula el error quadrático medio de cada linea de A con cada muestra en el bloque Block.

$C=A.MultipleMse(Block) \equiv [c_{ij}]$

El elemento $c_{ij}$ indica el error quadrático medio de la linea de con la muestra de .

$c_{ij}=\frac{1}{N} \sum \limits_{n}^{N} {|a_{in}-block[n]_{j}|}^2$

La matriz A debe tener N columnas y el bloque Block debe estar compuesto de N matrices.

Parámetros

[in] Block Bloque de N matrices a comparar.

Devuelve: Retorna una matriz $C\equiv [c_{ij}]$ con los valores de error cuadrático medio de cada linea de A con cada muestra en el bloque Block. En caso de que la matriz sea vacía se retorna una matriz vazia

◆ IdInMultipleMse() [1/2]

Pds::Array<unsigned int> Pds::Matrix::IdInMultipleMse ( const Pds::Matrix & B ) const

Calcula que linea de A es mas cercana a cada linea de B.

$C=A.IdInMultipleMse(B) \equiv [c_{ij}]$

El elemento $c_{i}$ constiene la linea A que esta mas cercana a la linea de . La lineas son comparadas usando distancia euclidiana.

Parámetros

[in] B Matriz a comparar.

Devuelve: Retorna una matriz $C\equiv [c_{i}]$ con los valores de las lineas de A mas cercanas a cada linea de B. En caso de que la matriz sea vacía se retorna una matriz vazia

◆ IdInMultipleMse() [2/2]

Pds::Array<unsigned int> Pds::Matrix::IdInMultipleMse ( const std::vector< Pds::Matrix > & Block ) const

Calcula que linea de A es mas cercana a cada muestra de Block.

$C=A.IdInMultipleMse(Block) \equiv [c_{ij}]$

El elemento $c_{i}$ constiene la linea A que esta mas cercana a la muestra de . La lineas son comparadas usando distancia euclidiana.

Parámetros

[in] Block Bloque de N matrices a comparar.

Devuelve: Retorna una matriz $C\equiv [c_{i}]$ con los valores de las lineas de A mas cercanas a cada muestra de Block. En caso de que la matriz sea vacía se retorna una matriz vazia

◆ ArrayAllocate() [1/7]

static double** Pds::Matrix::ArrayAllocate	(	double(*)(double)	func,
		const Pds::Matrix &	A
	)

static

crea dinámicamente un arreglo de A.Nlin() lineas y A.Ncol() columnas, con los datos copiados de aplicar func(A).

Parámetros

[in]	func	Función a aplicar, esta debe tener a forma double func(double).
[in]	A	Matriz de donde se copiaran datos.

Devuelve: Retorna un puntero al arreglo, o NULL si no consiguió reservar la memoria. Esta memoria debe ser liberada siempre com ArrayRelease

◆ ArrayAllocate() [2/7]

static double** Pds::Matrix::ArrayAllocate	(	double(*)(double, double)	func,
		const Pds::Matrix &	A,
		double	var
	)

static

crea dinámicamente un arreglo de A.Nlin() lineas y A.Ncol() columnas, con los datos copiados de aplicar func(A,var).

Parámetros

[in]	func	Función a aplicar, esta debe tener a forma double func(double).
[in]	A	Matriz de donde se copiaran datos.
[in]	var	Variable a evaluar.

Devuelve: Retorna un puntero al arreglo, o NULL si no consiguió reservar la memoria. Esta memoria debe ser liberada siempre com ArrayRelease

◆ ArrayAllocate() [3/7]

static double** Pds::Matrix::ArrayAllocate	(	double(*)(double, double)	func,
		const Pds::Matrix &	A,
		const Pds::Matrix &	B
	)

static

crea dinámicamente un arreglo de A.Nlin() lineas y A.Ncol() columnas, con los datos copiados de aplicar func(A,B). Los tamaño de A y B son similares.

Parámetros

[in]	func	Función a aplicar, esta debe tener a forma double func(double,double).
[in]	A	Matriz de donde se copiaran datos.
[in]	B	Matriz de donde se copiaran datos.

Devuelve: Retorna un puntero al arreglo, o NULL si no consiguió reservar la memoria. Esta memoria debe ser liberada siempre com ArrayRelease

◆ ArrayAllocate() [4/7]

static double** Pds::Matrix::ArrayAllocate	(	double(*)(double, double, double)	func,
		const Pds::Matrix &	A,
		const Pds::Matrix &	B,
		double	var
	)

static

crea dinámicamente un arreglo de A.Nlin() lineas y A.Ncol() columnas, con los datos copiados de aplicar func(A,B,var). Los tamaño de A y B son similares.

Parámetros

[in]	func	Función a aplicar, esta debe tener a forma double func(double,double,double).
[in]	A	Matriz de donde se copiaran datos.
[in]	B	Matriz de donde se copiaran datos.
[in]	var	Tercer valor a evaluar.

Devuelve: Retorna un puntero al arreglo, o NULL si no consiguió reservar la memoria. Esta memoria debe ser liberada siempre com ArrayRelease

◆ ArrayAllocate() [5/7]

static double** Pds::Matrix::ArrayAllocate	(	double(*)(double, double, double)	func,
		const Pds::Matrix &	A,
		const Pds::Matrix &	B,
		const Pds::Matrix &	C
	)

static

crea dinámicamente un arreglo de A.Nlin() lineas y A.Ncol() columnas, con los datos copiados de aplicar func(A,B,C). Los tamaño de A, B y C son similares.

Parámetros

[in]	func	Función a aplicar, esta debe tener a forma double func(double,double,double).
[in]	A	Matriz de donde se copiaran datos.
[in]	B	Matriz de donde se copiaran datos.
[in]	C	Matriz de donde se copiaran datos.

Devuelve: Retorna un puntero al arreglo, o NULL si no consiguió reservar la memoria. Esta memoria debe ser liberada siempre com ArrayRelease

◆ ArrayAllocate() [6/7]

static double** Pds::Matrix::ArrayAllocate	(	double(*)(double, double, double, double)	func,
		const Pds::Matrix &	A,
		const Pds::Matrix &	B,
		const Pds::Matrix &	C,
		double	var
	)

static

crea dinámicamente un arreglo de A.Nlin() lineas y A.Ncol() columnas, con los datos copiados de aplicar func(A,B,C,var). Los tamaño de A, B y C son similares.

Parámetros

[in]	func	Función a aplicar, esta debe tener a forma double func(double,double,double,double).
[in]	A	Matriz de donde se copiaran datos.
[in]	B	Matriz de donde se copiaran datos.
[in]	C	Matriz de donde se copiaran datos.
[in]	var	Cuarto valor a evaluar.

Devuelve: Retorna un puntero al arreglo, o NULL si no consiguió reservar la memoria. Esta memoria debe ser liberada siempre com ArrayRelease

◆ ArrayAllocate() [7/7]

static double** Pds::Matrix::ArrayAllocate	(	double(*)(double, double, double, double)	func,
		const Pds::Matrix &	A,
		const Pds::Matrix &	B,
		const Pds::Matrix &	C,
		const Pds::Matrix &	D
	)

static

crea dinámicamente un arreglo de A.Nlin() lineas y A.Ncol() columnas, con los datos copiados de aplicar func(A,B,C,D). Los tamaño de A, B, C y D son similares.

Parámetros

[in]	func	Función a aplicar, esta debe tener a forma double func(double,double,double,double).
[in]	A	Matriz de donde se copiaran datos.
[in]	B	Matriz de donde se copiaran datos.
[in]	C	Matriz de donde se copiaran datos.
[in]	D	Matriz de donde se copiaran datos.

Devuelve: Retorna un puntero al arreglo, o NULL si no consiguió reservar la memoria. Esta memoria debe ser liberada siempre com ArrayRelease

◆ operator<<()

std::ostream& operator<<	(	std::ostream &	out,
		const Pds::Matrix &	mat
	)

Retorna el contenido de la matriz por la salida estándar.

std::cout<<mat;

es equivalente a :

std::cout<<mat.ToString();

Parámetros

[in]	out	La salida
[in]	mat	La matriz a mostrar

Devuelve: Retorna la misma salida estándar out.

Ver también: Pds::Matrix::ToString();

◆ operator+() [4/4]

Pds::Matrix operator+	(	double	b,
		const Pds::Matrix &	A
	)

Suma b con (A), el resultado es cargado en C. Este operador es similar al método Add()

$C \leftarrow b+A$

Pds::Matrix A(4,4);
Pds::Matrix C;
 
A.Fill(2.0);
 
C=2.0+A;
 
std::cout<<C;

Parámetros

[in]	b	El valor a sumar
[in]	A	matriz a sumar

Devuelve: Retorna un nuevo objeto con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

Ver también: Add

◆ operator-() [4/4]

Pds::Matrix operator-	(	double	b,
		const Pds::Matrix &	A
	)

Resta b con (A), el resultado es cargado en C. Este operador es similar al método Add()

$C \leftarrow b-A$

Pds::Matrix A(4,4);
Pds::Matrix C;
 
A.Fill(2.0);
 
C=2.0-A;
 
std::cout<<C;

Parámetros

[in]	b	El valor a operar
[in]	A	matriz a restar

Devuelve: Retorna un nuevo objeto con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

Ver también: Sub

◆ operator*() [3/3]

Pds::Matrix operator*	(	double	b,
		const Pds::Matrix &	A
	)

Multiplica b con (A), el resultado es cargado en C. Este operador es similar al método Mul()

$C \leftarrow b*A$

Pds::Matrix A(4,4);
Pds::Matrix C;
 
A.Fill(2.0);
 
C=2.0*A;
 
std::cout<<C;

Parámetros

[in]	b	El valor a operar
[in]	A	matriz a multiplicar

Devuelve: Retorna un nuevo objeto con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

Ver también: Mul

◆ operator/() [3/3]

Pds::Matrix operator/	(	double	b,
		const Pds::Matrix &	A
	)

Divide b con (A), elemento a elemento y el resultado es cargado en C. Este operador es similar al método DivSelf()

$C \leftarrow b/A$

Pds::Matrix A(4,4);
Pds::Matrix C;
 
A.Fill(2.0);
 
C=2.0/A;
 
std::cout<<C;

Parámetros

[in]	b	El valor a operar
[in]	A	matriz a dividir

Devuelve: Retorna un nuevo objeto con el resultado, o una matriz vacía (this->IsEmpty() igual a true) en caso de error.

Ver también: Mul

◆ ~Matrix()

Pds::Matrix::~Matrix ( )

◆ FusionVer()

bool Pds::Matrix::FusionVer ( std::list< Pds::Matrix > & list )

Concatena verticalmente varias matrices.
Si las matrices no tienen el mismo número de columnas se considera um error. Destruye las matrices en list. Este metodo es mas rapido que Pds::MergeVer(list) pues transplanta memoria.

Parámetros

[in] list La lista de matrices a concatenar.

Devuelve: Retorna true en caso de enxito en la matriz concatenada o false y una matriz vacía en caso de error.

Namespaces

Estructuras de datos

Constructores

Métodos de estado

Métodos de inicialización

Métodos de tamaño

Métodos get y set de elementos

Métodos get y set de matrices y vectores

Métodos de opreaciones sobre las lineas de la matriz

Métodos estadísticos

Métodos Information theory

Métodos Digital Signal Processing

Métodos de álgebra lineal

Métodos para find

Métodos para aplicar operaciones

Métodos para operar Pds::Matrix

Métodos con regiones con Pds::Matrix.

Métodos variados con Pds::Matrix.

Métodos para reordenar memoria con Pds::Matrix.

Métodos para exportar e importar datos con Pds::Matrix.

Métodos Static con Matrices con Pds::Matrix.

Operadores unarios y sus métodos equivalentes con Pds::Matrix.

Operadores binarios y sus métodos equivalentes con Pds::Matrix.

Operadores binarios acumuladores y sus métodos equivalentes con Pds::Matrix.

Métodos exoticos con Pds::Matrix

Métodos Static con arrays

Operadores no miembros

Descripción detallada

Documentación de las funciones

◆ Matrix() [1/17]

◆ Matrix() [2/17]

◆ Matrix() [3/17]

◆ Matrix() [4/17]

◆ Matrix() [5/17]

◆ Matrix() [6/17]

◆ Matrix() [7/17]

◆ Matrix() [8/17]

◆ Matrix() [9/17]

◆ Matrix() [10/17]

◆ Matrix() [11/17]

◆ Matrix() [12/17]

◆ Matrix() [13/17]

◆ Matrix() [14/17]

◆ Matrix() [15/17]

◆ Matrix() [16/17]

◆ Matrix() [17/17]

◆ IsEmpty()

◆ IsNotEmpty()

◆ IsSimilarTo()

◆ IsNotSimilarTo()

◆ IsMulBy()

◆ IsNotMulBy()

◆ IsInRange()

◆ IsNotInRange()

◆ IsInSizeRange()

◆ IsRowMatrix()

◆ IsColMatrix()

◆ IsZero()

◆ IsLeq() [1/2]

◆ IsLeq() [2/2]

◆ IsGeq() [1/2]

◆ IsGeq() [2/2]

◆ IsEqualTo() [1/2]

◆ IsEqualTo() [2/2]

◆ HasInf()

◆ HasNan()

◆ HasNotFinite()

◆ FillRandC()

◆ FillRandN() [1/2]

◆ FillRandN() [2/2]

◆ FillRandU() [1/3]

◆ FillRandU() [2/3]

◆ FillRandU() [3/3]

◆ FillId()

◆ Fill()

◆ FillLinSpace()

◆ Nlin()

◆ Ncol()

◆ Nel()

◆ Size()