Matrix2D< T > Class Template Reference

#include <mask.h>

Collaboration diagram for Matrix2D< T >:

Public Member Functions
Constructors
	Matrix2D ()
	Matrix2D (const FileName &fnMappedMatrix, int Ydim, int Xdim, size_t offset=0)
	Matrix2D (int Ydim, int Xdim)
	Matrix2D (const Matrix2D< T > &v)
	~Matrix2D ()
Matrix2D< T > &	operator= (const Matrix2D< T > &op1)
Core memory operations for Matrix2D
void	clear ()
void	convertTo (float out[3][3]) const
void	coreInit (const FileName &fn, int Ydim, int Xdim, size_t offset=0)
void	coreInit ()
void	coreAllocate (int _mdimy, int _mdimx)
void	coreDeallocate ()
Size and shape of Matrix2D
void	resize (size_t Ydim, size_t Xdim, bool noCopy=false)
template<typename T1 >
void	resize (const Matrix2D< T1 > &v)
void	resizeNoCopy (int Ydim, int Xdim)
template<typename T1 >
void	resizeNoCopy (const Matrix2D< T1 > &v)
void	mapToFile (const FileName &fn, int Ydim, int Xdim, size_t offset=0)
void	submatrix (int i0, int j0, int iF, int jF)
template<typename T1 >
bool	sameShape (const Matrix2D< T1 > &op) const
size_t	Xdim () const
size_t	Ydim () const
Initialization of Matrix2D values
void	initConstant (T val)
void	initConstant (size_t Ydim, size_t Xdim, T val)
void	initZeros ()
void	initZeros (size_t Ydim, size_t Xdim)
template<typename T1 >
void	initZeros (const Matrix2D< T1 > &op)
void	initRandom (size_t Ydim, size_t Xdim, double op1, double op2, RandomMode mode=RND_UNIFORM)
void	initGaussian (int Ydim, int Xdim, double op1=0., double op2=1.)
void	initIdentity ()
void	initIdentity (int dim)
void	initGaussian (int dim, double var)

Public Attributes
T *	mdata
bool	destroyData
bool	mappedData
int	fdMap
char *	mdataOriginal
size_t	mdimx
size_t	mdimy
size_t	mdim

Operators for Matrix2D
T &	operator() (int i, int j) const
void	setVal (T val, int y, int x)
T	getVal (int y, int x) const
Matrix2D< T >	operator* (T op1) const
Matrix2D< T >	operator/ (T op1) const
void	operator*= (T op1)
void	operator/= (T op1)
Matrix1D< T >	operator* (const Matrix1D< T > &op1) const
Matrix2D< T >	operator* (const Matrix2D< T > &op1) const
Matrix2D< T >	operator+ (const Matrix2D< T > &op1) const
void	operator+= (const Matrix2D< T > &op1) const
Matrix2D< T >	operator- (const Matrix2D< T > &op1) const
void	operator-= (const Matrix2D< T > &op1) const
bool	equal (const Matrix2D< T > &op, double accuracy=XMIPP_EQUAL_ACCURACY) const
bool	equalAbs (const Matrix2D< T > &op, double accuracy=XMIPP_EQUAL_ACCURACY) const
Matrix2D< T >	operator* (T op1, const Matrix2D< T > &op2)

Utilities for Matrix2D
T	computeMax () const
T	computeMin () const
void	computeMaxAndMin (T &maxValue, T &minValue) const
void	rowSum (Matrix1D< T > &sum) const
void	colSum (Matrix1D< T > &sum) const
void	rowEnergySum (Matrix1D< T > &sum) const
T **	adaptForNumericalRecipes () const
T *	adaptForNumericalRecipes2 () const
void	loadFromNumericalRecipes (T **m, int Ydim, int Xdim)
void	killAdaptationForNumericalRecipes (T **m) const
void	killAdaptationForNumericalRecipes2 (T **m) const
void	read (const FileName &fn)
void	write (const FileName &fn) const
void	fromVector (const Matrix1D< T > &op1)
void	toVector (Matrix1D< T > &op1) const
void	copyToVector (std::vector< T > &v)
void	copyFromVector (std::vector< T > &v, int Xdim, int Ydim)
void	getRow (size_t i, Matrix1D< T > &v) const
void	getCol (size_t j, Matrix1D< T > &v) const
void	setRow (size_t i, const Matrix1D< T > &v)
void	setCol (size_t j, const Matrix1D< T > &v)
void	computeRowMeans (Matrix1D< double > &Xmr) const
void	computeColMeans (Matrix1D< double > &Xmr) const
void	setConstantCol (size_t j, T v)
void	getDiagonal (Matrix1D< T > &d) const
T	trace () const
T	det () const
T	det3x3 () const
	determinat of 3x3 matrix More...
double	norm ()
Matrix2D< T >	transpose () const
void	inv (Matrix2D< T > &result) const
void	invAlgLib (Matrix2D< T > &result, bool use_lu=false) const
void	svd (Matrix2D< double > &U, Matrix1D< double > &W, Matrix2D< double > &V) const
void	eigs (Matrix2D< double > &U, Matrix1D< double > &W, Matrix2D< double > &V, Matrix1D< int > &indexes) const
Matrix2D< T >	inv () const
void	selfInverse ()
bool	isIdentity () const
std::ostream &	operator<< (std::ostream &ostrm, const Matrix2D< T > &v)

Detailed Description

template<typename T>
class Matrix2D< T >

Matrix2D class

Definition at line 36 of file mask.h.

Constructor & Destructor Documentation

Matrix2D() [1/4]

template<typename T>

Matrix2D< T >::Matrix2D ( )

inline

Empty constructor

Definition at line 423 of file matrix2d.h.

    {
        coreInit();
    }

Matrix2D() [2/4]

template<typename T>

Matrix2D< T >::Matrix2D ( const FileName &  fnMappedMatrix, int  Ydim, int  Xdim, size_t  offset = 0  )

inline

Definition at line 428 of file matrix2d.h.

    {
        coreInit(fnMappedMatrix,Ydim,Xdim,offset);
    }

Matrix2D() [3/4]

template<typename T>

Matrix2D< T >::Matrix2D ( int  Ydim, int  Xdim  )

inline

Dimension constructor

Definition at line 435 of file matrix2d.h.

    {
        coreInit();
        initZeros(Ydim, Xdim);
    }

Matrix2D() [4/4]

template<typename T>

Matrix2D< T >::Matrix2D ( const Matrix2D< T > &  v )

inline

Copy constructor

Definition at line 443 of file matrix2d.h.

    {
        coreInit();
        *this = v;
    }

~Matrix2D()

template<typename T>

Matrix2D< T >::~Matrix2D ( )

inline

Destructor.

Definition at line 451 of file matrix2d.h.

    {
        coreDeallocate();
    }

Member Function Documentation

adaptForNumericalRecipes()

template<typename T >

T ** Matrix2D< T >::adaptForNumericalRecipes

(

)

const

Produce a 2D array suitable for working with Numerical Recipes

This function must be used only as a preparation for routines which need that the first physical index is 1 and not 0 as it usually is in C. New memory is needed to hold the new double pointer array.

Definition at line 1280 of file matrix2d.cpp.

{
   T** m = NULL;
   ask_Tmatrix(m, 1, mdimy, 1, mdimx);

   for (int i = 0; i < mdimy; i++)
       for (int j = 0; j < mdimx; j++)
           m[i+1][j+1] = mdata[i*mdimx + j];

   return m;
}

adaptForNumericalRecipes2()

template<typename T>

T* Matrix2D< T >::adaptForNumericalRecipes2 ( ) const

inline

Produce a 1D pointer suitable for working with Numerical Recipes (2)

This function meets the same goal as the one before, however this one work with 2D arrays as a single pointer. The first element of the array is pointed by result[1*Xdim+1], and in general result[i*Xdim+j]

Definition at line 875 of file matrix2d.h.

    {
        return mdata - 1 - mdimx;
    }

clear()

template<typename T>

void Matrix2D< T >::clear ( )

inline

Clear.

Definition at line 473 of file matrix2d.h.

    {
        coreDeallocate();
        coreInit();
    }

colSum()

template<typename T>

void Matrix2D< T >::colSum

(

Matrix1D< T > &

sum

)

const

Get column sum.

Definition at line 787 of file matrix2d.cpp.

{
    sum.initZeros(MAT_XSIZE(*this));
    FOR_ALL_ELEMENTS_IN_MATRIX2D(*this)
        VEC_ELEM(sum,j)+=MAT_ELEM(*this,i,j);
}

computeColMeans()

template<typename T >

void Matrix2D< T >::computeColMeans

(

Matrix1D< double > &

Xmr

)

const

Compute row means

Definition at line 613 of file matrix2d.cpp.

{
    Xmr.initZeros(MAT_YSIZE(*this));
    FOR_ALL_ELEMENTS_IN_MATRIX2D(*this)
        VEC_ELEM(Xmr,j)+=MAT_ELEM(*this,i,j);
    Xmr*=1.0/MAT_YSIZE(*this);
 }

computeMax()

template<typename T >

T Matrix2D< T >::computeMax

(

)

const

Maximum of the values in the array.

The returned value is of the same type as the type of the array.

Definition at line 1236 of file matrix2d.cpp.

{
   if (mdim <= 0)
       return static_cast< T >(0);

   T maxval = mdata[0];
   for (size_t n = 0; n < mdim; n++)
       if (mdata[n] > maxval)
           maxval = mdata[n];
   return maxval;
}

computeMaxAndMin()

template<typename T>

void Matrix2D< T >::computeMaxAndMin	(	T &	maxValue,
		T &	minValue
	)		const

Maximum and minimum of the values in the array.

Definition at line 1262 of file matrix2d.cpp.

{
   maxValue=minValue=0;
   if (mdim <= 0)
       return;

   maxValue = minValue = mdata[0];
   for (size_t n = 0; n < mdim; n++)
   {
       T val=mdata[n];
       if (val < minValue)
           minValue = val;
       else if (val > maxValue)
           maxValue = val;
   }
}

computeMin()

template<typename T >

T Matrix2D< T >::computeMin

(

)

const

Minimum of the values in the array.

The returned value is of the same type as the type of the array.

Definition at line 1249 of file matrix2d.cpp.

{
   if (mdim <= 0)
       return static_cast< T >(0);

   T minval = mdata[0];
   for (size_t n = 0; n < mdim; n++)
       if (mdata[n] < minval)
           minval = mdata[n];
   return minval;
}

computeRowMeans()

template<typename T >

void Matrix2D< T >::computeRowMeans

(

Matrix1D< double > &

Xmr

)

const

Compute row means

Definition at line 604 of file matrix2d.cpp.

{
    Xmr.initZeros(MAT_YSIZE(*this));
    FOR_ALL_ELEMENTS_IN_MATRIX2D(*this)
        VEC_ELEM(Xmr,i)+=MAT_ELEM(*this,i,j);
    Xmr*=1.0/MAT_XSIZE(*this);
}

convertTo()

template<typename T>

void Matrix2D< T >::convertTo ( float  out[3][3] ) const

inline

Method will convert Matrix2D matrix to float[3][3]

Definition at line 480 of file matrix2d.h.

                                                 {
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                out[i][j] = (*this)(i, j);
            }
        }
    }

copyFromVector()

template<typename T>

void Matrix2D< T >::copyFromVector ( std::vector< T > &  v, int  Xdim, int  Ydim  )

inline

Copy stl::vector to matrix

Definition at line 966 of file matrix2d.h.

    {
        if (mdimx!=Xdim || mdimy!=Ydim)
            resizeNoCopy(Ydim, Xdim);
        copy( v.begin(), v.begin()+v.size(), mdata);
    }

copyToVector()

template<typename T>

void Matrix2D< T >::copyToVector ( std::vector< T > &  v )

inline

Copy matrix to stl::vector

Definition at line 960 of file matrix2d.h.

    {
        v.assign(mdata, mdata+mdim);
    }

coreAllocate()

template<typename T >

void Matrix2D< T >::coreAllocate	(	int	_mdimy,
		int	_mdimx
	)

Core allocate.

Definition at line 982 of file matrix2d.cpp.

{
   if (_mdimy <= 0 ||_mdimx<=0)
   {
       clear();
       return;
   }

   mdimx=_mdimx;
   mdimy=_mdimy;
   mdim=_mdimx*_mdimy;
   mdata = new T [mdim];
   mdataOriginal = NULL;
   mappedData=false;
   fdMap=-1;
   if (mdata == NULL)
       REPORT_ERROR(ERR_MEM_NOTENOUGH, "coreAllocate: No space left");
}

coreDeallocate()

template<typename T >

void Matrix2D< T >::coreDeallocate

(

)

Core deallocate. Free all mdata.

Definition at line 1002 of file matrix2d.cpp.

{
   if (mdata != NULL && destroyData)
       delete[] mdata;
   if (mappedData)
   {
#ifdef XMIPP_MMAP
       munmap(mdataOriginal,mdimx*mdimy*sizeof(T));
       close(fdMap);
#else

       REPORT_ERROR(ERR_MMAP,"Mapping not supported in Windows");
#endif

   }
   mdata=NULL;
   mdataOriginal=NULL;
}

coreInit() [1/2]

template<typename T >

void Matrix2D< T >::coreInit	(	const FileName &	fn,
		int	Ydim,
		int	Xdim,
		size_t	offset = 0
	)

Core init from mapped file. Offset is in bytes.

Definition at line 75 of file matrix2d.cpp.

{
#ifdef XMIPP_MMAP

    mdimx=Xdim;
    mdimy=Ydim;
    mdim=mdimx*mdimy;
    destroyData=false;
    mappedData=true;
    fdMap = open(fn.c_str(),  O_RDWR, S_IREAD | S_IWRITE);
    if (fdMap == -1)
        REPORT_ERROR(ERR_IO_NOTOPEN,fn);
    const size_t pagesize=sysconf(_SC_PAGESIZE);
    size_t offsetPages=(offset/pagesize)*pagesize;
    size_t offsetDiff=offset-offsetPages;
    if ( (mdataOriginal = (char*) mmap(0,Ydim*Xdim*sizeof(T)+offsetDiff, PROT_READ | PROT_WRITE, MAP_SHARED, fdMap, offsetPages)) == MAP_FAILED )
        REPORT_ERROR(ERR_MMAP_NOTADDR,(String)"mmap failed "+integerToString(errno));
    mdata=(T*)(mdataOriginal+offsetDiff);
#else

    REPORT_ERROR(ERR_MMAP,"Mapping not supported in Windows");
#endif

}

coreInit() [2/2]

template<typename T >

void Matrix2D< T >::coreInit

(

)

Core init. Initialize everything to 0

Definition at line 971 of file matrix2d.cpp.

{
   mdimx=mdimy=mdim=0;
   mdata=NULL;
   mdataOriginal=NULL;
   destroyData=true;
   mappedData=false;
   fdMap=-1;
}

det()

template<typename T >

T Matrix2D< T >::det

(

)

const

Determinant of a matrix

An exception is thrown if the matrix is not squared or it is empty.

double det = m.det();

Definition at line 38 of file matrix2d.cpp.

{
    // (see Numerical Recipes, Chapter 2 Section 5)
    if (mdimx == 0 || mdimy == 0)
        REPORT_ERROR(ERR_MATRIX_EMPTY, "determinant: Matrix is empty");

    if (mdimx != mdimy)
        REPORT_ERROR(ERR_MATRIX_SIZE, "determinant: Matrix is not squared");

    for (size_t i = 0; i < mdimy; i++)
    {
        bool all_zeros = true;
        for (size_t j = 0; j < mdimx; j++)
            if (fabs(MAT_ELEM((*this),i, j)) > XMIPP_EQUAL_ACCURACY)
            {
                all_zeros = false;
                break;
            }

        if (all_zeros)
            return 0;
    }

    // Perform decomposition
    Matrix1D< int > indx;
    T d;
    Matrix2D<T> LU;
    ludcmp(*this, LU, indx, d);

    // Calculate determinant
    for (size_t i = 0; i < mdimx; i++)
        d *= (T) MAT_ELEM(LU,i , i);

    return d;
}

det3x3()

template<typename T>

T Matrix2D< T >::det3x3 ( ) const

inline

determinat of 3x3 matrix

Definition at line 1061 of file matrix2d.h.

    {
        return (
                   dMij(*this,0,0)*( dMij(*this,2,2)*dMij(*this,1,1)-
                                     dMij(*this,2,1)*dMij(*this,1,2) )-
                   dMij(*this,1,0)*( dMij(*this,2,2)*dMij(*this,0,1)-
                                     dMij(*this,2,1)*dMij(*this,0,2) )+
                   dMij(*this,2,0)*( dMij(*this,1,2)*dMij(*this,0,1)-
                                     dMij(*this,1,1)*dMij(*this,0,2) )
               );
    }

eigs()

template<typename T >

void Matrix2D< T >::eigs	(	Matrix2D< double > &	U,
		Matrix1D< double > &	W,
		Matrix2D< double > &	V,
		Matrix1D< int > &	indexes
	)		const

Perform SVD decomposition and add an index vector with the descending order of singular values

Definition at line 719 of file matrix2d.cpp.

{
  svdcmp(*this, U, W, V);
  indexes.resizeNoCopy(W);
  indexes.enumerate();

  double dAux;
  int iAux;

  FOR_ALL_ELEMENTS_IN_MATRIX1D(W)
  {
      for (int j = i; j > 0 && dMi(W, j) > dMi(W, j-1); --j)
      {
        VEC_SWAP(W, j, j-1, dAux);
        VEC_SWAP(indexes, j, j-1, iAux);
      }
  }
}

equal()

template<typename T>

bool Matrix2D< T >::equal	(	const Matrix2D< T > &	op,
		double	accuracy = XMIPP_EQUAL_ACCURACY
	)		const

Equality.

Returns true if this object has got the same shape (origin and size) than the argument and the same values (within accuracy).

Definition at line 1202 of file matrix2d.cpp.

{
   if (!sameShape(op))
       return false;
   for (size_t i = 0; i < mdimy; i++)
       for (size_t j = 0; j < mdimx; j++)
           if (fabs( MAT_ELEM(*this,i,j) - MAT_ELEM(op,i,j) ) > accuracy)
           {
               //std::cerr << "DEBUG_ROB: MAT_ELEM(*this,i,j): " << MAT_ELEM(*this,i,j) << std::endl;
               //std::cerr << "DEBUG_ROB: MAT_ELEM(op,i,j): " << MAT_ELEM(op,i,j) << std::endl;
               return false;
           }
   return true;
}

equalAbs()

template<typename T>

bool Matrix2D< T >::equalAbs	(	const Matrix2D< T > &	op,
		double	accuracy = XMIPP_EQUAL_ACCURACY
	)		const

Equality.

Returns true if this object has got the same shape (origin and size) than the argument and the same values (within accuracy and without SIGN).

Definition at line 1219 of file matrix2d.cpp.

{
   if (!sameShape(op))
       return false;
   for (size_t i = 0; i < mdimy; i++)
       for (size_t j = 0; j < mdimx; j++)
           if ( (fabs( MAT_ELEM(*this,i,j)) - fabs(MAT_ELEM(op,i,j)) )> accuracy)
           {
               //std::cerr << "DEBUG_ROB: MAT_ELEM(*this,i,j): " << MAT_ELEM(*this,i,j) << std::endl;
               //std::cerr << "DEBUG_ROB: MAT_ELEM(op,i,j): " << MAT_ELEM(op,i,j) << std::endl;
               return false;
           }
   return true;
}

fromVector()

template<typename T>

void Matrix2D< T >::fromVector

(

const Matrix1D< T > &

op1

)

Makes a matrix from a vector

The origin of the matrix is set such that it has one of the index origins (X or Y) to the same value as the vector, and the other set to 0 according to the shape.

Matrix2D< double > m = fromVector(v);

Definition at line 803 of file matrix2d.cpp.

{
    // Null vector => Null matrix
    if (op1.size() == 0)
    {
        clear();
        return;
    }

    // Look at shape and copy values
    if (op1.isRow())
    {
        if (mdimy!=1 || mdimx!=VEC_XSIZE(op1))
            resizeNoCopy(1, VEC_XSIZE(op1));

        for (size_t j = 0; j < VEC_XSIZE(op1); j++)
            MAT_ELEM(*this,0, j) = VEC_ELEM(op1,j);
    }
    else
    {
        if (mdimy!=1 || mdimx!=VEC_XSIZE(op1))
            resizeNoCopy(VEC_XSIZE(op1), 1);

        for (size_t i = 0; i < VEC_XSIZE(op1); i++)
            MAT_ELEM(*this, i, 0) = VEC_ELEM(op1,i);
    }
}

getCol()

template<typename T>

void Matrix2D< T >::getCol	(	size_t	j,
		Matrix1D< T > &	v
	)		const

Get Column

This function returns a column vector corresponding to the chosen column.

std::vector< double > v;
m.getCol(-1, v);

Definition at line 890 of file matrix2d.cpp.

{
    if (mdimx == 0 || mdimy == 0)
    {
        v.clear();
        return;
    }

    if (j >= mdimx)
        REPORT_ERROR(ERR_INDEX_OUTOFBOUNDS,"getCol: Matrix subscript (j) greater than matrix dimension");

    if (VEC_XSIZE(v)!=mdimy)
        v.resizeNoCopy(mdimy);
    for (size_t i = 0; i < mdimy; i++)
        VEC_ELEM(v,i) = MAT_ELEM(*this,i, j);

    v.setCol();
}

getDiagonal()

template<typename T>

void Matrix2D< T >::getDiagonal

(

Matrix1D< T > &

d

)

const

Get diagonal. It is assumed that the matrix is squared

Definition at line 949 of file matrix2d.cpp.

{
    d.resizeNoCopy(MAT_XSIZE(*this));
    for (size_t i=0; i<MAT_XSIZE(*this); ++i)
        VEC_ELEM(d,i)=MAT_ELEM(*this,i,i);
}

getRow()

template<typename T>

void Matrix2D< T >::getRow	(	size_t	i,
		Matrix1D< T > &	v
	)		const

Get row

This function returns a row vector corresponding to the chosen row inside the nth 2D matrix, the numbering of the rows is also logical not physical.

std::vector< double > v;
m.getRow(-2, v);

Definition at line 871 of file matrix2d.cpp.

{
    if (mdimx == 0 || mdimy == 0)
    {
        v.clear();
        return;
    }

    if (i >= mdimy)
        REPORT_ERROR(ERR_INDEX_OUTOFBOUNDS, "getRow: Matrix subscript (i) greater than matrix dimension");

    if (VEC_XSIZE(v)!=mdimx)
        v.resizeNoCopy(mdimx);
    memcpy(&VEC_ELEM(v,0),&MAT_ELEM(*this,i,0),mdimx*sizeof(T));

    v.setRow();
}

getVal()

template<typename T>

T Matrix2D< T >::getVal ( int  y, int  x  ) const

inline

Parenthesis operator for phyton

Definition at line 720 of file matrix2d.h.

    {
        return MAT_ELEM((*this),y,x);
    }

initConstant() [1/2]

template<typename T>

void Matrix2D< T >::initConstant ( T  val )

inline

Same value in all components.

The constant must be of a type compatible with the array type, ie, you cannot assign a double to an integer array without a casting. It is not an error if the array is empty, then nothing is done.

v.initConstant(3.14);

Definition at line 602 of file matrix2d.h.

    {
        for (size_t j = 0; j < mdim; j++)
            mdata[j] = val;
    }

initConstant() [2/2]

template<typename T>

void Matrix2D< T >::initConstant ( size_t  Ydim, size_t  Xdim, T  val  )

inline

Initialize to zeros with a given size.

Definition at line 610 of file matrix2d.h.

    {
        if (mdimx!=Xdim || mdimy!=Ydim)
            resizeNoCopy(Ydim, Xdim);
        initConstant(val);
    }

initGaussian() [1/2]

template<typename T >

void Matrix2D< T >::initGaussian	(	int	Ydim,
		int	Xdim,
		double	op1 = 0.,
		double	op2 = 1.
	)

Initialize to gaussian numbers

Definition at line 1118 of file matrix2d.cpp.

{
 initRandom(Ydim, Xdim, op1, op2, RND_GAUSSIAN);
}

initGaussian() [2/2]

template<typename T >

void Matrix2D< T >::initGaussian	(	int	dim,
		double	var
	)

2D gaussian matrix of a given size and with a given variance. The amplitude of the Gaussian is set to 1.

A (dim x dim) gaussian matrix is generated.

m.initGaussian(3,1);

Definition at line 1125 of file matrix2d.cpp.

{
   double center = ((double)dim)/2;
   initZeros(dim, dim);
   for (int i = 0; i < dim; i++)
       for (int j = 0; j < dim; j++)
           MAT_ELEM(*this,i,j) = std::exp(-( (i-center)*(i-center)+(j-center)*(j-center) )/(2*var*var));
}

initIdentity() [1/2]

template<typename T>

void Matrix2D< T >::initIdentity ( )

inline

2D Identity matrix of current size

If actually the matrix is not squared then an identity matrix is generated of size (Xdim x Xdim).

m.initIdentity();

Definition at line 673 of file matrix2d.h.

    {
        initIdentity(MAT_XSIZE(*this));
    }

initIdentity() [2/2]

template<typename T>

void Matrix2D< T >::initIdentity ( int  dim )

inline

2D Identity matrix of a given size

A (dim x dim) identity matrix is generated.

m.initIdentity(3);

Definition at line 686 of file matrix2d.h.

    {
        initZeros(dim, dim);
        for (int i = 0; i < dim; i++)
            MAT_ELEM(*this,i,i) = 1;
    }

initRandom()

template<typename T >

void Matrix2D< T >::initRandom	(	size_t	Ydim,
		size_t	Xdim,
		double	op1,
		double	op2,
		RandomMode	mode = RND_UNIFORM
	)

Initialize to random random numbers, uniform or gaussian

Definition at line 1108 of file matrix2d.cpp.

{
   if (mdimx!=Xdim || mdimy!=Ydim)
       resizeNoCopy(Ydim, Xdim);
   for (size_t j = 0; j < mdim; j++)
      mdata[j] = static_cast< T > (mode == RND_UNIFORM ? rnd_unif(op1, op2) : rnd_gaus(op1, op2));
}

initZeros() [1/3]

template<typename T>

void Matrix2D< T >::initZeros ( )

inline

Initialize to zeros with current size.

All values are set to 0. The current size and origin are kept. It is not an error if the array is empty, then nothing is done.

v.initZeros();

Definition at line 626 of file matrix2d.h.

    {
        memset(mdata,0,mdimx*mdimy*sizeof(T));
    }

initZeros() [2/3]

template<typename T>

void Matrix2D< T >::initZeros ( size_t  Ydim, size_t  Xdim  )

inline

Initialize to zeros with a given size.

Definition at line 633 of file matrix2d.h.

    {
        if (mdimx!=Xdim || mdimy!=Ydim)
            resizeNoCopy(Ydim, Xdim);
        memset(mdata,0,mdimx*mdimy*sizeof(T));
    }

initZeros() [3/3]

template<typename T>

template<typename T1 >

void Matrix2D< T >::initZeros ( const Matrix2D< T1 > &  op )

inline

Initialize to zeros following a pattern.

All values are set to 0, and the origin and size of the pattern are adopted.

v2.initZeros(v1);

Definition at line 650 of file matrix2d.h.

    {
        if (mdimx!=op.mdimx || mdimy!=op.mdimy)
            resizeNoCopy(op);
        memset(mdata,0,mdimx*mdimy*sizeof(T));
    }

inv() [1/2]

template<typename T>

void Matrix2D< T >::inv

(

Matrix2D< T > &

result

)

const

Inverse of a matrix

The matrix is inverted using a SVD decomposition. In fact the pseudoinverse is returned.

Matrix2D< double > m1_inv;
m1.inv(m1_inv);

Definition at line 663 of file matrix2d.cpp.

{
    if (mdimx == 0 || mdimy == 0)
        REPORT_ERROR(ERR_MATRIX_EMPTY, "Inverse: Matrix is empty");
    result.initZeros(mdimx, mdimy);
    SPEED_UP_temps0;
    if (mdimx==2)
    {
        M2x2_INV(result,*this);
    }
    else if (mdimx==3)
    {
        M3x3_INV(result,*this);
    }
    else if (mdimx==4)
    {
        M4x4_INV(result,*this);
    }
    else
    {
        // Perform SVD decomposition
        Matrix2D< double > u, v;
        Matrix1D< double > w;
        svdcmp(*this, u, w, v); // *this = U * W * V^t

        double tol = computeMax() * XMIPP_MAX(mdimx, mdimy) * 1e-14;

        // Compute W^-1
        bool invertible = false;
        FOR_ALL_ELEMENTS_IN_MATRIX1D(w)
        {
            if (fabs(VEC_ELEM(w,i)) > tol)
            {
                VEC_ELEM(w,i) = 1.0 / VEC_ELEM(w,i);
                invertible = true;
            }
            else
                VEC_ELEM(w,i) = 0.0;
        }

        if (!invertible)
            return;

        // Compute V*W^-1
        FOR_ALL_ELEMENTS_IN_MATRIX2D(v)
        MAT_ELEM(v,i,j) *= VEC_ELEM(w,j);

        // Compute Inverse
        for (size_t i = 0; i < mdimx; i++)
            for (size_t j = 0; j < mdimy; j++)
                for (size_t k = 0; k < mdimx; k++)
                    MAT_ELEM(result,i,j) += MAT_ELEM(v,i,k) * MAT_ELEM(u,j,k);
    }
}

inv() [2/2]

template<typename T>

Matrix2D<T> Matrix2D< T >::inv ( ) const

inline

Inverse of a matrix

Definition at line 1136 of file matrix2d.h.

    {
        Matrix2D<T> result;
        inv(result);

        return result;
    }

invAlgLib()

template<typename T>

void Matrix2D< T >::invAlgLib	(	Matrix2D< T > &	result,
		bool	use_lu = false
	)		const

Inverse of a matrix

The matrix is inverted using a AlgLib. Set LU to use LU decomposition

Matrix2D< double > m1_inv;
m1.inv(m1_inv);

isIdentity()

template<typename T >

bool Matrix2D< T >::isIdentity

(

)

const

True if the matrix is identity

if (m.isIdentity())
    std::cout << "The matrix is identity\n";

Definition at line 1323 of file matrix2d.cpp.

{
   for (size_t i = 0; i < mdimy; i++)
       for (size_t j = 0; j < mdimx; j++)
           if (i != j)
           {
               if (MAT_ELEM(*this,i,j)!=0)
                   return false;
           }
           else
           {
               if (MAT_ELEM(*this,i,j)!=1)
                   return false;
           }
   return true;
}

killAdaptationForNumericalRecipes()

template<typename T>

void Matrix2D< T >::killAdaptationForNumericalRecipes ( T **  m ) const

inline

Kill a 2D array produced for numerical recipes

The allocated memory is freed.

Definition at line 888 of file matrix2d.h.

    {
        free_Tmatrix(m, 1, mdimy, 1, mdimx);
    }

killAdaptationForNumericalRecipes2()

template<typename T>

void Matrix2D< T >::killAdaptationForNumericalRecipes2 ( T **  m ) const

inline

Kill a 2D array produced for numerical recipes, 2.

Nothing needs to be done.

Definition at line 897 of file matrix2d.h.

        {}

loadFromNumericalRecipes()

template<typename T>

void Matrix2D< T >::loadFromNumericalRecipes	(	T **	m,
		int	Ydim,
		int	Xdim
	)

Load 2D array from numerical recipes result.

Definition at line 1293 of file matrix2d.cpp.

{
   if (mdimx!=Xdim || mdimy!=Ydim)
       resizeNoCopy(Ydim, Xdim);

   for (int i = 1; i <= Ydim; i++)
       for (int j = 1; j <= Xdim; j++)
           MAT_ELEM(*this,i - 1, j - 1) = m[i][j];
}

mapToFile()

template<typename T >

void Matrix2D< T >::mapToFile	(	const FileName &	fn,
		int	Ydim,
		int	Xdim,
		size_t	offset = 0
	)

Map to file. The matrix is mapped to a file. The file is presumed to be already created with enough space for a matrix of size Ydim x Xdim. Offset is in bytes.

Definition at line 1079 of file matrix2d.cpp.

{
   if (mdata!=NULL)
       clear();

#ifdef XMIPP_MMAP

   coreInit(fn,Ydim,Xdim,offset);
#else

   resizeNoCopy(Ydim, Xdim);
#endif

}

norm()

template<typename T>

double Matrix2D< T >::norm ( )

inline

Frobenius norm of a matrix

Definition at line 1074 of file matrix2d.h.

    {
        double sum=0.;
        FOR_ALL_ELEMENTS_IN_MATRIX2D(*this)
        {
            T aux=MAT_ELEM(*this,i,j);
            sum+=aux*aux;
        }
        return sqrt(sum);
    }

operator()()

template<typename T>

T& Matrix2D< T >::operator() ( int  i, int  j  ) const

inline

Matrix element access

Definition at line 708 of file matrix2d.h.

    {
        return MAT_ELEM((*this),i,j);
    }

operator*() [1/3]

template<typename T>

Matrix2D<T> Matrix2D< T >::operator* ( T  op1 ) const

inline

v3 = v1 * k.

Definition at line 727 of file matrix2d.h.

    {
        Matrix2D<T> tmp(*this);
        for (size_t i=0; i < mdim; i++)
            tmp.mdata[i] = mdata[i] * op1;
        return tmp;
    }

operator*() [2/3]

template<typename T>

Matrix1D< T > Matrix2D< T >::operator*

(

const Matrix1D< T > &

op1

)

const

Matrix by vector multiplication

v2 = A*v1;

Definition at line 759 of file matrix2d.cpp.

{
    Matrix1D<T> result;

    if (mdimx != VEC_XSIZE(op1))
        REPORT_ERROR(ERR_MATRIX_SIZE, "Not compatible sizes in matrix by vector");

    if (!op1.isCol())
        REPORT_ERROR(ERR_MATRIX, "Vector is not a column");

    result.initZeros(mdimy);
    for (size_t i = 0; i < mdimy; i++)
        for (size_t j = 0; j < mdimx; j++)
            VEC_ELEM(result,i) += MAT_ELEM(*this,i, j) * VEC_ELEM(op1,j);

    result.setCol();
    return result;
}

operator*() [3/3]

template<typename T>

Matrix2D< T > Matrix2D< T >::operator*

(

const Matrix2D< T > &

op1

)

const

Matrix by Matrix multiplication

C = A*B;

Definition at line 1135 of file matrix2d.cpp.

{
   Matrix2D<T> result;
   if (mdimx != op1.mdimy)
       REPORT_ERROR(ERR_MATRIX_SIZE, "Not compatible sizes in matrix multiplication");

   result.initZeros(mdimy, op1.mdimx);
   for (size_t i = 0; i < mdimy; i++)
       for (size_t j = 0; j < op1.mdimx; j++)
           for (size_t k = 0; k < mdimx; k++)
               MAT_ELEM(result,i, j) += MAT_ELEM(*this,i, k) * MAT_ELEM(op1, k, j);
   return result;
}

operator*=()

template<typename T>

void Matrix2D< T >::operator*= ( T  op1 )

inline

v3 *= k.

Definition at line 757 of file matrix2d.h.

    {
        for (size_t i=0; i < mdim; i++)
            mdata[i] *= op1;
    }

operator+()

template<typename T>

Matrix2D< T > Matrix2D< T >::operator+

(

const Matrix2D< T > &

op1

)

const

Matrix summation

C = A + B;

Definition at line 1150 of file matrix2d.cpp.

{
   Matrix2D<T> result;
   if (mdimx != op1.mdimx || mdimy != op1.mdimy)
       REPORT_ERROR(ERR_MATRIX_SIZE, "operator+: Not same sizes in matrix summation");

   result.initZeros(mdimy, mdimx);
   for (size_t i = 0; i < mdimy; i++)
       for (size_t j = 0; j < mdimx; j++)
           result(i, j) = (*this)(i, j) + op1(i, j);

   return result;
}

operator+=()

template<typename T>

void Matrix2D< T >::operator+=

(

const Matrix2D< T > &

op1

)

const

Matrix summation

A += B;

Definition at line 1165 of file matrix2d.cpp.

{
   if (mdimx != op1.mdimx || mdimy != op1.mdimy)
       REPORT_ERROR(ERR_MATRIX_SIZE, "operator+=: Not same sizes in matrix summation");

   for (size_t i = 0; i < mdimy; i++)
       for (size_t j = 0; j < mdimx; j++)
           MAT_ELEM(*this,i, j) += MAT_ELEM(op1, i, j);
}

operator-()

template<typename T>

Matrix2D< T > Matrix2D< T >::operator-

(

const Matrix2D< T > &

op1

)

const

Matrix subtraction

C = A - B;

Definition at line 1176 of file matrix2d.cpp.

{
   Matrix2D<T> result;
   if (mdimx != op1.mdimx || mdimy != op1.mdimy)
       REPORT_ERROR(ERR_MATRIX_SIZE, "operator-: Not same sizes in matrix summation");

   result.initZeros(mdimy, mdimx);
   for (size_t i = 0; i < mdimy; i++)
       for (size_t j = 0; j < mdimx; j++)
           result(i, j) = (*this)(i, j) - op1(i, j);

   return result;
}

operator-=()

template<typename T>

void Matrix2D< T >::operator-=

(

const Matrix2D< T > &

op1

)

const

Matrix subtraction

A -= B;

Definition at line 1191 of file matrix2d.cpp.

{
   if (mdimx != op1.mdimx || mdimy != op1.mdimy)
       REPORT_ERROR(ERR_MATRIX_SIZE, "operator-=: Not same sizes in matrix summation");

   for (size_t i = 0; i < mdimy; i++)
       for (size_t j = 0; j < mdimx; j++)
           MAT_ELEM(*this,i, j) -= MAT_ELEM(op1, i, j);
}

operator/()

template<typename T>

Matrix2D<T> Matrix2D< T >::operator/ ( T  op1 ) const

inline

v3 = v1 / k.

Definition at line 737 of file matrix2d.h.

    {
        Matrix2D<T> tmp(*this);
        for (size_t i=0; i < mdim; i++)
            tmp.mdata[i] = mdata[i] / op1;
        return tmp;
    }

operator/=()

template<typename T>

void Matrix2D< T >::operator/= ( T  op1 )

inline

v3 /= k.

Definition at line 765 of file matrix2d.h.

    {
        for (size_t i=0; i < mdim; i++)
            mdata[i] /= op1;
    }

operator=()

template<typename T>

Matrix2D< T > & Matrix2D< T >::operator=

(

const Matrix2D< T > &

op1

)

Assignment.

You can build as complex assignment expressions as you like. Multiple assignment is allowed.

v1 = v2 + v3;
v1 = v2 = v3;

Definition at line 957 of file matrix2d.cpp.

{
   if (&op1 != this)
   {
       if (MAT_XSIZE(*this)!=MAT_XSIZE(op1) ||
           MAT_YSIZE(*this)!=MAT_YSIZE(op1))
           resizeNoCopy(op1);
       memcpy(mdata,op1.mdata,op1.mdim*sizeof(T));
   }

   return *this;
}

read()

template<typename T >

void Matrix2D< T >::read

(

const FileName &

fn

)

Read this matrix from file. The matrix is assumed to be already resized.

Definition at line 101 of file matrix2d.cpp.

{
    std::ifstream fhIn;
    fhIn.open(fn.c_str());
    if (!fhIn)
        REPORT_ERROR(ERR_IO_NOTEXIST,fn);
    FOR_ALL_ELEMENTS_IN_MATRIX2D(*this)
    fhIn >> MAT_ELEM(*this,i,j);
    fhIn.close();
}

resize() [1/2]

template<typename T >

void Matrix2D< T >::resize	(	size_t	Ydim,
		size_t	Xdim,
		bool	noCopy = false
	)

Resize to a given size

Definition at line 1022 of file matrix2d.cpp.

{

   if (Xdim == mdimx && Ydim == mdimy)
       return;

   if (Xdim <= 0 || Ydim <= 0)
   {
       clear();
       return;
   }

   T * new_mdata;
   size_t YXdim=Ydim*Xdim;

   try
   {
       new_mdata = new T [YXdim];
   }
   catch (std::bad_alloc &)
   {
       REPORT_ERROR(ERR_MEM_NOTENOUGH, "Allocate: No space left");
   }

   // Copy needed elements, fill with 0 if necessary
   if (!noCopy)
   {
       T zero=0; // Useful for complexes
       for (size_t i = 0; i < Ydim; i++)
           for (size_t j = 0; j < Xdim; j++)
           {
               T *val=NULL;
               if (i >= mdimy)
                   val = &zero;
               else if (j >= mdimx)
                   val = &zero;
               else
                   val = &mdata[i*mdimx + j];
               new_mdata[i*Xdim+j] = *val;
           }
   }
   else
       memset(new_mdata,0,YXdim*sizeof(T));

   // deallocate old vector
   coreDeallocate();

   // assign *this vector to the newly created
   mdata = new_mdata;
   mdimx = Xdim;
   mdimy = Ydim;
   mdim = Xdim * Ydim;
   mappedData = false;
}

resize() [2/2]

template<typename T>

template<typename T1 >

void Matrix2D< T >::resize ( const Matrix2D< T1 > &  v )

inline

Resize according to a pattern.

This function resize the actual array to the same size and origin as the input pattern. If the actual array is larger than the pattern then the trailing values are lost, if it is smaller then 0's are added at the end

v2.resize(v1);
// v2 has got now the same structure as v1

Definition at line 526 of file matrix2d.h.

    {
        if (mdimx != v.mdimx || mdimy != v.mdimy)
            resize(v.mdimy, v.mdimx);
    }

resizeNoCopy() [1/2]

template<typename T>

void Matrix2D< T >::resizeNoCopy ( int  Ydim, int  Xdim  )

inline

Resize to a given size (don't copy old elements)

Definition at line 534 of file matrix2d.h.

    {
        resize(Ydim, Xdim, true);
    }

resizeNoCopy() [2/2]

template<typename T>

template<typename T1 >

void Matrix2D< T >::resizeNoCopy ( const Matrix2D< T1 > &  v )

inline

Resize according to a pattern. Do not copy old elements.

Definition at line 543 of file matrix2d.h.

    {
        if (mdimx != v.mdimx || mdimy != v.mdimy)
            resize(v.mdimy, v.mdimx, true);
    }

rowEnergySum()

template<typename T>

void Matrix2D< T >::rowEnergySum

(

Matrix1D< T > &

sum

)

const

Get row energy sum. Sum of the squared values by row

Definition at line 795 of file matrix2d.cpp.

{
    sum.initZeros(MAT_YSIZE(*this));
    FOR_ALL_ELEMENTS_IN_MATRIX2D(*this)
        VEC_ELEM(sum,i)+=MAT_ELEM(*this,i,j)*MAT_ELEM(*this,i,j);
}

rowSum()

template<typename T>

void Matrix2D< T >::rowSum

(

Matrix1D< T > &

sum

)

const

Get row sum.

Definition at line 779 of file matrix2d.cpp.

{
    sum.initZeros(MAT_YSIZE(*this));
    FOR_ALL_ELEMENTS_IN_MATRIX2D(*this)
        VEC_ELEM(sum,i)+=MAT_ELEM(*this,i,j);
}

sameShape()

template<typename T>

template<typename T1 >

bool Matrix2D< T >::sameShape ( const Matrix2D< T1 > &  op ) const

inline

Same shape.

Returns true if this object has got the same shape (origin and size) than the argument

Definition at line 566 of file matrix2d.h.

    {
        return ((mdimx == op.mdimx) && (mdimy == op.mdimy));
    }

selfInverse()

template<typename T>

void Matrix2D< T >::selfInverse ( )

inline

Inverse the current matrix

Definition at line 1146 of file matrix2d.h.

    {
        Matrix2D<T> auxMatrix(*this);
        auxMatrix.inv(*this);
    }

setCol()

template<typename T>

void Matrix2D< T >::setCol	(	size_t	j,
		const Matrix1D< T > &	v
	)

Set Column

This function sets a column vector corresponding to the chosen column inside matrix.

m.setCol(0, (m.row(1)).transpose()); // Copies row 1 in column 0

Definition at line 929 of file matrix2d.cpp.

{
    if (mdimx == 0 || mdimy == 0)
        REPORT_ERROR(ERR_MATRIX_EMPTY, "setCol: Target matrix is empty");

    if (j>= mdimx)
        REPORT_ERROR(ERR_INDEX_OUTOFBOUNDS, "setCol: Matrix subscript (j) out of range");

    if (VEC_XSIZE(v) != mdimy)
        REPORT_ERROR(ERR_MATRIX_SIZE,
                     "setCol: Vector dimension different from matrix one");

    if (!v.isCol())
        REPORT_ERROR(ERR_MATRIX_DIM, "setCol: Not a column vector in assignment");

    for (size_t i = 0; i < mdimy; i++)
        MAT_ELEM(*this,i, j) = VEC_ELEM(v,i);
}

setConstantCol()

template<typename T>

void Matrix2D< T >::setConstantCol ( size_t  j, T  v  )

inline

Set constant column. Set a given column to a constant value A(i,j)=val;

Definition at line 1028 of file matrix2d.h.

    {
        if (mdimx == 0 || mdimy == 0)
            REPORT_ERROR(ERR_MATRIX_EMPTY, "setCol: Target matrix is empty");

        if (j>= mdimx)
            REPORT_ERROR(ERR_INDEX_OUTOFBOUNDS, "setCol: Matrix subscript (j) out of range");

        for (size_t i = 0; i < mdimy; i++)
            MAT_ELEM(*this,i, j) = v;
    }

setRow()

template<typename T>

void Matrix2D< T >::setRow	(	size_t	i,
		const Matrix1D< T > &	v
	)

Set Row

This function sets a row vector corresponding to the chosen row in the 2D Matrix

m.setRow(-2, m.row(1)); // Copies row 1 in row -2

Definition at line 910 of file matrix2d.cpp.

{
    if (mdimx == 0 || mdimy == 0)
        REPORT_ERROR(ERR_MATRIX_EMPTY, "setRow: Target matrix is empty");

    if (i >= mdimy)
        REPORT_ERROR(ERR_INDEX_OUTOFBOUNDS, "setRow: Matrix subscript (i) out of range");

    if (VEC_XSIZE(v) != mdimx)
        REPORT_ERROR(ERR_MATRIX_SIZE,
                     "setRow: Vector dimension different from matrix one");

    if (!v.isRow())
        REPORT_ERROR(ERR_MATRIX_DIM, "setRow: Not a row vector in assignment");

    memcpy(&MAT_ELEM(*this,i,0),&VEC_ELEM(v,0),mdimx*sizeof(double));
}

setVal()

template<typename T>

void Matrix2D< T >::setVal ( T  val, int  y, int  x  )

inline

Parenthesis operator for phyton

Definition at line 714 of file matrix2d.h.

    {
        MAT_ELEM((*this),y,x)=val;
    }

submatrix()

template<typename T >

void Matrix2D< T >::submatrix	(	int	i0,
		int	j0,
		int	iF,
		int	jF
	)

Extract submatrix and assign to this object.

Definition at line 1095 of file matrix2d.cpp.

{
   if (i0 < 0 || j0 < 0 || iF >= MAT_YSIZE(*this) || jF >= MAT_XSIZE(*this))
       REPORT_ERROR(ERR_INDEX_OUTOFBOUNDS,"Submatrix indexes out of bounds");
   Matrix2D<T> result(iF - i0 + 1, jF - j0 + 1);

   FOR_ALL_ELEMENTS_IN_MATRIX2D(result)
   MAT_ELEM(result, i, j) = MAT_ELEM(*this, i+i0, j+j0);

   *this = result;
}

svd()

template<typename T>

void Matrix2D< T >::svd ( Matrix2D< double > &  U, Matrix1D< double > &  W, Matrix2D< double > &  V  ) const

inline

Perform SVD decomposition *this = U * W * V^t

Definition at line 1124 of file matrix2d.h.

    {
      svdcmp(*this, U, W, V);
    }

toVector()

template<typename T>

void Matrix2D< T >::toVector

(

Matrix1D< T > &

op1

)

const

Makes a vector from a matrix

An exception is thrown if the matrix is not a single row or a single column. The origin of the vector is set according to the one of the matrix.

Matrix1D< double > v;
m.toVector(v);

Definition at line 832 of file matrix2d.cpp.

{
    // Null matrix => Null vector
    if (mdimx == 0 || mdimy == 0)
    {
        op1.clear();
        return;
    }

    // If matrix is not a vector, produce an error
    if (!(mdimx == 1 || mdimy == 1))
        REPORT_ERROR(ERR_MATRIX_DIM,
                     "toVector: Matrix cannot be converted to vector");

    // Look at shape and copy values
    if (mdimy == 1)
    {
        // Row vector
        if (VEC_XSIZE(op1)!=mdimx)
            op1.resizeNoCopy(mdimx);

        memcpy(&VEC_ELEM(op1,0),&MAT_ELEM(*this,0,0),mdimx*sizeof(double));

        op1.setRow();
    }
    else
    {
        // Column vector
        if (VEC_XSIZE(op1)!=mdimy)
            op1.resizeNoCopy(mdimy);

        for (size_t i = 0; i < mdimy; i++)
            VEC_ELEM(op1,i) = MAT_ELEM(*this,i, 0);

        op1.setCol();
    }
}

trace()

template<typename T >

T Matrix2D< T >::trace

(

)

const

Trace Sum of the values in the diagonal

Definition at line 1304 of file matrix2d.cpp.

{
   size_t d=std::min(MAT_XSIZE(*this),MAT_YSIZE(*this));
   T retval=0;
   for (size_t i=0; i<d; ++i)
       retval+=MAT_ELEM(*this,i,i);
   return retval;
}

transpose()

template<typename T >

Matrix2D< T > Matrix2D< T >::transpose

(

)

const

Algebraic transpose of a Matrix

You can use the transpose in as complex expressions as you like. The origin of the vector is not changed.

v2 = v1.transpose();

Definition at line 1314 of file matrix2d.cpp.

{
   Matrix2D<T> result(mdimx, mdimy);
   FOR_ALL_ELEMENTS_IN_MATRIX2D(result)
   MAT_ELEM(result,i,j) = MAT_ELEM((*this),j,i);
   return result;
}

write()

template<typename T >

void Matrix2D< T >::write

(

const FileName &

fn

)

const

Write this matrix to file

Definition at line 113 of file matrix2d.cpp.

{
    std::ofstream fhOut;
    fhOut.open(fn.c_str());
    if (!fhOut)
        REPORT_ERROR(ERR_IO_NOTOPEN,(std::string)"write: Cannot open "+fn+" for output");
    fhOut << *this;
    fhOut.close();
}

Xdim()

template<typename T>

size_t Matrix2D< T >::Xdim ( ) const

inline

X dimension

Returns X dimension

Definition at line 575 of file matrix2d.h.

    {
        return mdimx;
    }

Ydim()

template<typename T>

size_t Matrix2D< T >::Ydim ( ) const

inline

Y dimension

Returns Y dimension

Definition at line 584 of file matrix2d.h.

    {
        return mdimy;
    }

Friends And Related Function Documentation

operator*

template<typename T>

Matrix2D<T> operator* ( T  op1, const Matrix2D< T > &  op2  )

friend

v3 = k * v2.

Definition at line 747 of file matrix2d.h.

    {
        Matrix2D<T> tmp(op2);
        for (size_t i=0; i < op2.mdim; i++)
            tmp.mdata[i] = op1 * op2.mdata[i];
        return tmp;
    }

operator<<

template<typename T>

std::ostream& operator<< ( std::ostream &  ostrm, const Matrix2D< T > &  v  )

friend

Show matrix

Definition at line 910 of file matrix2d.h.

    {
        if (v.Xdim() == 0 || v.Ydim() == 0)
            ostrm << "NULL matrix\n";
        else
        {
            ostrm << std::endl;
            double max_val = v.computeMax();
            int prec = bestPrecision(max_val, 10);

            for (size_t i = 0; i < v.Ydim(); i++)
            {
                for (size_t j = 0; j < v.Xdim(); j++)
                {
                    ostrm << floatToString((double) v(i, j), 10, prec) << ' ';
                }
                ostrm << std::endl;
            }
        }

        return ostrm;
    }

Member Data Documentation

destroyData

template<typename T>

bool Matrix2D< T >::destroyData

Definition at line 398 of file matrix2d.h.

fdMap

template<typename T>

int Matrix2D< T >::fdMap

Definition at line 404 of file matrix2d.h.

mappedData

template<typename T>

bool Matrix2D< T >::mappedData

Definition at line 401 of file matrix2d.h.

mdata

template<typename T>

T* Matrix2D< T >::mdata

Definition at line 395 of file matrix2d.h.

mdataOriginal

template<typename T>

char* Matrix2D< T >::mdataOriginal

Definition at line 407 of file matrix2d.h.

mdim

template<typename T>

size_t Matrix2D< T >::mdim

Definition at line 416 of file matrix2d.h.

mdimx

template<typename T>

size_t Matrix2D< T >::mdimx

Definition at line 410 of file matrix2d.h.

mdimy

template<typename T>

size_t Matrix2D< T >::mdimy

Definition at line 413 of file matrix2d.h.

---

The documentation for this class was generated from the following files:

• xmipp/libraries/data/mask.h
• xmippCore/core/matrix2d.h
• xmippCore/core/matrix2d.cpp