Doxygen doesn't generate References function call relation for class method whose object created indirectly - doxygen

References to Array<>::print is missing for testTemplate in document generated for below example documentation:
.
#include"lib.h"
using namespace std;
void testTemplate(void);
int main()
{
testTemplate();
return 0;
}
void testTemplate(void)
{
int arr[5] = {1, 2, 3, 4, 5};
using array_type = Array<int>;
array_type array2(arr, 5);
array2.print();
}
#include<iostream>
template <typename T>
class Array
{
private:
T *ptr;
int size;
public:
Array(T arr[], int s);
void print();
};
template <typename T>
Array<T>::Array(T arr[], int s)
{
ptr = new T[s];
size = s;
for(int i = 0; i < size; i++)
{
ptr[i] = arr[i];
}
}
template <typename T>
void Array<T>::print()
{
for (int i = 0; i < size; i++)
{
std::cout<<" "<<*(ptr + i);
}
std::cout<<std::endl;
}
Doxygen settings:
EXTRACT_ALL = YES
EXTRACT_PRIVATE = YES
EXTRACT_PACKAGE = YES
EXTRACT_STATIC = YES
EXTRACT_LOCAL_CLASSES = YES
EXTRACT_LOCAL_METHODS = YES
EXTRACT_ANON_NSPACES = YES
RESOLVE_UNNAMED_PARAMS = YES
REFERENCED_BY_RELATION = YES
REFERENCES_RELATION = YES
Exmaple 2: similar use case
file <project_name.h>
class ProjectName
{
public:
int arr[5] = {1, 2, 3, 4, 5};
Array<int> array_type;
ProjectName(void):array_type(arr,5)
{
}
void print(void)
{
std::cout<<"Hello World"<<std::endl;
}
};
ProjectName& getProjectName(void);
file <project_name.cpp>
#include "project_name.h"
ProjectName& getProjectName(void)
{
static ProjectName obj;
return obj;
}
file <main.cpp>
#include <iostream>
#include"project_name.h"
using namespace std;
void testTemplate(void);
int main()
{
testTemplate();
return 0;
}
void testTemplate(void)
{
ProjectName& project = getProjectName();
project.print();
project.array_type.print();
}
References to Array<>::print is missing for testTemplate in generated document :

Related

How to define a static private method outside the class in c++

#include <iostream>
class BST {
private:
struct Bst_node
{
int data;
struct Bst_node* left;
struct Bst_node* right;
}*root;
// static Bst_node* get_inorder_predecessor(Bst_node* ptr);
static BST::Bst_node* get_inorder_predecessor(Bst_node* ptr)
{
ptr = ptr->left;
if (ptr == NULL) return NULL;
while (ptr->right != NULL)
{
ptr = ptr->right;
}
return ptr;
}
public:
void create()
{
root = new Bst_node;
root->data = 8;
root->right = NULL;
root->left = new Bst_node;
root->left->data = 10;
root->left->left = NULL;
root->left->right = NULL;
}
void print()
{
Bst_node * ptr = get_inorder_predecessor(this->root);
if(ptr == NULL) std::cout<<"NULL\n";
else std::cout<<ptr->data<<std::endl;
}
};
int main()
{
BST obj;
obj.create();
obj.print();
return 0;
}
The above code is working fine but when i define 'get_inorder_predecessor()' function outside the class it gives error see the below code.
#include <iostream>
class BST {
private:
struct Bst_node
{
int data;
struct Bst_node* left;
struct Bst_node* right;
}*root;
static Bst_node* get_inorder_predecessor(Bst_node* ptr);
public:
void create()
{`
root = new Bst_node;
root->data = 8;
root->right = NULL;
root->left = new Bst_node;
root->left->data = 10;
root->left->left = NULL;
root->left->right = NULL;
}
void print()
{
Bst_node * ptr = get_inorder_predecessor(this->root);
if(ptr == NULL) std::cout<<"NULL\n";
else std::cout<<ptr->data<<std::endl;
}
};
static BST::Bst_node* get_inorder_predecessor(Bst_node* ptr)
{
ptr = ptr->left;
if (ptr == NULL) return NULL;
while (ptr->right != NULL)
{
ptr = ptr->right;
}
return ptr;
}
int main()
{
BST obj;
obj.create();
obj.print();
return 0;
}
See the ERRORS:
'''binary.cpp:33:13: error: 'struct BST::Bst_node' is private within this context
static BST::Bst_node* get_inorder_predecessor(Bst_node* ptr)
^~~~~~~~
binary.cpp:4:12: note: declared private here
struct Bst_node
^~~~~~~~
binary.cpp:33:47: error: 'Bst_node' was not declared in this scope
static BST::Bst_node* get_inorder_predecessor(Bst_node* ptr)
^~~~~~~~
binary.cpp:33:57: error: 'ptr' was not declared in this scope
static BST::Bst_node* get_inorder_predecessor(Bst_node* ptr)
^~~
'''

C++ Fix the following code so that it will correctly recursively traverse a directory tree in order to find where a particular file is

I have an assignment as following: Write a program will ask the user how many random numbers to generate. Then it will present a menu which has the options of Display, Average, Median, and Standard Deviation, Regenerate, and Quit. Without the use of a switch statement, or an if statements, or pointers to functions, have the program execute the user's selection from the menu. (Note: Function pointers are not allowed!)
This is what I have so far:
#include <iostream>
#include <cstdlib>
#include <array>
#include <cmath>
#include <stdlib.h>
#include <map>
using namespace std;
template <typename T> class wrapperclass
{
public:
static T myclass;
};
class Display
{
public:
static void myFunction(int random[], int num)
{
for(int i=0; i<num; ++i)
{
cout << random[i] <<endl;
}
}
};
class Average
{
public:
static double myFunction(int random[], int num)
{
double avg = 0;
for(int i=0; i<num; ++i)
{
avg += random[i];
}
return avg/num;
}
};
class Median
{
public:
static double myFunction(int random[], int num)
{
double mid = 0;
if(num % 2 == 0)
{
mid = (random[num/2] + random[num/2-1])/2;
}
else
{
mid = random[num/2];
}
return mid;
}
};
class StdDi
{
public:
static double myFunction(int random[], int num)
{
double avg=0;
double total=0;
for(int i=0; i<num; ++i)
{
avg += random[i];
}
avg = avg/num;
for(int i=0; i<num; ++i)
{
total += (avg-random[i])*(avg-random[i]);
}
total = total/num;
return sqrt(total);
}
};
class renerate
{
public:
static void myFunction(int)
{
}
};
class quit
{
public:
static void myFunction()
{
exit(EXIT_FAILURE);
}
};
int main()
{
int num = 0;
int option = 0;
map<int, class T> magic;
cout << "How many random numbers would u like to generate? " << endl;
cin >> num;
int random[num];
for(int i=0; i<num; ++i)
{
random[i] = rand() % 100 + 1;
}
cout << " Menu"<<endl
<< "1. Display"<<endl
<< "2. Average"<<endl
<< "3. Median"<<endl
<< "4. Standard Deviation"<<endl
<< "5. Renerate"<<endl
<< "6. Quit"<<endl;
cin >> option;
cout<<wrapperclass<Average>::myclass.myFunction(random, num);
return 0;
}
I'm about to directly pass the user input "option" into that "wrapperclass" like this "wrapperclass" so I can simply call the .myFunction since all classes have the same function name. but this won't work for c++ so is there any work around?

Creating class object c++ in if-statement

I actually have a small question. I want to create an attribute "function" which should be from the class function1, function2 or function3. Is there a way I can do that?
Here is the code:
double Uppersum::evalIntegral(double p_) {
if (functiontype == FUNKTION1){
Function1 function;
}
else if (functiontype == FUNKTION2) {
Function2 function;
}
else if (functiontype == FUNKTION3){
Function3 function;
}
function.setParameterP(p_);
double increment_h = (boundary_b - boundary_a)/num_subintervalls_m;
double sum = 0;
for (int index_i = 0; index_i < num_subintervalls_m -1; index_i++){
double x_1 = index_i * increment_h;
double x_2 = (index_i+1) * increment_h;
double y_1, y_2;
y_1 = function.evalFunctionValue(x_1);
y_2 = function.evalFunctionValue(x_2);
sum += increment_h * std::max(y_1, y_2);
}
}
class Function {
protected:
double parameter_p;
public:
void setParameterP(double p_);
virtual double evalFunctionValue(double x_)=0;
};
class Function1 : public Function {
public:
double evalFunctionValue(double x_);
};
Why not use inheritance, superclass has the virtual functions setParameterP and evalFunctionValue. and in subclasses, override those virtual functions.
here is the test codeļ¼š
test.cpp
#include <iostream>
typedef enum{
FUNCTION1,
FUNCTION2,
FUNCTION3
}FunctionType;
using namespace std;
class super
{
public:
super(){}
~super(){}
virtual void setParameterP() = 0;
virtual void evalFunctionValue() = 0;
};
class func1:public super
{
public:
func1(){}
virtual void setParameterP(){cout<<"call setParameterP In func1"<<endl;}
virtual void evalFunctionValue(){cout<<"call evalFunctionValue In func1"<<endl;}
};
class func2:public super
{
public:
func2(){}
virtual void setParameterP(){cout<<"call setParameterP In func2"<<endl;}
virtual void evalFunctionValue(){cout<<"call evalFunctionValue In func2"<<endl;}
};
class func3:public super
{
public:
func3(){}
virtual void setParameterP(){cout<<"call setParameterP In func3"<<endl;}
virtual void evalFunctionValue(){cout<<"call evalFunctionValue In func3"<<endl;}
};
class FuncFactory
{
public:
static super* create(FunctionType var)
{
super* ret = nullptr;
switch (var)
{
case FUNCTION1:
ret = new func1();
break;
case FUNCTION2:
ret = new func2();
break;
case FUNCTION3:
ret = new func3();
break;
default:
cout <<"invalid FunctionType" << endl;
}
return ret;
}
};
int main(int argc, char** argv)
{
super* pFunc = FuncFactory::create(FUNCTION1);
pFunc->setParameterP();
pFunc->evalFunctionValue();
delete pFunc;
pFunc = FuncFactory::create(FUNCTION2);
pFunc->setParameterP();
pFunc->evalFunctionValue();
delete pFunc;
pFunc = FuncFactory::create(FUNCTION3);
pFunc->setParameterP();
pFunc->evalFunctionValue();
delete pFunc;
return 0;
}
here is the process result:
result

Want to reset integers using virtual class function

The function I want works within the class butt won't apply to main. Must maintain the initial (Entity *entity = new Nummchange(flarb);)
#include <iostream>
using namespace std;
class Entity
{
public:
Entity(){}
~Entity(){}
virtual int reset(int NUMM) = NULL;
protected:
private:
};
class Nummchange : public Entity
{
public:
Nummchange(int NUMM);
~Nummchange();
int reset(int NUMM);
protected:
private:
int numm;
};
Nummchange::Nummchange(int NUMM)
{
}
Nummchange::~Nummchange()
{
}
int Nummchange::reset(int NUMM)
{
numm = 50;
NUMM = numm;
std::cout << "\nnumm+++++++"<< numm << "\n" << std::endl;
return numm;
}
int main()
{
int flarb = 50;
Entity *entity = new Nummchange(flarb);
while (flarb >= 0)
{
flarb--;
cout << flarb;
if(flarb == 0)
{
entity->reset(flarb);
std::cout << "flarb+++++++"<< flarb << "\n" << std::endl;
}
}
system("pause");
return 0;
}
Success is if the while loop continues perpetually.
int reset(int NUMM); method should take reference of integer type as below.
int reset(int &NUMM);
Make sure that you change the parameter to be reference of integer in all the three places of the method use in the program.

class has no member problem (code works find in VS, but failed in Ubuntu)

all
I got a piece of code about sparse matrix, it works fine in VISUAL STUDIO 2008, but when I want to port it to ubuntu environment, the compiler report the following errors:
../include/spmatrix.h(123): error:
class template "numc::CSRMatrix"
has no member "resize"
../include/spmatrix.h(170): error:
expected a ";"
../include/spmatrix.h(171): error:
identifier "it" is undefined
../include/spmatrix.h(176): error:
expected a ";"
../include/spmatrix.h(178): error:
identifier "it" is undefined
../include/spmatrix.h(183): error:
identifier "size" is undefined
../include/spmatrix.h(185): error:
expected a ";"
../include/spmatrix.h(185): error:
identifier "it" is undefined
.> ./include/spmatrix.h(186): error:
expected a ";"
../include/spmatrix.h(187): error:
identifier "cit" is undefined
../include/spmatrix.h(205): error:
expected a ";"
../include/spmatrix.h(205): error:
identifier "it" is undefined
../include/spmatrix.h(218): error:
expected a ";"
../include/spmatrix.h(218): error:
identifier "it" is undefined
../include/spmatrix.h(222): error:
expected a ";"
../include/spmatrix.h(223): error:
identifier "f" is undefined
../include/spmatrix.h(224): error:
identifier "make_pair" is undefined
../include/spmatrix.h(224): error:
type name is not allowed
../include/spmatrix.h(224): error:
type name is not allowed
../include/spmatrix.h(245): error:
identifier "RowType" is undefined
../include/spmatrix.h(246): error:
name followed by "::" must be a class
or namespace name
../include/spmatrix.h(246): error:
expected a ";"
../include/spmatrix.h(246): error:
identifier "it" is undefined
../include/spmatrix.h(269): error:
identifier "RowType" is undefined
../include/spmatrix.h(270): error:
name followed by "::" must be a class
or namespace name
../include/spmatrix.h(270): error:
expected a ";"
../include/spmatrix.h(271): error:
identifier "it" is undefined
../include/spmatrix.h(276): error:
identifier "RowType" is undefined
../include/spmatrix.h(276): error:
identifier "crow" is undefined
../include/spmatrix.h(277): error:
name followed by "::" must be a class
or namespace name
../include/spmatrix.h(277): error:
expected a ";"
../include/spmatrix.h(279): error:
identifier "it" is undefined
../include/spmatrix.h(311): error:
expected a ";"
../include/spmatrix.h(311): error:
identifier "it" is undefined
../include/spmatrix.h(350): error:
expected a ";"
../include/spmatrix.h(350): error:
identifier "it" is undefined
../include/spmatrix.h(423): error:
expected a ";"
../include/spmatrix.h(424): error:
identifier "it" is undefined
../include/spmatrix.h(484): error:
expected a ";"
../include/spmatrix.h(485): error:
identifier "it" is undefined
../include/spmatrix.h(518): error:
expected a ";"
../include/spmatrix.h(520): error:
identifier "it" is undefined
I try to figure out where the problem is, but failed. Hope you can give me some hint where the problem is. Thanks in advance for your help!
Below is the code of this sparse matrix, it is just a header file:
#pragma warning(disable: 4786)
#ifndef NUMC_CSRMATRIX_H
#define NUMC_CSRMATRIX_H
#include <cmath>
#include <map>
#include <vector>
#include <limits>
#include <algorithm>
#ifndef _NUMC_BEGIN
#define _NUMC_BEGIN namespace numc {
#define _NUMC_END }
#endif
_NUMC_BEGIN
using std::vector;
using std::map;
using std::swap;
using std::lower_bound;
template<typename R> class CSRMatrix;
template<typename R> struct RowMat;
template<typename R> void CreateCSRMatrixFromRowMap(CSRMatrix<R>&, const RowMat<R>&);
t emplate<typename R> void CSRMatrixTranspose (const CSRMatrix<R>&, CSRMatrix<R>&);
template<typename R> bool Mul2MatricesSymmResult (const CSRMatrix<R>&, const CSRMatrix<R>&, RowMat<R>&);
template<typename R> bool Mul2MatricesSymmResult (const CSRMatrix<R>&, const CSRMatrix<R>&, CSRMatrix<R>&);
template<typename R> bool Mul2Matrices (const CSRMatrix<R>&, const CSRMatrix<R>&, RowMat<R>&);
template<typename R> bool Mul2Matrices (const CSRMatrix<R>&, const CSRMatrix<R>&, CSRMatrix<R>&);
template<typename R>
class CSRMatrix
{
public:
enum MatType{ RealStrucSymm=1, RealSymmPosDef=2, RealSymmIndef=-2,
CompStrucSymm=3, CompHermPosDef=4, CompHermIndef=-4,
CompSymm=6, RealUnSymm=11, CompUnSymm=13};
std::vector<R> mAv;
std::vector<int> mAi, mAj;
CSRMatrix():mNRow(0),mNCol(0),mMtype(RealUnSymm) {};
CSRMatrix(const RowMat<R> &rm):mMtype(RealUnSymm) { CreateCSRMatrixFromRowMap(*this, rm); }
MatType mMtype;
#if ( defined(_MSC_VER)&&(_MSC_VER>1300) )
//template<typename T> class CSRMatrix;
#define FFM <> // FFM FRIEND_FUNCTION_MAGIC
#else
#define FFM
#endif
friend void CreateCSRMatrixFromRowMap FFM(CSRMatrix<R>&, const RowMat<R>&);
friend void CSRMatrixTranspose FFM(const CSRMatrix<R>&, CSRMatrix<R>&);
friend bool Mul2MatricesSymmResult FFM(const CSRMatrix<R>&, const CSRMatrix<R>&, RowMat<R>&);
friend bool Mul2MatricesSymmResult FFM(const CSRMatrix<R>&, const CSRMatrix<R>&, CSRMatrix<R>&);
friend bool Mul2Matrices FFM(const CSRMatrix<R>&, const CSRMatrix<R>&, RowMat<R>&);
friend bool Mul2Matrices FFM(const CSRMatrix<R>&, const CSRMatrix<R>&, CSRMatrix<R>&);
#undef FFM
private:
int mNRow, mNCol;
public:
inline int nRow() const { return mNRow; }
inline int nCol() const { return mNCol; }
inline int empty() const { return (0==nRow() || 0==nCol()) ;}
inline bool onebase() const { return (!mAi.empty()) && (mAi[0]==1); } //default: zerobase, including empty matrix!
inline MatType mtype() const { return mMtype; }
inline bool issymm() const
{ return (RealSymmIndef==mMtype || RealSymmPosDef==mMtype || CompSymm==mMtype); }
inline void clear()
{ mNRow = 0; mNCol = 0; mMtype = RealUnSymm; mAv.clear(); mAi.clear(); mAj.clear(); }
R getElementV(int x, int y) const{
double *p = const_cast<CSRMatrix*>(this)->getElementP(x, y);
return (NULL==p)?0:*p;
}
R* getElementP(int x, int y) {
if (x<0||y<0) return NULL;
if ( issymm() && x>y) swap(x, y);
const int off = onebase();
std::vector<int>::const_iterator it = lower_bound(mAj.begin()+mAi[x]-off, mAj.begin()+(mAi[x+1]-off), y+off);
if (it==mAj.begin()+(mAi[x+1]-off) || *it!=(y+off) ) return NULL;
return &mAv.front() + ( it-mAj.begin() );
}
void MultiVect(R* in, R *out) const;
bool ChangeBase(bool oneBase) {
if( onebase() == oneBase ) return true;
int ii;
if (oneBase) {
if (mAi[0] != 0){
fprintf(stderr, "error matrix!");
return false;
}
for (ii=0; ii<mAi.back(); ii++) mAj[ii]++;
for (ii=0; ii<mNRow+1; ii++) mAi[ii]++;
}
else {
if (mAi[0] != 1){
fprintf(stderr, "error matrix!");
return false;
}
for (ii=0; ii<mAi.back()-1; ii++) mAj[ii]--;
for (ii=0; ii<mNRow+1; ii++) mAi[ii]--;
}
return true;
}
void GetSubMat(const std::vector<int> &xi, const std::vector<int> &yi, CSRMatrix& mat){
mat.resize( yi.size() );
for(int j=0; j<yi.size(); j++){
for(int i=0; i<xi.size(); i++){
}
}
}
void print(FILE *f=stdout){
fprintf(f, "The matrix:\n");
for(int i=0; i<nRow(); i++){
fprintf(f, "%2d#:", i);
for(int j=0; j<nCol(); j++) {
fprintf(f, "\t%.3e", getElementV(i, j) );
}
fprintf(f, "\n");
}
}
};
template<typename R>
struct RowMat:public vector<map<int, R> >
{
typedef map<int, R> RowType;
typedef vector<RowType> BaseType;
int mNCol;
RowMat(int nrow=0, int ncol=0):BaseType(nrow),mNCol(ncol) { }
~RowMat() { }
RowMat(const CSRMatrix<R> &mat)
{
resize(mat.nCol(), mat.nRow());
int off = mat.onebase()?1:0;
for(unsigned int i=0; i+1<mat.mAi.size(); i++){
for(int j=mat.mAi[i]; j<mat.mAi[i+1]; j++){
(*this)(i, mat.mAj[j-off]-off) = mat.mAv[ j-off ];
}
}
}
virtual bool symmetric() const {return false;}
virtual inline R operator()(int i, int j) const{
const RowType &crow = (*this)[i];
RowType::const_iterator it = crow.find(j);
return ( it==crow.end() )?0:it->second;
}
virtual inline R& operator()(int i, int j){
RowType &crow = (*this)[i];
RowType::iterator it = crow.find(j);
return ( it==crow.end() )?crow.insert( std::pair<int,R>(j, 0) ).first->second:it->second;
}
int clearZero() {
int nZero;
for (size_t i=0; i<size(); i++) {
RowType &r = (*this)[i];
for (RowType::const_iterator it=r.begin(); it!=r.end(); ) {
RowType::const_iterator cit = it++;
if(fabs(cit->second) < std::numeric_limits<R>::epsilon()){
r.erase(cit);
++nZero;
}
}
}
return nZero;
}
inline void resize(int nrow, int ncol=0) { BaseType::resize(nrow); mNCol = ncol>0?ncol:mNCol; }
inline int nRow() const { return BaseType::size(); }
inline int nCol() const { return mNCol; }
int operator+=(const RowMat<R>& r) { return add(r, 1); }
void operator *= (const double v) {
for(int i=0; i<nRow(); i++){
map<int, R>& crow = (*this)[i];
for(map<int,R>::iterator it=crow.begin(); it!=crow.end(); ++it){
it->second *= v;
}
}
}
int add(const RowMat<R>& r, R k){
const int h = nRow();
if( r.nRow() != h ) return -1;
for(int i=0; i<h; i++){
const map<int, R>& rrow = r[i];
map<int, R>& lrow = (*this)[i];
for(RowType::const_iterator it=rrow.begin(); it!=rrow.end(); ++it){
int col = it->first;
R val = it->second * k;
map<int,R>::iterator f = lrow.find(col);
if( f != lrow.end() ) f->second += val;
lrow.insert( make_pair<int, R>(col, val) );
}
}
return 0;
}
};
template<typename R>
struct RowMatSym : public RowMat<R>
{
typedef RowMat<R> Base;
RowMatSym(int nrow=0, int ncol=0):Base(nrow, ncol) {}
~RowMatSym() { }
RowMatSym(const RowMat<R> &rm){
resize(rm.nCol(), rm.nRow());
for(unsigned int i=0; i<rm.nRow(); i++){
const RowType &crow = rm[i];
for(RowType::const_iterator it=crow.begin(); it!=crow.end(); ++it){
(*this)(i, it->first) = it->second;
}
}
}
RowMatSym(const CSRMatrix<R> &mat)
{
resize(mat.nCol(), mat.nRow());
int off = mat.onebase()?1:0;
for(unsigned int i=0; i+1<mat.mAi.size(); i++){
for(int j=mat.mAi[i]; j<mat.mAi[i+1]; j++){
const int k = mat.mAj[j-off]-off;
(*this)(i, k) = mat.mAv[ j-off ];
}
}
}
virtual bool symmetric() const {return true;}
inline R operator()(int i, int j) const{
if(i>j) std::swap(i, j);
const RowType &crow = (*this)[i];
RowType::const_iterator it = crow.find(j);
return ( it==crow.end() )?0:it->second;
}
inline R& operator()(int i, int j){
if(i>j) std::swap(i, j);
RowType &crow = (*this)[i];
RowType::iterator it = crow.find(j);
return ( it==crow.end() )?crow.insert( std::pair<int,R>(j, 0) ).first->second
:it->second;
}
};
//////////////////////////////////////////////////////////////////////////
/// Get SubMatrix from rowmap
//////////////////////////////////////////////////////////////////////////
template <typename R>
void GetSubRowMap(const RowMat<R>& src,
const std::vector<int> &xi, const std::vector<int> &yi,
RowMat<R>& dst)
{
assert( xi.size()>0 && yi.size()>0 );
assert( yi.back() < (int)src.size() );
if( xi.empty() || yi.empty() || yi.back() >= (int)src.size() ){
fprintf(stderr, "\nerror matrix!");
return;
}
typedef std::map<int, R> row;
dst.resize( yi.size() );
for(unsigned int j=0; j<yi.size(); j++){
const row &srow = src[ yi[j] ];
row &drow = dst[j];
const int* pxi = &xi.front();
for(row::const_iterator it=srow.begin(); it!=srow.end(); ++it ){
pxi = std::lower_bound(pxi, &xi.back(), it->first);
if(*pxi != it->first){ // done
continue;
}
int col = pxi - &xi.front();
drow[col] = it->second;
}
}
}
//////////////////////////////////////////////////////////////////////////
/// Create CSR matrix from vector of rowmap
//////////////////////////////////////////////////////////////////////////
template <typename R>
void CreateCSRMatrixFromRowMap(CSRMatrix<R> &matC, const RowMat<R>& rowC)
{
if(rowC.mNCol <= 0){
fprintf(stderr, "\nnumber of column not specified in the RowMat, exit!");
return;
}
matC.clear();
matC.mNRow = rowC.nRow();
matC.mNCol = rowC.nCol();
matC.mAi.reserve(matC.nRow()+1);
int i,nnz=0;
for (i=0; i<matC.nRow(); i++) {
nnz += rowC[i].size();
}
matC.mAj.reserve(nnz);
matC.mAv.reserve(nnz);
// copy rows into matC
matC.mAi.push_back(0);
for (i=0; i<matC.nRow(); i++) {
matC.mAi.push_back(matC.mAi.back());
for (std::map<int, R>::const_iterator it=rowC[i].begin(); it!=rowC[i].end(); it++) {
matC.mAi.back()++;
matC.mAj.push_back(it->first);
matC.mAv.push_back(it->second);
}
}
}
//////////////////////////////////////////////////////////////////////////
/// Computes the transpose of a matrix.
template <typename R>
void CSRMatrixTranspose(const CSRMatrix<R> &matA, CSRMatrix<R> &matAT)
{
if (matA.issymm()) { // symmetric - just copy the matrix
matAT = matA;
return;
}
matAT.mNRow = matA.nCol();
matAT.mNCol = matA.nRow();
matAT.mMtype = matA.mMtype;
// non-symmetric matrix -> need to build data structure.
// we'll go over the columns and build the rows
int off = matA.onebase()?1:0;
RowMat<R> rowC(matA.nCol(), matA.nRow());
for (int i=0; i<matA.nRow(); i++) {
for (int j=matA.mAi[i]; j<matA.mAi[i+1]; j++) {
rowC[matA.mAj[j-off]-off][i] = matA.mAv[j-off];
}
}
CreateCSRMatrixFromRowMap(matAT, rowC);
}
//////////////////////////////////////////////////////////////////////////
// multiplication of sparse matrix
// Assuming nothing about the result (the result is not stored symmetric)
//////////////////////////////////////////////////////////////////////////
template <typename R>
bool Mul2Matrices(const CSRMatrix<R> &matA, const CSRMatrix<R> &matB,
RowMat<R> &rowsC)
{
if(matA.onebase() || matB.onebase() ){
fprintf(stderr, "\nmatrix saved in 1-based format, pleased converted it to 0-based and try again!");
return false;
}
// Compatibility of dimensions
if (matA.nCol() != matB.nRow())
return false;
// (m x n)*(n x k) = (m x k)
const int m=matA.nRow();
const int n=matA.nCol();
const int k=matB.nCol();
rowsC = RowMat<R>(m, k); // clean all coefficients
R aiv, valB;
int colInd, colB;
for (int i=0; i<m; ++i) { // creating row i of C
std::map<int, R> &mapRow2Val = rowsC[i];
for (int iAi = matA.mAi[i]; iAi < matA.mAi[i+1]; ++iAi) { // travel on ai
colInd = matA.mAj[iAi];
aiv = matA.mAv[iAi];
// make aiv*b_{rowInd} and insert into mapRow2Val
for (int iB=matB.mAi[colInd]; iB<matB.mAi[colInd+1]; ++iB) {
colB=matB.mAj[iB];
valB=matB.mAv[iB];
// insert valA*aiv into map
std::map<int, R>::iterator it = mapRow2Val.find(colB);
if (it == mapRow2Val.end()) { // first time
mapRow2Val[colB] = valB*aiv;
}
else {
it->second = it->second + valB*aiv;
}
}
}
}// now column i is created
return true;
}
template <typename R>
bool Mul2Matrices(const CSRMatrix<R> &matA, const CSRMatrix<R> &matB, CSRMatrix<R> &matC)
{
RowMat<R> rowsC;
if( !Mul2Matrices(matA, matB, rowsC) ) return false;
const int k=matB.mNCol;
rowsC.mNCol = k;
CreateCSRMatrixFromRowMap(matC, rowsC); // modified by jianwei hu # 16/09/07
return true;
}
//////////////////////////////////////////////////////////////////////////
// multiplication of sparse matrix
// The result is symmetric
//////////////////////////////////////////////////////////////////////////
template <typename R>
bool Mul2MatricesSymmResult(const CSRMatrix<R> &matA, const CSRMatrix<R> &matB,
RowMat<R> &rowsC)
{
if(matA.onebase() || matB.onebase()){
fprintf(stderr, "\nmatrix saved in 1-based format, pleased converted it to 0-based and try again!");
return false;
}
// Compatibility of dimensions
if(matA.nCol() != matB.nRow() || matA.nRow() != matB.nCol()) return false;
// (m x n)*(n x m) = (m x m)
const int m=matA.nRow();
const int n=matA.nCol();
rowsC = RowMat<R>(m, m); // clean all coefficients
R aiv, valB;
int colInd, colB;
for(int i=0; i<m; ++i) { // creating row i of C
std::map<int, R> &mapRow2Val = rowsC[i];
for (int iAi = matA.mAi[i]; iAi < matA.mAi[i+1]; ++iAi) { // travel on ai
colInd = matA.mAj[iAi];
aiv = matA.mAv[iAi];
// make aiv*b_{colInd} and insert into mapRow2Val
for (int iB=matB.mAi[colInd]; iB<matB.mAi[colInd+1]; ++iB) {
colB=matB.mAj[iB];
if (colB >= i) {
valB=matB.mAv[iB];
// insert valA*aiv into map
std::map<int, R>::iterator it = mapRow2Val.find(colB);
if (it == mapRow2Val.end()) { // first time
mapRow2Val[colB] = valB*aiv;
}
else {
it->second = it->second + valB*aiv;
}
}
}
}
}// now column i is created
return true;
}
template <typename R>
bool Mul2MatricesSymmResult(const CSRMatrix<R> &matA, const CSRMatrix<R> &matB, CSRMatrix<R> &matC)
{
RowMat<R> rowsC;
if( !Mul2MatricesSymmResult(matA, matB, rowsC) ) return false;
rowsC.mNCol = matA.nCol();
CreateCSRMatrixFromRowMap(matC, rowsC);
matC.mMtype = CSRMatrix<R>::RealSymmIndef;
return true;
}
template<typename R>
void DebugShowRowMatrix(const std::vector<std::map<int,R> > &rowA)
{
printf("\n");
for(unsigned int i=0; i<rowA.size(); i++){
printf("\n%3d#", i);
std::map<int,R>::const_iterator it=rowA[i].begin();
int j=0;
for(; it!=rowA[i].end(); ++it){
for(int k=j; k<it->first; k++){
printf("\t%3.2f", 0);
}
j=it->first+1;
printf("\t%3.2f", it->second);
}
}
}
typedef CSRMatrix<float> CSRMatrixf;
typedef CSRMatrix<double> CSRMatrixd;
_NUMC_END
#endif // NUMC_CSRMATRIX_H
Line 123: the CSRMatrix::resize method is undefined, and since CSRMatrix has no base class, it's not inherited.
Line 171: Using a typedef's nested type, like RowType::const_iterator, is a Visual Studio extension, it may not work in other compilers. You should replace these and similar usages with other typedefs, like so:
typedef typename map<int,R>::const_iterator RowTypeConstIterator;
UPDATE: The typename keyword is required (just learned it!)