Home | Develop | Download | Contact
Namespaces | Estructuras de datos
Clase Pds::Vector
Matrices y vectores

Clase que implementa un vector columna de valores reales. Más...

Namespaces

namespace  Pds
 Nombre de espacio para Pds (Procesamiento Digital de Senales)
 

Estructuras de datos

class  Pds::Vector
 La clase tipo Pds::Vector . Esta clase genera una matriz de Nlin lineas y 1 columna. Para usar incluir Pds/Vector. Más...
 

Varios tipos de constructores

Crean una objeto Pds::Vector

 Pds::Vector::Vector (void)
 Crea un objeto de tipo Pds::Vector. Más...
 
 Pds::Vector::Vector (unsigned int N)
 Crea un objeto de tipo Pds::Vector. Más...
 
 Pds::Vector::Vector (const Pds::Size &S)
 Crea un objeto de tipo Pds::Vector con elementos inicializados con cero. Más...
 
 Pds::Vector::Vector (const Pds::Matrix &B)
 Crea un objeto de tipo Pds::Vector copiando datos desde una matriz. Toda la matriz es vectorizada leyendo columna a columna. Más...
 
template<class Datum >
 Pds::Vector::Vector (const Pds::Array< Datum > &B)
 Crea un objeto de tipo Pds::Vector copiando datos desde un arreglo. Más...
 
 Pds::Vector::Vector (const char *str)
 Crea un objeto de tipo Pds::Vector copiando datos desde una cadena. Más...
 
 Pds::Vector::Vector (const std::initializer_list< double > list)
 Crea un objeto de tipo Pds::Vector copiando datos desde una lista. Más...
 
 Pds::Vector::Vector (const std::vector< double > &vec)
 Crea un objeto de tipo Pds::Vector copiando datos desde una std::vector. Más...
 
 Pds::Vector::Vector (const std::vector< int > &vec)
 Crea un objeto de tipo Pds::Vector copiando datos desde una std::vector. Más...
 
 Pds::Vector::Vector (const std::vector< bool > &vec)
 Crea un objeto de tipo Pds::Vector copiando datos desde una std::vector. Más...
 
 Pds::Vector::Vector (unsigned int N, double val)
 Crea un objeto de tipo Pds::Vector. Más...
 
 Pds::Vector::Vector (const Pds::Matrix &B, unsigned int col)
 Crea un objeto de tipo Pds::Vector copiando datos desde una columna de una matriz. Más...
 
 Pds::Vector::Vector (double(*func)(double), const Pds::Vector &B)
 Crea un objeto de tipo Pds::Vector, evaluando mediante una función, los datos de otro vector. Más...
 
 Pds::Vector::Vector (double(*func)(double), const Pds::Matrix &B)
 Crea un objeto de tipo Pds::Vector, evaluando mediante una función, los datos de una matriz vectorizada. Más...
 
 Pds::Vector::Vector (Pds::Ra::FormatType Type, std::string filepath)
 Crea un objeto de tipo Pds::Vector copiando datos desde un archivo. Más...
 
 Pds::Vector::~Vector ()
 

Operadores binarios.

Pds::Vector Pds::Vector::Conv (const Pds::Vector &B, Pds::Ra::Padding Padding=Pds::Ra::Full) const
 Calcula la convolución entre A y B. Más...
 
static Pds::Size Pds::Vector::Conv1DOutputSize (unsigned int Anlin, unsigned int Bnlin, unsigned int Stride, Pds::Ra::Padding Padding)
 Calcula el tamaño de la matriz resultado de la convolucion de A y B. Más...
 
Pds::Vector Pds::Vector::Conv1D (const Pds::Vector &B, unsigned int Stride=1, Pds::Ra::Padding Padding=Pds::Ra::Full) const
 Calcula la convolución entre A y B. Más...
 
Pds::Vector Pds::Vector::XCorr (const Pds::Vector &B, bool Same=false) const
 Calcula la correlacion cruzada entre A y B. Más...
 
Pds::Matrix Pds::Vector::MulTComp (double b, const Pds::Vector &B) const
 Multiplica con sigo mismo (A), la transpuesta de un vector [b;B] y el resultado es cargado en C.
Más...
 

Métodos Static con Vectores VectorBlock.

Herramientas genéricas que pueden ser usadas desde Pds::Vector

static bool Pds::Vector::IsVectorBlock (const std::vector< Pds::Vector > &Block)
 Verifica que el bloque (std::vector<Pds::Vector>) sea un vector no vacío de matrices no nulas y similares. Es decir un Hiperrectángulo. Más...
 
static Pds::Vector Pds::Vector::FlattenVectorBlock (const std::vector< Pds::Vector > &Block)
 Convierte a Pds::Vector un VectorBlock. Más...
 
static std::vector< Pds::Vector > Pds::Vector::RandNVectorBlock (unsigned int N, unsigned int Sz)
 Crea un bloque (std::vector<Pds::Vector>) con matrices no nulas y similares inicializadas con Pds::RandN(). Más...
 
static std::vector< Pds::Vector > Pds::Vector::MaxPoolingVectorBlock (const std::vector< Pds::Vector > &A, unsigned int LinPool)
 Aplica max pooling a cada matriz $\mathbf{A}[n]$
de $L_\mathbf{An}$ lineas y $C_\mathbf{An}$ columnas. Más...
 

Static export import.

static bool Pds::Vector::ExportVectorBlockXmlToStream (std::ofstream &myfile, const std::vector< Pds::Vector > &Block)
 Retorna un std::string en formato Xml con el contenido del VectorBlock. Más...
 
static std::string Pds::Vector::ExportVectorBlockXmlToString (const std::vector< Pds::Vector > &Block)
 Retorna un std::string en formato Xml con el contenido del VectorBlock. Más...
 
static std::vector< Pds::Vector > Pds::Vector::ImportVectorBlockXmlFromString (const std::string &str)
 Carga el contenido de una std::vector<Pds::Vector> desde un std::string en formato Xml. Más...
 

Métodos Static con Vectores TensorVectorBlock.

Herramientas genéricas que pueden ser usadas desde Pds::Vector

static bool Pds::Vector::IsTensorVectorBlock (const std::vector< std::vector< Pds::Vector > > &Tensor)
 Verifica que el tensor (std::vector<std::vector<Pds::Vector>>) sea un vector de vectores no vacíos de matrices no nulas y similares. Es decir un Hiperrectángulo. Más...
 
static std::vector< std::vector< Pds::Vector > > Pds::Vector::RandNTensorVectorBlock (unsigned int L, unsigned int N, unsigned int Sz)
 Crea un tensor (std::vector<std::vector<Pds::Vector>>) con matrices no nulas y similares inicializadas con Pds::RandN(). Más...
 
static std::string Pds::Vector::ExportTensorVectorBlockXmlToString (const std::vector< std::vector< Pds::Vector > > &Block)
 Retorna un std::string en formato Xml con el contenido del TensorVectorBlock. Más...
 
static std::vector< std::vector< Pds::Vector > > Pds::Vector::ImportTensorVectorBlockXmlFromString (const std::string &str)
 Carga el contenido de una std::vector<std::vector<Pds::Vector>> desde un std::string en formato Xml. Más...
 
static bool Pds::Vector::ExportTensorVectorBlockXmlToStream (std::ofstream &myfile, const std::vector< std::vector< Pds::Vector > > &Block)
 Escribe en un std::ofstream en formato Xml con el contenido del TensorVectorBlock. Más...
 

Operadores unarios.

Pds::Vector Pds::Vector::Unit (void) const
 Calcula el vector unitario de $\mathbf{a}$. Más...
 
bool Pds::Vector::Normalize (void)
 Normaliza el vector convirtiendolo en unvector unitario. Más...
 
Pds::Vector Pds::Vector::Reverse (void)
 Retorna $\mathbf{b}$ un vector en orden reverso de si mismo, $\mathbf{a}$. Más...
 
Pds::Vector Pds::Vector::Cumulative (void)
 Retorna un vector $\mathbf{b}$ que acumula la suma de elementos de $\mathbf{a}$. Más...
 
Pds::Vector Pds::Vector::CumulativeNorm (void)
 Retorna un vector $\mathbf{b}$ que acumula y normaliza la suma de elementos de $\mathbf{a}$. Más...
 

Métodos para reordenar memoria con Pds::Vector.

bool Pds::Vector::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::Vector::Reshape (unsigned int Nel)
 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::Vector::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. Si las matrices no tienen un número de columnas igual a 1 da un error. Destruye las matrices en list. Este metodo es mas rapido que Pds::MergeVer(list) pues transplanta memoria. Más...
 

Métodos para calculo de kmeans y centroides con Pds::Vector

Descripción de algunos operadores habilitados a trabajar con Pds::Vector.

std::vector< unsigned int > Pds::Vector::NearestK (unsigned int K, const std::vector< Pds::Vector > &C, std::vector< double > &D2) const
 Calcula que linea $m$ de $\mathbf{C}\in \mathbb{R}^{M\times N}$ es mas cercana al vector $\mathbf{v}\in \mathbb{R}^{N}$. Más...
 

Métodos para ordenar Pds::Vector.

bool Pds::Vector::SortWith (Pds::Matrix &A)
 Ordena de forma ascendente un vector y se lleva consigo una matriz A ordenando tambien las filas de esta. Más...
 
bool Pds::Vector::SortMe (void)
 Ordena de forma ascendente un vector . Más...
 
bool Pds::Vector::SortMeReverse (void)
 Ordena de forma descendente un vector . Más...
 
std::vector< unsigned int > Pds::Vector::SortMeAndGetIds (void)
 Ordena de forma ascendente un vector e retorna el vector de IDs. Más...
 
bool Pds::Vector::SortFollowing (const std::vector< unsigned int > &id)
 Ordena de forma ascendente un vector siguiendo un vector de IDs. En caso de error no se hace nada, se considera error si el tamaño de is es diferente del tamaño del vector, o si algún id es mayor que el tamaño del vector. Más...
 

Métodos get set con Pds::Vector.

const double & Pds::Vector::operator[] (const unsigned int &id) const
 Retorna el valor en cada posicion del vector (solo lectura). Más...
 
const double & Pds::Vector::GetRaw (unsigned int lin) const
 Retorna una variable Datum en la posición (lin,0) de vector. Más...
 
void Pds::Vector::SetRaw (unsigned int lin, const double &val)
 Establece una variable Datum en la posición (lin,0) del vector. Más...
 

Métodos para exportar e importar Json con Pds::Matrix.

Herramientas genéricas que pueden ser usadas desde Pds::Matrix

Pds::Json Pds::Vector::ToJson (void) const
 Retorna un objeto Pds::Json con el contenido del vector. Más...
 
bool Pds::Vector::FromJson (const Pds::Json &J)
 Lee un objeto Pds::Json busca la etiqueta "Vector" y lo carga en la matriz. El objeto debe tener al menos los siguientes dados. Más...
 

Operadores binarios acumuladores y sus métodos equivalentes

Descripción de algunos operadores habilitados a trabajar con Pds::Vector.

bool Pds::Vector::Copy (const Pds::Matrix &B)
 Copia en si mismo (A), el contenido de una matriz B vectorizandola columana a columna. 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...
 
bool Pds::Vector::Vectorize (const Pds::Matrix &B)
 Copia en si mismo (A), el contenido de una matriz B vectorizandola columana a columna. Este método es equivalente a Copy(). Más...
 
bool Pds::Vector::CopyFromRow (unsigned int lin, const Pds::Matrix &B)
 Copia en si mismo (A), una linea de la matriz B. El tamaño de A debe ser el mismo que las columnas de B. Más...
 
void Pds::Vector::AddRawAssigAt (unsigned int lin, const double &val)
 Suma un valor al contenido de un elemento lin (acumula). Elem+=val. Más...
 

Descripción detallada

Clase que implementa un vector columna de valores reales.

#include <Pds/Vector>


Estas funciones trabajan con una matriz de la forma.

\[ \mathbf{A}=\left(\begin{matrix} a_{00} \\ a_{10} \\ \vdots \\ a_{(Nlin-2)0} \\ a_{(Nlin-1)0} \\ \end{matrix}\right) \]

\[ A\equiv [a_{i0}] \]

nlin es el número de lineas.

Informacion adicional puede ser encontrada en [5]

Documentación de las funciones

◆ Vector() [1/15]

Pds::Vector::Vector ( void  )

Crea un objeto de tipo Pds::Vector.

◆ Vector() [2/15]

Pds::Vector::Vector ( unsigned int  N)

Crea un objeto de tipo Pds::Vector.

Parámetros
[in]NEl numero de lineas del vector.

◆ Vector() [3/15]

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

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

\[ \mathbf{A}=\left(\begin{matrix} 0 \\ 0 \\ \vdots \\ 0 \\ 0 \\ \end{matrix}\right) \]

\[ A\equiv [0] \]

Para crear una matriz A de 6 filas y 1 columna:

Pds::Matrix B(2,3);
Pds::Vector A(B.Size());
if(A.IsEmpty()) std::cout<<"Yes,possible memory allocation problem\n";
else std::cout<<"No,all fine\n";
Pds::Matrix
La clase tipo Pds::Matrix . Esta clase genera una matriz de Nlin lineas y Ncol columnas....
Definition: Matrix.hpp:96
Pds::Vector
La clase tipo Pds::Vector . Esta clase genera una matriz de Nlin lineas y 1 columna....
Definition: Vector.hpp:80
Parámetros
[in]SEl tamaño del vector, en general el tamaño es S.Ncol*S.Nlin.

◆ Vector() [4/15]

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

Crea un objeto de tipo Pds::Vector copiando datos desde una matriz. Toda la matriz es vectorizada leyendo columna a columna.

\[ 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,5);
Pds::Vector A(B);
if(A.IsEmpty()) std::cout<<"Yes,possible memory allocation problem\n";
else std::cout<<"No,all fine\n";
Parámetros
[in]BMatriz a copiar.

◆ Vector() [5/15]

template<class Datum >
Pds::Vector::Vector ( const Pds::Array< Datum > &  B)

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

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

\[ \mathbf{A} \leftarrow \mathbf{B} \]

Parámetros
[in]BArray a copiar.

◆ Vector() [6/15]

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

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

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

Pds::Vector 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";
Pds::Matrix::IsEmpty
bool IsEmpty(void) const
Verifica si la matriz es nula es decir con lineas o columnas cero o arreglo NULL.
Parámetros
[in]strCadena a leer.

◆ Vector() [7/15]

Pds::Vector::Vector ( const std::initializer_list< double >  list)

Crea un objeto de tipo Pds::Vector copiando datos desde una lista.

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

Pds::Vector A={1, 2, 3, 4, 5 6};
if(A.IsEmpty()) std::cout<<"Yes,possible memory allocation problem\n";
else std::cout<<"No,all fine\n";
Parámetros
[in]listLista a leer.

◆ Vector() [8/15]

Pds::Vector::Vector ( const std::vector< double > &  vec)

Crea un objeto de tipo Pds::Vector copiando datos desde una std::vector.

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

std::vector<double> a={1, 2, 3, 4, 5 6};
Pds::Vector A(a);
if(A.IsEmpty()) std::cout<<"Yes,possible memory allocation problem\n";
else std::cout<<"No,all fine\n";
Parámetros
[in]vecVector a leer.

◆ Vector() [9/15]

Pds::Vector::Vector ( const std::vector< int > &  vec)

Crea un objeto de tipo Pds::Vector copiando datos desde una std::vector.

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

std::vector<int> a={1, 2, 3, 4, 5, 6};
Pds::Vector A(a);
if(A.IsEmpty()) std::cout<<"Yes,possible memory allocation problem\n";
else std::cout<<"No,all fine\n";
Parámetros
[in]vecVector a leer.

◆ Vector() [10/15]

Pds::Vector::Vector ( const std::vector< bool > &  vec)

Crea un objeto de tipo Pds::Vector copiando datos desde una std::vector.

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

std::vector<bool> a={true,false, false, true, true};
Pds::Vector A(a);
if(A.IsEmpty()) std::cout<<"Yes,possible memory allocation problem\n";
else std::cout<<"No,all fine\n";
Parámetros
[in]vecVector a leer.

◆ Vector() [11/15]

Pds::Vector::Vector ( unsigned int  N,
double  val 
)

Crea un objeto de tipo Pds::Vector.

Parámetros
[in]NEl numero de lineas del vector.
[in]valEl valor a inicializar.

◆ Vector() [12/15]

Pds::Vector::Vector ( const Pds::Matrix &  B,
unsigned int  col 
)

Crea un objeto de tipo Pds::Vector copiando datos desde una columna de una matriz.

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

\[ \mathbf{A} \leftarrow \mathbf{B\{:,col\}} \]

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

Pds::Matrix B(4,5);
Pds::Vector A(B,2);
if(A.IsEmpty()) std::cout<<"Yes,possible memory allocation problem\n";
else std::cout<<"No,all fine\n";
Parámetros
[in]BMatriz a copiar.
[in]colcolumna a copiar.

◆ Vector() [13/15]

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

Crea un objeto de tipo Pds::Vector, evaluando mediante una función, los datos de otro vector.

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

\[ \mathbf{A} \leftarrow func(\mathbf{B}) \]

Para crear un vector A , copia de sin(B):

Pds::Vector B(4);
Pds::Vector A(cos,B);
if(A.IsEmpty()) std::cout<<"Yes,possible memory allocation problem\n";
else std::cout<<"No,all fine\n";
Parámetros
[in]BVector a evaluar para copiar los resultados.
[in]funcFunción a aplicar, esta debe tener a forma double func(double).

◆ Vector() [14/15]

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

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

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

\[ B_{Nlin~Ncol,1} \leftarrow func(\mathbf{B(:)}) \]

Para crear un vector A , copia de sin(B(:)):

Pds::Matrix B(4);
Pds::Vector A(cos,B);
if(A.IsEmpty()) std::cout<<"Yes,possible memory allocation problem\n";
else std::cout<<"No,all fine\n";
Parámetros
[in]BVector a evaluar para copiar los resultados.
[in]funcFunción a aplicar, esta debe tener a forma double func(double).

◆ Vector() [15/15]

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

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

Pds::Vector A(Pds::Ra::TextFormat,"textfile.txt");
if(A.IsEmpty()) std::cout<<"Yes,possible memory allocation problem\n";
else std::cout<<"No,all fine\n";
Pds::Ra::TextFormat
@ TextFormat
Definition: RaDefines.hpp:373
Parámetros
[in]TypeTipo de archivo de fuente de datos.
[in]filepathPath del archivo cargado.

◆ Conv()

Pds::Vector Pds::Vector::Conv ( const Pds::Vector &  B,
Pds::Ra::Padding  Padding = Pds::Ra::Full 
) const

Calcula la convolución entre A y B.

\[ \mathbf{A}\equiv [a_{i}]\rightarrow ~0 \leq i< L_A \]

\[ \mathbf{B}\equiv [b_{i}]\rightarrow ~0 \leq i< L_B \]

\[ \mathbf{C}\equiv [c_{i}]\rightarrow ~0 \leq i< L_C \]

\[ c(k) \leftarrow \sum \limits_{l=-\infty}^{+\infty} a(k-l)b(l) \]

Conv
Padding Length ID
Pds::Ra::Valid $\mathbf{C}.Size() \equiv \left\{ \left\lfloor\frac{L_A-L_B+S_L}{S_L}\right\rfloor, 1 \right\} $ $ \textbf{for}~k: L_B-1~\overset{+S_L}{\rightarrow}~\left\lfloor\frac{L_A-L_B}{S_L}\right\rfloor + L_B-1 $
Pds::Ra::Same $\mathbf{C}.Size() \equiv \left\{ \left\lfloor\frac{L_A-1+S_L}{S_L}\right\rfloor, 1 \right\} $ $ \textbf{for}~k: \left\lfloor \frac{L_B}{2} \right\rfloor ~\overset{+S_L}{\rightarrow}~ \left\lfloor\frac{L_A-1}{S_L}\right\rfloor+\left\lfloor \frac{L_B}{2} \right\rfloor $
Pds::Ra::Full $\mathbf{C}.Size() \equiv \left\{ \left\lfloor\frac{L_A+L_B-2 +S_L}{S_L}\right\rfloor, 1 \right\} $ $ \textbf{for}~k: 0 ~\overset{+S_L}{\rightarrow}~\left\lfloor\frac{L_A+L_B-2}{S_L}\right\rfloor $
Parámetros
[in]BVector a aplicar la convolución.
[in]Paddingindica el tipo de pading de la convolución lo cual afecta al tamaño del vector de salida. Puede ser Pds::Ra::Valid, Pds::Ra::Full o Pds::Ra::Same.
Devuelve
retorna la convolucion.
Ejemplos
example_vector_dsp.cpp y example_vector_dsp_conv.cpp.

◆ Conv1DOutputSize()

static Pds::Size Pds::Vector::Conv1DOutputSize ( unsigned int  Anlin,
unsigned int  Bnlin,
unsigned int  Stride,
Pds::Ra::Padding  Padding 
)
static

Calcula el tamaño de la matriz resultado de la convolucion de A y B.

\[ \mathbf{A}\equiv [a_{i}]\rightarrow ~0 \leq i< L_A \]

\[ \mathbf{B}\equiv [b_{i}]\rightarrow ~0 \leq i< L_B \]

\[ \mathbf{C}\equiv [c_{i}]\rightarrow ~0 \leq i< L_C \]

\[ c(k) \leftarrow \sum \limits_{l=-\infty}^{+\infty} a(k-l)b(l) \]

Conv1D
Padding Length ID
Pds::Ra::Valid $\mathbf{C}.Size() \equiv \left\{ \left\lfloor\frac{L_A-L_B+S_L}{S_L}\right\rfloor, 1 \right\} $ $ \textbf{for}~k: L_B-1~\overset{+S_L}{\rightarrow}~\left\lfloor\frac{L_A-L_B}{S_L}\right\rfloor + L_B-1 $
Pds::Ra::Same $\mathbf{C}.Size() \equiv \left\{ \left\lfloor\frac{L_A-1+S_L}{S_L}\right\rfloor, 1 \right\} $ $ \textbf{for}~k: \left\lfloor \frac{L_B}{2} \right\rfloor ~\overset{+S_L}{\rightarrow}~ \left\lfloor\frac{L_A-1}{S_L}\right\rfloor+\left\lfloor \frac{L_B}{2} \right\rfloor $
Pds::Ra::Full $\mathbf{C}.Size() \equiv \left\{ \left\lfloor\frac{L_A+L_B-2 +S_L}{S_L}\right\rfloor, 1 \right\} $ $ \textbf{for}~k: 0 ~\overset{+S_L}{\rightarrow}~\left\lfloor\frac{L_A+L_B-2}{S_L}\right\rfloor $
Parámetros
[in]AnlinTamaño de la matriz a aplicar la convolución.
[in]BnlinTamaño de la matriz kernel a aplicar la convolución.
[in]StridePaso del convolucionador.
[in]Paddingindica el tipo de pading de la convolución lo cual afecta al tamaño del vector de salida.
Devuelve
retorna el tamaño de la convolución.
Ejemplos
example_vector_dsp.cpp.

◆ Conv1D()

Pds::Vector Pds::Vector::Conv1D ( const Pds::Vector &  B,
unsigned int  Stride = 1,
Pds::Ra::Padding  Padding = Pds::Ra::Full 
) const

Calcula la convolución entre A y B.

\[ \mathbf{A}\equiv [a_{i}]\rightarrow ~0 \leq i< L_A \]

\[ \mathbf{B}\equiv [b_{i}]\rightarrow ~0 \leq i< L_B \]

\[ \mathbf{C}\equiv [c_{i}]\rightarrow ~0 \leq i< L_C \]

\[ c(k) \leftarrow \sum \limits_{l=-\infty}^{+\infty} a(k-l)b(l) \]

Conv1D
Padding Length ID
Pds::Ra::Valid $\mathbf{C}.Size() \equiv \left\{ \left\lfloor\frac{L_A-L_B+S_L}{S_L}\right\rfloor, 1 \right\} $ $ \textbf{for}~k: L_B-1~\overset{+S_L}{\rightarrow}~\left\lfloor\frac{L_A-L_B}{S_L}\right\rfloor + L_B-1 $
Pds::Ra::Same $\mathbf{C}.Size() \equiv \left\{ \left\lfloor\frac{L_A-1+S_L}{S_L}\right\rfloor, 1 \right\} $ $ \textbf{for}~k: \left\lfloor \frac{L_B}{2} \right\rfloor ~\overset{+S_L}{\rightarrow}~ \left\lfloor\frac{L_A-1}{S_L}\right\rfloor+\left\lfloor \frac{L_B}{2} \right\rfloor $
Pds::Ra::Full $\mathbf{C}.Size() \equiv \left\{ \left\lfloor\frac{L_A+L_B-2 +S_L}{S_L}\right\rfloor, 1 \right\} $ $ \textbf{for}~k: 0 ~\overset{+S_L}{\rightarrow}~\left\lfloor\frac{L_A+L_B-2}{S_L}\right\rfloor $
Parámetros
[in]BVector a aplicar la convolución.
[in]StridePaso del convolucionador.
[in]Paddingindica el tipo de pading de la convolución lo cual afecta al tamaño del vector de salida. Puede ser Pds::Ra::Valid, Pds::Ra::Full o Pds::Ra::Same.
Devuelve
retorna la convolucion.
Ejemplos
example_matrixmath_dsp.cpp, example_vector_dsp.cpp y example_vector_dsp_conv1d.cpp.

◆ XCorr()

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

Calcula la correlacion cruzada entre A y B.

\[ \mathbf{A}\equiv [a_{i}] \rightarrow~0 \leq i< L_A \]

\[ \mathbf{B}\equiv [b_{i}] \rightarrow~0 \leq i< L_B \]

\[ \mathbf{C}\equiv [c_{i}] \rightarrow~ 0 \leq i< L_A+L_B-1 \]

\[ c(l) \leftarrow \sum \limits_{k=-\infty}^{+\infty} a(l+k) b(k) \]

XCorr
Same Formulation
false $\mathbf{C}.Size() \equiv \left\{ L_A+L_B-1, 1 \right\} $
true $\mathbf{C}.Size() \equiv \left\{ L_A,1 \right\} $
Parámetros
[in]BVector a aplicar la correlacion cruzada.
[in]SameIndica el tamaño del vector de salida.
Devuelve
retorna la correlacion cruzada.
Ejemplos
example_vector_dsp.cpp.

◆ MulTComp()

Pds::Matrix Pds::Vector::MulTComp ( double  b,
const Pds::Vector &  B 
) const

Multiplica con sigo mismo (A), la transpuesta de un vector [b;B] y el resultado es cargado en C.

\[ C \leftarrow A*[b;B]^T \]

Pds::Vector A="1 2 3 4";
Pds::Vector B="-1 2";
Pds::Matrix C;
C=A.MulTComp(1,B);
std::cout<<C;
Pds::Vector::MulTComp
Pds::Matrix MulTComp(double b, const Pds::Vector &B) const
Multiplica con sigo mismo (A), la transpuesta de un vector [b;B] y el resultado es cargado en C.
Parámetros
[in]bEl pedazo de arriba del vector a multiplicar
[in]BEl 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.

◆ IsVectorBlock()

static bool Pds::Vector::IsVectorBlock ( const std::vector< Pds::Vector > &  Block)
static

Verifica que el bloque (std::vector<Pds::Vector>) sea un vector no vacío de matrices no nulas y similares. Es decir un Hiperrectángulo.

Parámetros
[in]BlockUn bloque (std::vector<Pds::Vector>) de N matrices (Pds::Vector).
Devuelve
Retorna true si el vector no está vacío y todas las matrices son iguales y no vacías.

◆ FlattenVectorBlock()

static Pds::Vector Pds::Vector::FlattenVectorBlock ( const std::vector< Pds::Vector > &  Block)
static

Convierte a Pds::Vector un VectorBlock.

La converción es realizada vectorizando cada matriz concatenando sus columnas, esta concatenación se repite desde la primera matriz Block[0] hasta la última Block[N-1].

Parámetros
[in]BlockUn bloque (std::vector<Pds::Vector>) de N matrices (Pds::Vector).
Devuelve
Retorna un Pds::Vector que representa la linearización de un VectorBlock. Se retorna un vector vacio si alguna de las matrices en el VectorBlock está vacia.
Ejemplos
example_vector_dsp.cpp.

◆ RandNVectorBlock()

static std::vector< Pds::Vector > Pds::Vector::RandNVectorBlock ( unsigned int  N,
unsigned int  Sz 
)
static

Crea un bloque (std::vector<Pds::Vector>) con matrices no nulas y similares inicializadas con Pds::RandN().

Parámetros
[in]NNúmero de capas del Vector block.
[in]SzTamaño de cada matriz en el Vector block.
Devuelve
Retorna un Vector block Out o un vector vacio (Out.size()==0) en caso de error .

◆ MaxPoolingVectorBlock()

static std::vector< Pds::Vector > Pds::Vector::MaxPoolingVectorBlock ( const std::vector< Pds::Vector > &  A,
unsigned int  LinPool 
)
static

Aplica max pooling a cada matriz $\mathbf{A}[n]$
de $L_\mathbf{An}$ lineas y $C_\mathbf{An}$ columnas.

La matriz resultante $\mathbf{B}[n]$ tendrá $L_\mathbf{Bn}=ceil(L_\mathbf{An}/LinPool)$ lineas y $C_\mathbf{Bn}=ceil(C_\mathbf{An}/ColPool)$ columnas.

Parámetros
[in]ASampleBlock a aplicar maxpooling.
[in]LinPoolPooling entre lineas.
Devuelve
Retorna la matriz B resultado de aplicar maxpooling.
Ejemplos
example_vector_dsp.cpp.

◆ ExportVectorBlockXmlToStream()

static bool Pds::Vector::ExportVectorBlockXmlToStream ( std::ofstream &  myfile,
const std::vector< Pds::Vector > &  Block 
)
static

Retorna un std::string en formato Xml con el contenido del VectorBlock.

Por exemplo si guardamos un VectorBlock A={Pds::Eye(3),Pds::Ones(3)} en el std::string se escribirá:

<VectorBlock>
<Nel>2</Nel>
<Matrix>
<Nlin>3</Nlin>
<Ncol>3</Ncol>
<Array>
1
1
1
</Array>
</Matrix>
<Matrix>
<Nlin>3</Nlin>
<Ncol>3</Ncol>
<Array>
1
1
1
</Array>
</Matrix>
</VectorBlock>
Parámetros
[in]myfileStream de salida.
[in]BlockUn bloque (std::vector<Pds::Vector>) de N matrices (Pds::Vector).
Devuelve
Retorna un true si todo fue bien o false si no.
Ejemplos
example_vector_export_vector_block.cpp.

◆ ExportVectorBlockXmlToString()

static std::string Pds::Vector::ExportVectorBlockXmlToString ( const std::vector< Pds::Vector > &  Block)
static

Retorna un std::string en formato Xml con el contenido del VectorBlock.

Por exemplo si guardamos un VectorBlock A={Pds::X3D(),Pds::Y3D()} en el std::string se escribirá:

<VectorBlock>
<Nel>2</Nel>
<Matrix>
<Nlin>3</Nlin>
<Ncol>1</Ncol>
<Array>
1
0
0
</Array>
</Matrix>
<Matrix>
<Nlin>3</Nlin>
<Ncol>3</Ncol>
<Array>
0
1
0
</Array>
</Matrix>
</VectorBlock>
Parámetros
[in]BlockUn bloque (std::vector<Pds::Vector>) de N matrices (Pds::Vector).
Devuelve
Retorna un std::string en formato Xml con el contenido de la matriz.
Ejemplos
example_vector_export_vector_block.cpp.

◆ ImportVectorBlockXmlFromString()

static std::vector< Pds::Vector > Pds::Vector::ImportVectorBlockXmlFromString ( const std::string &  str)
static

Carga el contenido de una std::vector<Pds::Vector> desde un std::string en formato Xml.

Si la lectura es satisfactoria se retorna un nuevo std::vector<Pds::Vector>, en caso de error el vector estará vacio, es decir size()==0.

Por exemplo si tenemos un std::string str con el texto:

<VectorBlock>
<Nel>2</Nel>
<Matrix>
<Nlin>3</Nlin>
<Ncol>1</Ncol>
<Array>
1
0
0
</Array>
</Matrix>
<Matrix>
<Nlin>3</Nlin>
<Ncol>3</Ncol>
<Array>
0
1
0
</Array>
</Matrix>
</VectorBlock>

Podremos leer el contenido y cargarlo en A usando:

A=Pds::Vector::ImportVectorBlockXmlFromString(str);

Este formato de almacenamiento de datos proviene de usar Pds::Vector::ExportVectorBlockXmlToString().

Parámetros
[in]strEl std::string donde se leerán los datos.
Devuelve
Retorna una VectorBlock de tipo std::vector<Pds::Vector>.
Ejemplos
example_vector_export_vector_block.cpp.

◆ IsTensorVectorBlock()

static bool Pds::Vector::IsTensorVectorBlock ( const std::vector< std::vector< Pds::Vector > > &  Tensor)
static

Verifica que el tensor (std::vector<std::vector<Pds::Vector>>) sea un vector de vectores no vacíos de matrices no nulas y similares. Es decir un Hiperrectángulo.

Parámetros
[in]TensorUn bloque (std::vector<std::vector<Pds::Vector>>) de L sample block con N matrices (Pds::Vector).
Devuelve
Retorna true si el vector no está vacío y todas las matrices son iguales y no vacías.

◆ RandNTensorVectorBlock()

static std::vector< std::vector< Pds::Vector > > Pds::Vector::RandNTensorVectorBlock ( unsigned int  L,
unsigned int  N,
unsigned int  Sz 
)
static

Crea un tensor (std::vector<std::vector<Pds::Vector>>) con matrices no nulas y similares inicializadas con Pds::RandN().

Parámetros
[in]LNúmero de sample block.
[in]NNúmero de capas en cada sample block.
[in]SzTamaño de cada una de las matrices en todos los sample block.
Devuelve
Retorna un sample block Out o un vector vacio (Out.size()==0) en caso de error .

◆ ExportTensorVectorBlockXmlToString()

static std::string Pds::Vector::ExportTensorVectorBlockXmlToString ( const std::vector< std::vector< Pds::Vector > > &  Block)
static

Retorna un std::string en formato Xml con el contenido del TensorVectorBlock.

Por exemplo si guardamos un TensorVectorBlock A={{Pds::X3D(),Pds::Y3D()},{Pds::Y3D(),Pds::Z3D()}} en el std::string se escribirá:

<TensorVectorBlock>
<Nel>2</Nel>
<VectorBlock>
...
</VectorBlock>
<VectorBlock>
...
</VectorBlock>
</TensorVectorBlock>
Parámetros
[in]BlockUn bloque (std::vector<std::vector<Pds::Vector>>) de N*M matrices (Pds::Vector).
Devuelve
Retorna un std::string en formato Xml con el contenido del TensorVectorBlock.

◆ ImportTensorVectorBlockXmlFromString()

static std::vector< std::vector< Pds::Vector > > Pds::Vector::ImportTensorVectorBlockXmlFromString ( const std::string &  str)
static

Carga el contenido de una std::vector<std::vector<Pds::Vector>> desde un std::string en formato Xml.

Si la lectura es satisfactoria se retorna un nuevo std::vector<std::vector<Pds::Vector>>, en caso de error el vector estará vacio, es decir size()==0.

Por exemplo si tenemos un std::string str con el texto:

<TensorVectorBlock>
<Nel>2</Nel>
<VectorBlock>
...
</VectorBlock>
<VectorBlock>
...
</VectorBlock>
</TensorVectorBlock>

Podremos leer el contenido y cargarlo en A usando:

A=Pds::Vector::ImportTensorVectorBlockXmlFromString(str);

Este formato de almacenamiento de datos proviene de usar Pds::Vector::ExportTensorVectorBlockXmlToString().

Parámetros
[in]strEl std::string donde se leerán los datos.
Devuelve
Retorna una TensorVectorBlock de tipo std::vector<std::vector<Pds::Vector>>.

◆ ExportTensorVectorBlockXmlToStream()

static bool Pds::Vector::ExportTensorVectorBlockXmlToStream ( std::ofstream &  myfile,
const std::vector< std::vector< Pds::Vector > > &  Block 
)
static

Escribe en un std::ofstream en formato Xml con el contenido del TensorVectorBlock.

Por exemplo si guardamos un TensorVectorBlock A={{Pds::X3D(),Pds::Y3D()},{Pds::Y3D(),Pds::Z3D()}} en el std::ofstream se escribirá:

<TensorVectorBlock>
<Nel>2</Nel>
<VectorBlock>
...
</VectorBlock>
<VectorBlock>
...
</VectorBlock>
</TensorVectorBlock>
Parámetros
[in]myfileStream de salida.
[in]BlockUn bloque (std::vector<std::vector<Pds::Vector>>) de N*M matrices (Pds::Vector).
Devuelve
Retorna un true si todo fue bien o false si no.

◆ Unit()

Pds::Vector Pds::Vector::Unit ( void  ) const

Calcula el vector unitario de $\mathbf{a}$.

\[ \mathbf{b}\leftarrow \frac{\mathbf{a}}{||\mathbf{a}||} \]

Devuelve
retorna un vector unitario $\mathbf{B}$.
Ejemplos
example_vector_operator_unit.cpp.

◆ Normalize()

bool Pds::Vector::Normalize ( void  )

Normaliza el vector convirtiendolo en unvector unitario.

\[ \mathbf{a}\leftarrow \frac{\mathbf{a}}{||\mathbf{a}||} \]

Devuelve
retorna true si todo fue bien o false si no.

◆ Reverse()

Pds::Vector Pds::Vector::Reverse ( void  )

Retorna $\mathbf{b}$ un vector en orden reverso de si mismo, $\mathbf{a}$.

\[ \mathbf{b}\leftarrow [a_{N-1} \quad ... \quad a_{n} \quad ... \quad a_{0}]\]

.

Devuelve
Retorna $\mathbf{b}$ un vector en orden reverso de si mismo, $\mathbf{a}$.
Ejemplos
example_vector_operator_unit.cpp.

◆ Cumulative()

Pds::Vector Pds::Vector::Cumulative ( void  )

Retorna un vector $\mathbf{b}$ que acumula la suma de elementos de $\mathbf{a}$.

\[ b_{n}=\sum_{l=0}^{n}a_{l}\]

.

\[ \mathbf{b}\leftarrow [b_{0} \quad ... \quad b_{n} \quad ... \quad b_{N-1}]\]

.

Devuelve
Retorna un vector $\mathbf{b}$ que acumula la suma de elementos de $\mathbf{a}$.
Ejemplos
example_vector_operator_unit.cpp.

◆ CumulativeNorm()

Pds::Vector Pds::Vector::CumulativeNorm ( void  )

Retorna un vector $\mathbf{b}$ que acumula y normaliza la suma de elementos de $\mathbf{a}$.

\[ b_{n}=\frac{\sum_{l=0}^{n}a_{l}}{\sum_{l=0}^{N-1}a_{l}}\]

.

\[ \mathbf{b}\leftarrow [b_{0} \quad ... \quad b_{n} \quad ... \quad b_{N-1}]\]

.

Devuelve
Retorna un vector $\mathbf{b}$ que acumula y normaliza la suma de elementos de $\mathbf{a}$.
Ejemplos
example_vector_operator_unit.cpp.

◆ Reshape() [1/2]

bool Pds::Vector::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.

|warning Este método cambiar .Reshape(Nlin,Ncol) por .Reshape(Nlin*Ncol,1)

Parámetros
[in]NlinNúmero de lineas. Da error si el valor es cero.
[in]NcolNúmero de columnas. Da error si el valor es cero.

◆ Reshape() [2/2]

bool Pds::Vector::Reshape ( unsigned int  Nel)

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]NelNúmero de lineas. Da error si el valor es cero.

◆ FusionVer()

bool Pds::Vector::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. Si las matrices no tienen un número de columnas igual a 1 da un error. Destruye las matrices en list. Este metodo es mas rapido que Pds::MergeVer(list) pues transplanta memoria.

Parámetros
[in]listLa 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.

◆ NearestK()

std::vector< unsigned int > Pds::Vector::NearestK ( unsigned int  K,
const std::vector< Pds::Vector > &  C,
std::vector< double > &  D2 
) const

Calcula que linea $m$ de $\mathbf{C}\in \mathbb{R}^{M\times N}$ es mas cercana al vector $\mathbf{v}\in \mathbb{R}^{N}$.

\[ \mathbf{id}= \begin{bmatrix} id_0\\ id_1\\ \vdots\\ id_k\\ \vdots\\ id_{K-1}\\ \end{bmatrix}, \quad \mathbf{d}^{2}= \begin{bmatrix} d^{2}_0\\ d^{2}_1\\ \vdots\\ d^{2}_k\\ \vdots\\ d^{2}_{K-1}\\ \end{bmatrix} \quad \leftarrow \quad \mathbf{C}= \begin{bmatrix} \mathbf{c}_0^{T}\\ \mathbf{c}_1^{T}\\ \vdots\\ \mathbf{c}_m^{T}\\ \vdots\\ \mathbf{c}_{M-1}^{T}\\ \end{bmatrix}, \qquad \mathbf{v}= \begin{bmatrix} x_0\\ x_1\\ \vdots\\ x_n\\ \vdots\\ x_{N-1}\\ \end{bmatrix} \]

\[ d^{2}_{m}=\sum_{n}^{N}|c_{mn}-x_{n}|^2 \]

\[ id_{k}=\arg\min_{m,<k>}{d^{2}_{m}} \]

std::vector<unsigned int> ID;
std::vector<double> D2;
ID=V.NearestK(K,C,D2)

El vector $\mathbf{id}$ contiene a los $K$ indices de las lineas de $\mathbf{C}$ que estan mas cerca al vector $\mathbf{v}$. Las lineas son comparadas usando distancia euclidiana al cuadrado.

Parámetros
[in]KNúmero máximo de vecinos a buscar.
[in]CVector de vectores $\mathbf{c}_{m}$ a comparar. C.Ncol() debe ser igual V.Nel().
[out]D2El vector $\mathbf{d}^{2}$ de las distancias euclidianas al cuadrado correspondientes a $\mathbf{id}$.
Devuelve
Retorna un vector entero $ID\equiv \mathbf{id}$, de $K$ elementos. El primer elemento es el mas cercano. En caso de que el vector $\mathbf{v}$ sea vacío se retorna un vector vazio.
Ejemplos
example_vector_nearestk.cpp.

◆ SortWith()

bool Pds::Vector::SortWith ( Pds::Matrix &  A)

Ordena de forma ascendente un vector y se lleva consigo una matriz A ordenando tambien las filas de esta.

Parámetros
[in]AMatriz a ordenar acompañando el orden de las lineas del vector.
Devuelve
Retorna true si todo fue bien o false en caso de error, por ejemplo si las matrices están vacias o no tienen el mismo número de lineas.
Ejemplos
example_vector_sorting.cpp.

◆ SortMe()

bool Pds::Vector::SortMe ( void  )

Ordena de forma ascendente un vector .

Devuelve
Retorna true si todo fue bien o false en caso de error.
Ejemplos
example_vector_sorting.cpp.

◆ SortMeReverse()

bool Pds::Vector::SortMeReverse ( void  )

Ordena de forma descendente un vector .

Devuelve
Retorna true si todo fue bien o false en caso de error.
Ejemplos
example_vector_sorting.cpp.

◆ SortMeAndGetIds()

std::vector< unsigned int > Pds::Vector::SortMeAndGetIds ( void  )

Ordena de forma ascendente un vector e retorna el vector de IDs.

Devuelve
Retorna el vector de IDs ordenados.
Ejemplos
example_vector_sorting.cpp.

◆ SortFollowing()

bool Pds::Vector::SortFollowing ( const std::vector< unsigned int > &  id)

Ordena de forma ascendente un vector siguiendo un vector de IDs. En caso de error no se hace nada, se considera error si el tamaño de is es diferente del tamaño del vector, o si algún id es mayor que el tamaño del vector.

Devuelve
Retorna true si todo fue bien o false en caso de error.
Ejemplos
example_vector_sorting.cpp.

◆ operator[]()

const double & Pds::Vector::operator[] ( const unsigned int &  id) const
inline

Retorna el valor en cada posicion del vector (solo lectura).

Atención
NO hace una verificación si el indice existe!!!!
Parámetros
[in]idIndice del vector.
Devuelve
Retorna el valor en cada posicion del vector.

Definición en la línea 1186 del archivo Vector.hpp.

1187 {
1188 return this->array[id][0];
1189 }
Pds::Matrix::array
double ** array
Definition: Matrix.hpp:99

Hace referencia a Pds::Matrix::array.

◆ GetRaw()

const double & Pds::Vector::GetRaw ( unsigned int  lin) const
inline

Retorna una variable Datum en la posición (lin,0) de vector.

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]linLa linea en consulta.
Devuelve
Retorna una variable Datum en la posición (lin,0).

Definición en la línea 1199 del archivo Vector.hpp.

1200 {
1201 return this->array[lin][0];
1202 }

Hace referencia a Pds::Matrix::array.

◆ SetRaw()

void Pds::Vector::SetRaw ( unsigned int  lin,
const double &  val 
)
inline

Establece una variable Datum en la posición (lin,0) del vector.

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]linLa linea en consulta.
[in]valvalor a escribir.
Ejemplos
example_matrixmath_information.cpp.

Definición en la línea 1212 del archivo Vector.hpp.

1213 {
1214 this->array[lin][0]=val;
1215 }

Hace referencia a Pds::Matrix::array.

◆ ToJson()

Pds::Json Pds::Vector::ToJson ( void  ) const

Retorna un objeto Pds::Json con el contenido del vector.

Por exemplo si guardamos una matriz V.FillId() entonces se retornará:

{
"Vector":
{
"Nel":5,
"Array":[0, 1, 2, 3, 4 ]
}
}
Devuelve
Retorna un objeto Pds::Json con el contenido del vector.
Ejemplos
example_vector_export_json.cpp y example_vector_json.cpp.

◆ FromJson()

bool Pds::Vector::FromJson ( const Pds::Json &  J)

Lee un objeto Pds::Json busca la etiqueta "Vector" y lo carga en la matriz. El objeto debe tener al menos los siguientes dados.

{
"Vector":
{
"Nel":5,
"Array":[0, 1, 2, 3, 4 ]
}
}
Devuelve
Retorna true si la lectura sucedió sin errores y false si no. Si la lectura es incorrecta la matriz se vuelve vacia.
Ejemplos
example_vector_json.cpp.

◆ Copy()

bool Pds::Vector::Copy ( const Pds::Matrix &  B)

Copia en si mismo (A), el contenido de una matriz B vectorizandola columana a columna. 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]Bla matriz a copiar
Devuelve
Retorna true si todo fue bien o false si no. Si se retorna false el receptor no altera su contenido.
Ejemplos
example_vector_create.cpp.

Referenciado por Pds::Vector::Vectorize().

◆ Vectorize()

bool Pds::Vector::Vectorize ( const Pds::Matrix &  B)
inline

Copia en si mismo (A), el contenido de una matriz B vectorizandola columana a columna. Este método es equivalente a Copy().

\[ A \leftarrow B \]

Parámetros
[in]Bla matriz a copiar
Devuelve
Retorna true si todo fue bien o false si no. Si se retorna false el receptor no altera su contenido.

Definición en la línea 1295 del archivo Vector.hpp.

1296 {
1297 return this->Copy(B);
1298 }
Pds::Vector::Copy
bool Copy(const Pds::Matrix &B)
Copia en si mismo (A), el contenido de una matriz B vectorizandola columana a columna....

Hace referencia a Pds::Vector::Copy().

Gráfico de llamadas para esta función:

◆ CopyFromRow()

bool Pds::Vector::CopyFromRow ( unsigned int  lin,
const Pds::Matrix &  B 
)

Copia en si mismo (A), una linea de la matriz B. El tamaño de A debe ser el mismo que las columnas de B.

\[ A \leftarrow B(lin,:) \]

Cuando acontece:

Pds::Matrix B(3,4);
Pds::Vector A(4);
unsigned int lin=1;
A.CopyFromRow(lin,B);
Parámetros
[in]linLinea a copiar.
[in]BLa matriz fuente de copia.
Devuelve
Retorna true si todo fue bien o false si no.

◆ AddRawAssigAt()

void Pds::Vector::AddRawAssigAt ( unsigned int  lin,
const double &  val 
)
inline

Suma un valor al contenido de un elemento lin (acumula). Elem+=val.

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]linLa linea en consulta.
[in]valvalor a acumular.

Definición en la línea 1327 del archivo Vector.hpp.

1328 {
1329 this->array[lin][0]+=val;
1330 }

Hace referencia a Pds::Matrix::array.

◆ ~Vector()

Pds::Vector::~Vector ( )

Enlaces de interés

HomePage Bazaar Download Bug report Ayuda Developer Feed
Manual de referencia generado el Martes, 10 de Octubre de 2023 18:23:41 para la biblioteca libpdsramm usando  Generado el Martes, 10 de Octubre de 2023 18:23:41 para libpdsramm por   doxygen 1.9.4