Matrix1D Vectors

Collaboration diagram for Matrix1D Vectors:

Classes
class	Matrix1D< T >

Typedefs
typedef Matrix1D< double >	DVector
typedef Matrix1D< int >	IVector

Vectors speed up macros
This macros are defined to allow high speed in critical parts of your program. They shouldn't be used systematically as usually there is no checking on the correctness of the operation you are performing. Speed comes from three facts: first, they are macros and no function call is performed (although most of the critical functions are inline functions), there is no checking on the correctness of the operation (it could be wrong and you are not warned of it), and destination vectors are not returned saving time in the copy constructor and in the creation/destruction of temporary vectors.
#define	MATRIX1D_ARRAY(v)   ((v).vdata)
#define	FOR_ALL_ELEMENTS_IN_MATRIX1D(v)   for (size_t i=0; i<v.vdim; i++)
#define	VEC_XSIZE(m)   ((m).vdim)
#define	XX(v)   (v).vdata[0]
#define	YY(v)   (v).vdata[1]
#define	ZZ(v)   (v).vdata[2]
#define	VECTOR_R2(v, x, y)
#define	VECTOR_R3(v, x, y, z)
#define	V2_PLUS_V2(a, b, c)
#define	V2_MINUS_V2(a, b, c)
#define	V2_PLUS_CT(a, b, k)
#define	V2_BY_CT(a, b, k)
#define	V3_PLUS_V3(a, b, c)
#define	V3_MINUS_V3(a, b, c)
#define	V3_PLUS_CT(a, b, c)
#define	V3_BY_CT(a, b, c)
#define	VEC_ELEM(v, i)   ((v).vdata[(i)])
#define	dMi(v, i)   ((v).vdata[(i)])
#define	VEC_SWAP(v, i, j, aux)   {aux = dMi(v, i); dMi(v, i) = dMi(v, j); dMi(v, j) = aux; }

Vector Related functions
These functions are not methods of Matrix1D
Matrix1D< double >	vectorR2 (double x, double y)
Matrix1D< double >	vectorR3 (double x, double y, double z)
Matrix1D< int >	vectorR3 (int x, int y, int z)
template<typename T >
T	dotProduct (const Matrix1D< T > &v1, const Matrix1D< T > &v2)
template<typename T >
Matrix1D< T >	vectorProduct (const Matrix1D< T > &v1, const Matrix1D< T > &v2)
template<typename T >
void	vectorProduct (const Matrix1D< T > &v1, const Matrix1D< T > &v2, Matrix1D< T > &result)
template<typename T >
void	sortTwoVectors (Matrix1D< T > &v1, Matrix1D< T > &v2)
template<typename T1 , typename T2 >
void	typeCast (const Matrix1D< T1 > &v1, Matrix1D< T2 > &v2)
template<typename T1 >
void	typeCast (const Matrix1D< T1 > &v1, Matrix1D< T1 > &v2)

Detailed Description

Macro Definition Documentation

dMi

#define dMi	(		v,
			i
	)		((v).vdata[(i)])

Definition at line 246 of file matrix1d.h.

FOR_ALL_ELEMENTS_IN_MATRIX1D

#define FOR_ALL_ELEMENTS_IN_MATRIX1D

(

v

)

for (size_t i=0; i<v.vdim; i++)

For all elements in the array This macro is used to generate loops for the vector in an easy manner. It defines an internal index 'i' which ranges the vector using its mathematical definition (ie, logical access).

FOR_ALL_ELEMENTS_IN_MATRIX1D(v)
{
    std::cout << v(i) << " ";
}

Definition at line 72 of file matrix1d.h.

MATRIX1D_ARRAY

#define MATRIX1D_ARRAY

(

v

)

((v).vdata)

Array access. This macro gives you access to the array (T)

Definition at line 58 of file matrix1d.h.

V2_BY_CT

#define V2_BY_CT	(		a,
			b,
			k
	)

Value:

{ \
        XX(a) = XX(b) * (k); \
        YY(a) = YY(b) * (k); }

Multiplying/dividing by a constant a R2 vector (a=b*k)

MultidimArray< double > a(2), b(2);
double k;
...;
V2_BY_CT(a, b, k);

MultidimArray< double > a(2), b(2);
double k;
...;
V2_BY_CT(a, b, 1/k);

Definition at line 179 of file matrix1d.h.

V2_MINUS_V2

#define V2_MINUS_V2	(		a,
			b,
			c
	)

Value:

{ \
        XX(a) = XX(b) - XX(c); \
        YY(a) = YY(b) - YY(c); }

Subtracting two R2 vectors (a=b-c)

MultidimArray< double > a(2), b(2), c(2);
...;
V2_MINUS_V2(a, b, c);

Definition at line 145 of file matrix1d.h.

V2_PLUS_CT

#define V2_PLUS_CT	(		a,
			b,
			k
	)

Value:

{ \
        XX(a) = XX(b) + (k); \
        YY(a) = YY(b) + (k); }

Adding/subtracting a constant to a R2 vector (a=b-k).

MultidimArray< double > a(2), b(2);
double k;
...;
V2_PLUS_CT(a, b, k);

MultidimArray< double > a(2), b(2);
double k;
...;
V2_PLUS_CT(a, b, -k);

Definition at line 162 of file matrix1d.h.

V2_PLUS_V2

#define V2_PLUS_V2	(		a,
			b,
			c
	)

Value:

{ \
        XX(a) = XX(b) + XX(c); \
        YY(a) = YY(b) + YY(c); }

Adding two R2 vectors (a=b+c)

MultidimArray< double > a(2), b(2), c(2);
...;
V2_PLUS_V2(a, b, c);

Definition at line 134 of file matrix1d.h.

V3_BY_CT

#define V3_BY_CT	(		a,
			b,
			c
	)

Value:

{ \
        XX(a) = XX(b) * (c); \
        YY(a) = YY(b) * (c); \
        ZZ(a) = ZZ(b) * (c); }

Multiplying/dividing by a constant a R3 vector (a=b*k)

MultidimArray< double > a(3), b(3);
double k;
...;
V3_BY_CT(a, b, k);

MultidimArray< double > a(3), b(3);
double k;
...;
V3_BY_CT(a, b, 1/k);

Definition at line 238 of file matrix1d.h.

V3_MINUS_V3

#define V3_MINUS_V3	(		a,
			b,
			c
	)

Value:

{ \
        XX(a) = XX(b) - XX(c); \
        YY(a) = YY(b) - YY(c); \
        ZZ(a) = ZZ(b) - ZZ(c); }

Subtracting two R3 vectors (a=b-c)

MultidimArray< double > a(3), b(3), c(3);
...;
V3_MINUS_V3(a, b, c);

Definition at line 202 of file matrix1d.h.

V3_PLUS_CT

#define V3_PLUS_CT	(		a,
			b,
			c
	)

Value:

{ \
        XX(a) = XX(b) + (c); \
        YY(a) = YY(b) + (c); \
        ZZ(a) = ZZ(b) + (c); }

Adding/subtracting a constant to a R3 vector (a=b-k)

MultidimArray< double > a(3), b(3);
double k;
...;
V3_PLUS_CT(a, b, k);

MultidimArray< double > a(3), b(3);
double k;
...;
V3_PLUS_CT(a, b, -k);

Definition at line 220 of file matrix1d.h.

V3_PLUS_V3

#define V3_PLUS_V3	(		a,
			b,
			c
	)

Value:

{ \
        XX(a) = XX(b) + XX(c); \
        YY(a) = YY(b) + YY(c); \
        ZZ(a) = ZZ(b) + ZZ(c); }

Adding two R3 vectors (a=b+c)

MultidimArray< double > a(3), b(3), c(3);
...;
V3_PLUS_V3(a, b, c);

Definition at line 190 of file matrix1d.h.

VEC_ELEM

#define VEC_ELEM	(		v,
			i
	)		((v).vdata[(i)])

Direct access to vector element

Definition at line 245 of file matrix1d.h.

VEC_SWAP

#define VEC_SWAP	(		v,
			i,
			j,
			aux
	)		{aux = dMi(v, i); dMi(v, i) = dMi(v, j); dMi(v, j) = aux; }

Definition at line 248 of file matrix1d.h.

VEC_XSIZE

#define VEC_XSIZE

(

m

)

((m).vdim)

X dimension of the matrix

Definition at line 77 of file matrix1d.h.

VECTOR_R2

#define VECTOR_R2	(		v,
			x,
			y
	)

Value:

{ \
        XX(v) = x; YY(v) = y; }

Creates vector in R2 The vector must be created beforehand to the correct size. After this macro the vector is (x, y) in R2.

MultidimArray< double > v(2);
VECTOR_R2(v, 1, 2);

Definition at line 112 of file matrix1d.h.

VECTOR_R3

#define VECTOR_R3	(		v,
			x,
			y,
			z
	)

Value:

{ \
        XX(v) = x; YY(v) = y; ZZ(v) = z;}

Creates vector in R3 The vector must be created beforehand to the correct size. After this macro the vector is (x, y, z) in R3.

MultidimArray< double > v(3);
VECTOR_R2(v, 1, 2, 1);

Definition at line 124 of file matrix1d.h.

XX

#define XX

(

v

)

(v).vdata[0]

Access to X component

XX(v) = 1;
val = XX(v);

Definition at line 85 of file matrix1d.h.

YY

#define YY

(

v

)

(v).vdata[1]

Access to Y component

YY(v) = 1;
val = YY(v);

Definition at line 93 of file matrix1d.h.

ZZ

#define ZZ

(

v

)

(v).vdata[2]

Access to Z component

ZZ(v) = 1;
val = ZZ(v);

Definition at line 101 of file matrix1d.h.

Typedef Documentation

DVector

typedef Matrix1D<double> DVector

Definition at line 1094 of file matrix1d.h.

IVector

typedef Matrix1D<int> IVector

Definition at line 1095 of file matrix1d.h.

Function Documentation

dotProduct()

template<typename T >

T dotProduct	(	const Matrix1D< T > &	v1,
		const Matrix1D< T > &	v2
	)

Dot product. Given any two vectors in Rn (n-dimensional vector), this function returns the dot product of both. If the vectors are not of the same size or shape then an exception is thrown. The dot product is defined as the sum of the component by component multiplication.

For the R3 vectors (V1x,V1y,V1z), (V2x, V2y, V2z) the result is V1x*V2x + V1y*V2y + V1z*V2z.

Matrix1D< double > v1(1000);
v1.init_random(0, 10, "gaussian");
std::cout << "The power of this vector should be 100 and is " <<
    dotProduct(v1, v1) << std::endl;

Definition at line 1140 of file matrix1d.h.

{
    if (!v1.sameShape(v2))
        REPORT_ERROR(ERR_MATRIX_SIZE,
                     "Dot product: vectors of different size or shape");

    T accumulate = 0;
    for (size_t j = 0; j < v1.vdim; j++)
        accumulate += v1.vdata[j] * v2.vdata[j];
    return accumulate;
}

sortTwoVectors()

template<typename T >

void sortTwoVectors	(	Matrix1D< T > &	v1,
		Matrix1D< T > &	v2
	)

Sort two vectors. v1 and v2 must be of the same shape, if not an exception is thrown. After calling this function all components in v1 are the minimum between the corresponding components in v1 and v2, and all components in v2 are the maximum.

For instance, XX(v1)=MIN(XX(v1), XX(v2)), XX(v2)=MAX(XX(v1), XX(v2)). Notice that both vectors are modified. This function is very useful for sorting two corners. After calling it you can certainly perform a non-empty for (from corner1 to corner2) loop.

Definition at line 1206 of file matrix1d.h.

{
    T temp;
    if (!v1.sameShape(v2))
        REPORT_ERROR(ERR_MATRIX_SIZE,
                     "sortTwoVectors: vectors are not of the same shape");

    for (size_t j = 0; j < v1.vdim; j++)
    {
        temp = XMIPP_MIN(v1.vdata[j], v2.vdata[j]);
        v2.vdata[j] = XMIPP_MAX(v1.vdata[j], v2.vdata[j]);
        v1.vdata[j] = temp;
    }
}

typeCast() [1/2]

template<typename T1 , typename T2 >

void typeCast	(	const Matrix1D< T1 > &	v1,
		Matrix1D< T2 > &	v2
	)

Conversion from one type to another. If we have an integer array and we need a double one, we can use this function. The conversion is done through a type casting of each element If n >= 0, only the nth volumes will be converted, otherwise all NSIZE volumes

Definition at line 1227 of file matrix1d.h.

{
    if (v1.vdim == 0)
    {
        v2.clear();
        return;
    }

    v2.resizeNoCopy(v1.vdim);
    for (size_t j = 0; j < v1.vdim; j++)
        v2.vdata[j] = static_cast<T2>(v1.vdata[j]);
}

typeCast() [2/2]

template<typename T1 >

void typeCast	(	const Matrix1D< T1 > &	v1,
		Matrix1D< T1 > &	v2
	)

Conversion from one type to another. In some cases, the two types are the same. So a faster way is simply by assignment.

Definition at line 1244 of file matrix1d.h.

{
    v2 = v1;
}

vectorProduct() [1/2]

template<typename T >

Matrix1D<T> vectorProduct	(	const Matrix1D< T > &	v1,
		const Matrix1D< T > &	v2
	)

Vector product in R3. This function takes two R3 vectors and compute their vectorial product. For two vectors (V1x,V1y,V1z), (V2x, V2y, V2z) the result is (V1y*V2z-V1z*v2y, V1z*V2x-V1x*V2z, V1x*V2y-V1y*V2x). Pay attention that this operator is not conmutative. An exception is thrown if the vectors are not of the same shape or they don't belong to R3.

Matrix1D< T > X = vectorR3(1, 0, 0), Y = vector_R3(0, 1, 0);
std::cout << "X*Y=Z=" << vectorProduct(X,Y).transpose() << std::endl;

Definition at line 1165 of file matrix1d.h.

{
    if (v1.vdim != 3 || v2.vdim != 3)
        REPORT_ERROR(ERR_MATRIX_SIZE, "Vector_product: vectors are not in R3");

    if (v1.isRow() != v2.isRow())
        REPORT_ERROR(ERR_MATRIX_SIZE,
                     "Vector_product: vectors are of different shape");

    Matrix1D<T> result(3);
    vectorProduct(v1, v2, result);
    return result;
}

vectorProduct() [2/2]

template<typename T >

void vectorProduct	(	const Matrix1D< T > &	v1,
		const Matrix1D< T > &	v2,
		Matrix1D< T > &	result
	)

Vector product in R3. This function computes the vector product of two R3 vectors. No check is performed, it is assumed that the output vector is already resized

Definition at line 1186 of file matrix1d.h.

{
    XX(result) = YY(v1) * ZZ(v2) - ZZ(v1) * YY(v2);
    YY(result) = ZZ(v1) * XX(v2) - XX(v1) * ZZ(v2);
    ZZ(result) = XX(v1) * YY(v2) - YY(v1) * XX(v2);
}

vectorR2()

Matrix1D<double> vectorR2	(	double	x,
		double	y
	)

Creates vector in R2. After this function the vector is (x,y) in R2.

Matrix1D< double > v = vectorR2(1, 2);

Definition at line 884 of file matrix1d.cpp.

{
    Matrix1D<double> result(2);
    VEC_ELEM(result, 0) = x;
    VEC_ELEM(result, 1) = y;
    return result;
}

vectorR3() [1/2]

Matrix1D<double> vectorR3	(	double	x,
		double	y,
		double	z
	)

Creates vector in R3. After this function the vector is (x,y,z) in R3.

Matrix1D< double > v = vectorR2(1, 2, 1);

Definition at line 892 of file matrix1d.cpp.

{
    Matrix1D<double> result(3);
    VEC_ELEM(result, 0) = x;
    VEC_ELEM(result, 1) = y;
    VEC_ELEM(result, 2) = z;
    return result;
}

vectorR3() [2/2]

Matrix1D<int> vectorR3	(	int	x,
		int	y,
		int	z
	)

Creates an integer vector in Z3.

Definition at line 901 of file matrix1d.cpp.

{
    Matrix1D<int> result(3);
    VEC_ELEM(result, 0) = x;
    VEC_ELEM(result, 1) = y;
    VEC_ELEM(result, 2) = z;
    return result;
}