SparseRow< doubletype > Class Template Reference

#include <SparseRow.h>

Public Member Functions
	SparseRow ()
	SparseRow (int in_M)
	~SparseRow ()
void	Echo ()
void	SetValues (int numvalues, int *cols, doubletype *vals, int *mods)
doubletype	Norm (NormMode mode)
doubletype	Mult (doubletype *X)
int	Nnz (void)
void	SetIrnJcnA (int *irn_loc, int *jcn_loc, doubletype *a_loc, int i_index, int count)

Data Fields
int	M
int	ncols
int *	indices
doubletype *	values

Detailed Description

template<class doubletype>
class SparseRow< doubletype >

Definition at line 13 of file SparseRow.h.

Constructor & Destructor Documentation

SparseRow() [1/2]

template<class doubletype >

SparseRow< doubletype >::SparseRow ( )

inline

Definition at line 23 of file SparseRow.h.

                 { /*{{{*/
          M=0;
          ncols=0;
          indices=NULL;
          values=NULL;
      } /*}}}*/

SparseRow() [2/2]

template<class doubletype >

SparseRow< doubletype >::SparseRow ( int  in_M )

inline

Definition at line 29 of file SparseRow.h.

                         {/*{{{*/
         
         M=in_M;
         ncols=0;
         indices=NULL;
         values=NULL;
 
      } /*}}}*/

~SparseRow()

template<class doubletype >

SparseRow< doubletype >::~SparseRow ( )

inline

Definition at line 37 of file SparseRow.h.

                  {/*{{{*/
         if(ncols){
            xDelete<int>(indices);
            xDelete<doubletype>(values);
         }
      } /*}}}*/

Member Function Documentation

Echo()

template<class doubletype >

void SparseRow< doubletype >::Echo ( void  )

inline

Definition at line 45 of file SparseRow.h.

                 { /*{{{*/
         int i;
 
         for(i=0;i<ncols;i++){
            _printf_("(" << indices[i] << "," << values[i] << ") ");
         }
      } /*}}}*/

SetValues()

template<class doubletype >

void SparseRow< doubletype >::SetValues ( int  numvalues, int *  cols, doubletype *  vals, int *  mods  )

inline

Definition at line 52 of file SparseRow.h.

                                                                         { /*{{{*/
 
         int count;
         int i,j;
 
         if(!M)_error_("unknow dimension for this sparse row!");
 
         /*Deallocate if already allocated: */
         if(ncols){
            xDelete<int>(indices);
            xDelete<doubletype>(values);
         }
 
         /*check numvalues: */
         if(!numvalues)return;
 
         /*Go through cols and resolve duplicates: */
         for(i=0;i<numvalues;i++){
            for(j=i+1;j<numvalues;j++){
               if (cols[j]==cols[i]){
                  if (mods[j]==ADD_VAL){
                     vals[i]+=vals[j];
                  }
                  else vals[i]=vals[j];
                  cols[j]=-1;
               }
               /*Ensure that this value will not be used anymore: */
            }
         }
 
         /*Now go through cols once more, and retrieve only what we need: */
         ncols=0;
         for(i=0;i<numvalues;i++)if(cols[i]>=0)ncols++;
 
         /*Allocate and fill: */
         indices=xNew<int>(ncols); _assert_(indices);
         values=xNewZeroInit<doubletype>(ncols);  _assert_(values);
         
         count=0;
         for(i=0;i<numvalues;i++){
            if(cols[i]>=0){
               indices[count]=cols[i];
               values[count]=vals[i];
               count++;
            }
         }
      
         if(count!=ncols)_error_("counter problem during set values operations");
      } /*}}}*/

Norm()

template<class doubletype >

doubletype SparseRow< doubletype >::Norm ( NormMode  mode )

inline

Definition at line 101 of file SparseRow.h.

                                    { /*{{{*/
 
         int i;
         doubletype norm=0.;
 
         switch(mode){
            case NORM_INF:
               for(i=0;i<ncols;i++){
                  norm+=fabs(values[i]);
               }
               return norm;
               break; 
            case NORM_FROB:
               for(i=0;i<ncols;i++){
                  norm+=values[i]*values[i];
               }
               return norm;
               break; 
 
            default:
               _error_("unknown norm !");
               break;
         }
      }

Mult()

template<class doubletype >

doubletype SparseRow< doubletype >::Mult ( doubletype *  X )

inline

Definition at line 126 of file SparseRow.h.

                                    { /*{{{*/
 
         int i;
         doubletype mult=0;
 
         for(i=0;i<ncols;i++){
            mult+=values[i]*X[indices[i]];
         }
         
         return mult;
      }

Nnz()

template<class doubletype >

int SparseRow< doubletype >::Nnz ( void  )

inline

Definition at line 138 of file SparseRow.h.

                   { /*{{{*/
 
         return ncols;
      }

SetIrnJcnA()

template<class doubletype >

void SparseRow< doubletype >::SetIrnJcnA ( int *  irn_loc, int *  jcn_loc, doubletype *  a_loc, int  i_index, int  count  )

inline

Definition at line 143 of file SparseRow.h.

                                                                                        {/*{{{*/
         int i;
 
         for(i=0;i<ncols;i++){
            irn_loc[count+i]=i_index;
            jcn_loc[count+i]=indices[i]+1; //fortran indexing
            a_loc[count+i]=values[i];
         }
      }

Field Documentation

M

template<class doubletype >

int SparseRow< doubletype >::M

Definition at line 17 of file SparseRow.h.

ncols

template<class doubletype >

int SparseRow< doubletype >::ncols

Definition at line 18 of file SparseRow.h.

indices

template<class doubletype >

int* SparseRow< doubletype >::indices

Definition at line 19 of file SparseRow.h.

values

template<class doubletype >

doubletype* SparseRow< doubletype >::values

Definition at line 20 of file SparseRow.h.

---

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

• src/c/toolkits/issm/SparseRow.h