is there a way to call a function depending on an integer at runtime?

[aaragon]

I have this scenario: several arrays for which I have their fixed
values at compilation time. Now, at runtime I need to access a
specific array depending on an integer but I want to avoid if and
switch statements.

My first approach was to rely on partial template specialization.
Therefore, I have:

// .h file
template <int v> SomeClass;

template <> struct SomeClass<1> {
static double loc(unsigned short i) {
return loc_;
}
static const double loc_[1];
};
template <> struct SomeClass<2> {
static double loc(unsigned short i) {
return loc_;
}
static const double loc_[2];
};
// and so on until 30 partial specializations

// .cpp file
const double SomeClass<1>::loc_[] = { 0.4 };
const double SomeClass<2>::loc_[] = { 0.2, 0.6 };
// and so on until 30 partial specializations

so I called the function like this:

double location = SomeClass<3>::loc(2);

Well, this approach worked fine until I changed the code so that the
integer is not known until runtime. So the question is...
Is there a way to do the same at runtime without having a switch or if
statement? Is there a way to do function overloading at runtime? I
thought that I could have something like the following:

struct SomeClass {

int val;
SomeClass(int v) : val(v) {}

double loc(unsigned short i) {
return locImpl(classB(val),i);
}
double locImpl(classB(1), int i) {
const double SomeClass<1>::loc_[] = { 0.4};
return loc_;
}
double locImpl(classB(2), int i) {
const double SomeClass<2>::loc_[] = { 0.2, 0.6 };
return loc_;
}
};

and convert the integer to some class and rely on function
overloading, but I couldn't find a way to do this. Any ideas? Thank
you,

a²

 

[Daniel T.]

I have this scenario: several arrays for which I have their fixed
values at compilation time. Now, at runtime I need to access a
specific array depending on an integer but I want to avoid if and
switch statements.

A map< int, vector< double > > would serve quite nicely I think.

 

[K.L.]

I have this scenario: several arrays for which I have their fixed
values at compilation time. Now, at runtime I need to access a
specific array depending on an integer but I want to avoid if and
switch statements.

My first approach was to rely on partial template specialization.
Therefore, I have:

// .h file
template <int v> SomeClass;

template <> struct SomeClass<1> {
  static double loc(unsigned short i) {
    return loc_;
  }
  static const double loc_[1];};

template <> struct SomeClass<2> {
  static double loc(unsigned short i) {
    return loc_;
  }
  static const double loc_[2];};

// and so on until 30 partial specializations

// .cpp file
const double SomeClass<1>::loc_[] = { 0.4 };
const double SomeClass<2>::loc_[] = { 0.2, 0.6 };
// and so on until 30 partial specializations

so I called the function like this:

double location = SomeClass<3>::loc(2);

Well, this approach worked fine until I changed the code so that the
integer is not known until runtime. So the question is...
Is there a way to do the same at runtime without having a switch or if
statement? Is there a way to do function overloading at runtime? I
thought that I could have something like the following:

struct SomeClass {

  int val;
  SomeClass(int v) : val(v) {}

  double loc(unsigned short i) {
    return locImpl(classB(val),i);
  }
  double locImpl(classB(1), int i) {
    const double SomeClass<1>::loc_[] = { 0.4};
    return loc_;
  }
  double locImpl(classB(2), int i) {
    const double SomeClass<2>::loc_[] = { 0.2, 0.6 };
    return loc_;
  }

};

and convert the integer to some class and rely on function
overloading, but I couldn't find a way to do this. Any ideas? Thank
you,

a²

map< int, vector< double > > is a good approach. Beyond it you can try
to use boost\preprocessor. Like this:

#define LocItem(z, n, ...) SomeClass<n+1>::loc_,
const double* locs[] =
{
BOOST_PP_REPEAT(30, LocItem,)
};

double loc(int v, unsigned short i)
{
return locs[v - 1]
}

I suppose v is from 1 to 30.

 

[aaragon]

I have this scenario: several arrays for which I have their fixed
values at compilation time. Now, at runtime I need to access a
specific array depending on an integer but I want to avoid if and
switch statements.

My first approach was to rely on partial template specialization.
Therefore, I have:

// .h file
template <int v> SomeClass;

template <> struct SomeClass<1> {
static double loc(unsigned short i) {
return loc_;
}
static const double loc_[1];};

template <> struct SomeClass<2> {
static double loc(unsigned short i) {
return loc_;
}
static const double loc_[2];};

// and so on until 30 partial specializations

// .cpp file
const double SomeClass<1>::loc_[] = { 0.4 };
const double SomeClass<2>::loc_[] = { 0.2, 0.6 };
// and so on until 30 partial specializations

so I called the function like this:

double location = SomeClass<3>::loc(2);

Well, this approach worked fine until I changed the code so that the
integer is not known until runtime. So the question is...
Is there a way to do the same at runtime without having a switch or if
statement? Is there a way to do function overloading at runtime? I
thought that I could have something like the following:

struct SomeClass {

int val;
SomeClass(int v) : val(v) {}

double loc(unsigned short i) {
return locImpl(classB(val),i);
}
double locImpl(classB(1), int i) {
const double SomeClass<1>::loc_[] = { 0.4};
return loc_;
}
double locImpl(classB(2), int i) {
const double SomeClass<2>::loc_[] = { 0.2, 0.6 };
return loc_;
}

};

and convert the integer to some class and rely on function
overloading, but I couldn't find a way to do this. Any ideas? Thank
you,

a²

map< int, vector< double > > is a good approach. Beyond it you can try
to use boost\preprocessor. Like this:

#define LocItem(z, n, ...) SomeClass<n+1>::loc_,
const double* locs[] =
{
BOOST_PP_REPEAT(30, LocItem,)

};

double loc(int v, unsigned short i)
{
return locs[v - 1]

}

I suppose v is from 1 to 30.

The problem with using a map is that it needs to be instantiated with
every element in it (all vectors needed to be created). I wanted to
use a function because in that way only the vectors that I use are
initialized. Most likely, I will be using only 1 of those 30 vectors
for each run, so it doesn't make sense to initialize ALL of them. Any
other ideas?

 

[jkherciueh]

I have this scenario: several arrays for which I have their fixed
values at compilation time. Now, at runtime I need to access a
specific array depending on an integer but I want to avoid if and
switch statements.

My first approach was to rely on partial template specialization.
Therefore, I have:

// .h file
template <int v> SomeClass;

template <> struct SomeClass<1> {
static double loc(unsigned short i) {
return loc_;
}
static const double loc_[1];};

template <> struct SomeClass<2> {
static double loc(unsigned short i) {
return loc_;
}
static const double loc_[2];};

// and so on until 30 partial specializations

// .cpp file
const double SomeClass<1>::loc_[] = { 0.4 };
const double SomeClass<2>::loc_[] = { 0.2, 0.6 };
// and so on until 30 partial specializations

so I called the function like this:

double location = SomeClass<3>::loc(2);

Well, this approach worked fine until I changed the code so that the
integer is not known until runtime. So the question is...
Is there a way to do the same at runtime without having a switch or if
statement? Is there a way to do function overloading at runtime? I
thought that I could have something like the following:

struct SomeClass {

int val;
SomeClass(int v) : val(v) {}

double loc(unsigned short i) {
return locImpl(classB(val),i);
}
double locImpl(classB(1), int i) {
const double SomeClass<1>::loc_[] = { 0.4};
return loc_;
}
double locImpl(classB(2), int i) {
const double SomeClass<2>::loc_[] = { 0.2, 0.6 };
return loc_;
}

};

and convert the integer to some class and rely on function
overloading, but I couldn't find a way to do this. Any ideas? Thank
you,

a²

map< int, vector< double > > is a good approach. Beyond it you can try
to use boost\preprocessor. Like this:

#define LocItem(z, n, ...) SomeClass<n+1>::loc_,
const double* locs[] =
{
BOOST_PP_REPEAT(30, LocItem,)

};

double loc(int v, unsigned short i)
{
return locs[v - 1]

}

I suppose v is from 1 to 30.

The problem with using a map is that it needs to be instantiated with
every element in it (all vectors needed to be created).

Huh? What makes you think that?

std::map< int, std::vector<double> > the_map;

creates an empty map. The expression

the_map

returns a reference to a vector<double> and this vector will be created (and
default initialized) at the first time a particular value for i is used. No
vectors will be created for indices that are not used.

I wanted to
use a function because in that way only the vectors that I use are
initialized. Most likely, I will be using only 1 of those 30 vectors
for each run, so it doesn't make sense to initialize ALL of them.

If you only use i=5, then only that map-entry will exist and no other
vectors will be created.

[snip]


Best

Kai-Uwe Bux

 

[Daniel T.]

The problem with using a map is that it needs to be instantiated
with every element in it (all vectors needed to be created). I
wanted to use a function because in that way only the vectors that
I use are initialized. Most likely, I will be using only 1 of those
30 vectors for each run, so it doesn't make sense to initialize ALL
of them.

Unless a single run is extremely fast, and you will be running this
program thousands of times per second, the extra time it take to
initialize all of the vectors is irrelevant. And if the run is extremely
fast and you are running the program thousands of times per second, then
you should be embedding this code in a program that makes several passes
per run.

So yes, it does make sense to initialize all of them.

 

[aaragon]

Unless a single run is extremely fast, and you will be running this
program thousands of times per second, the extra time it take to
initialize all of the vectors is irrelevant. And if the run is extremely
fast and you are running the program thousands of times per second, then
you should be embedding this code in a program that makes several passes
per run.

So yes, it does make sense to initialize all of them.

Ok, so I decided to follow your advice but with a little twist.
Instead of having a map to a vector, I will have now a map to function
pointers. Inside those functions the arrays (known at compilation
time) are declared static so they're initialized only once (when I
call the function the first time). In this way, I don't need to
initialize what I won't use. Also, I don'tneed to have annoying switch
or if blocks. It looks like this:

// .h file
template <int v>
double loc(size_t);
// forward declarations of function specializations (defined in .cxx
file)
template <>
double loc<1>(size_t);
template <>
double loc<2>(size_t);
// and so on

template <
struct Map {

typedef MapPolicy MapType;
MapType loc_;

Map() : loc_() {
// add location function pointers
loc_[1] = &loc<1>; // ERROR!!!
loc_[2] = &loc<2>; // ERROR!!!
// and so on
}
inline double loc(size_t i, size_t gp) {
return loc_[gp](i);
}
};

// .cxx file, partial specializations for the function
template<>
double loc<1>(size_t i) {
static const double loc[] = { 0.4 };
return loc;
}
template<>
double loc<2>(size_t i) {
static const double loc[] = { 0.2, 0.6 };
return loc;
}
// and so on until 30

Ok, this looks good and it's just what I want. However, for some
strange reason that I really don't see, I cannot compile this code. At
those ERROR lines I have the following message:

testMap.h: In constructor 'fea::Map<MapPolicy>::Map()':
testMap.h:36: error: expected primary-expression before ';' token

It doesn't allow me to take the address of the templated function. The
strange thing is that I can do the same from the main.cxx file, that
is:

// main.cxx

std::map<size_t, double (*)(size_t)> location;

location[1] = &loc<1>;
location[2] = &loc<2>;

cout<<"what the -> "<<location[2](1)<<endl;

works fine! Is this a problem with my compiler or there is something
wrong with the syntax? I'm using gcc version 4.1.2. I know, I know...
I could just use regular functions and call them loc1, loc2 and so on
and forget about the template (this will definitely work), but hey,
I'm learning day by day and I just cannot give up that easily, right?

a²

 

[aaragon]

Unless a single run is extremely fast, and you will be running this
program thousands of times per second, the extra time it take to
initialize all of the vectors is irrelevant. And if the run is extremely
fast and you are running the program thousands of times per second, then
you should be embedding this code in a program that makes several passes
per run.

So yes, it does make sense to initialize all of them.

Ok, so I decided to follow your advice but with a little twist.
Instead of having a map to a vector, I will have now a map to function
pointers. Inside those functions the arrays (known at compilation
time) are declared static so they're initialized only once (when I
call the function the first time). In this way, I don't need to
initialize what I won't use. Also, I don'tneed to have annoying switch
or if blocks. It looks like this:

// .h file
template <int v>
double loc(size_t);
// forward declarations of function specializations (defined in .cxx
file)
template <>
double loc<1>(size_t);
template <>
double loc<2>(size_t);
// and so on

template <
class MapPolicy = std::map<size_t, double (*)(size_t)>

struct Map {

typedef MapPolicy MapType;
MapType loc_;

Map() : loc_() {
// add location function pointers
loc_[1] = &loc<1>; // ERROR!!!
loc_[2] = &loc<2>; // ERROR!!!
// and so on
}
inline double loc(size_t i, size_t gp) {
return loc_[gp](i);
}

};

// .cxx file, partial specializations for the function
template<>
double loc<1>(size_t i) {
static const double loc[] = { 0.4 };
return loc;}

template<>
double loc<2>(size_t i) {
static const double loc[] = { 0.2, 0.6 };
return loc;}

// and so on until 30

Ok, this looks good and it's just what I want. However, for some
strange reason that I really don't see, I cannot compile this code. At
those ERROR lines I have the following message:

testMap.h: In constructor 'fea::Map<MapPolicy>::Map()':
testMap.h:36: error: expected primary-expression before ';' token

It doesn't allow me to take the address of the templated function. The
strange thing is that I can do the same from the main.cxx file, that
is:

// main.cxx

std::map<size_t, double (*)(size_t)> location;

location[1] = &loc<1>;
location[2] = &loc<2>;

cout<<"what the -> "<<location[2](1)<<endl;

works fine! Is this a problem with my compiler or there is something
wrong with the syntax? I'm using gcc version 4.1.2. I know, I know...
I could just use regular functions and call them loc1, loc2 and so on
and forget about the template (this will definitely work), but hey,
I'm learning day by day and I just cannot give up that easily, right?

a²

Ok, I know you guys hate when people post twice, but there is no edit
button here. Strange that it seems to me, I solved the problem by
adding the namespace at the front of the function. Why did they came
up with this rule? I don't have a clue. Anyways, I think I finally got
what I wanted, this is actually cool stuff! Thank you all for the
help...

a²

 

[fl]

Ok, so I decided to follow your advice but with a little twist.
Instead of having a map to a vector, I will have now a map to function
pointers. Inside those functions the arrays (known at compilation
time) are declared static so they're initialized only once (when I
call the function the first time). In this way, I don't need to
initialize what I won't use. Also, I don'tneed to have annoying switch
or if blocks. It looks like this:

// .h file
template <int v>
double loc(size_t);
// forward declarations of function specializations (defined in .cxx
file)
template <>
double loc<1>(size_t);
template <>
double loc<2>(size_t);
// and so on

Hi,
It is interesting. Could you fill the specific contents of the <>, so
I can learn something from you? Thanks a lot.

template <???????>
double loc<1>(size_t); // Really it is loc<1>?
template <???????>
double loc<2>(size_t);

template <
class MapPolicy = std::map<size_t, double (*)(size_t)>

struct Map {

  typedef MapPolicy MapType;
  MapType loc_;

  Map() : loc_() {
  // add location function pointers
  loc_[1] = &loc<1>;    // ERROR!!!
  loc_[2] = &loc<2>;    // ERROR!!!
  // and so on
  }
  inline double loc(size_t i, size_t gp) {
    return loc_[gp](i);
  }

};

// .cxx file, partial specializations for the function
template<>
double loc<1>(size_t i) {
  static const double loc[] = { 0.4 };
  return loc;}

template<>
double loc<2>(size_t i) {
  static const double loc[] = { 0.2, 0.6 };
  return loc;}

// and so on until 30

Ok, this looks good and it's just what I want. However, for some
strange reason that I really don't see, I cannot compile this code. At
those ERROR lines I have the following message:

testMap.h: In constructor 'fea::Map<MapPolicy>::Map()':
testMap.h:36: error: expected primary-expression before ';' token

It doesn't allow me to take the address of the templated function. The
strange thing is that I can do the same from the main.cxx file, that
is:

// main.cxx

    std::map<size_t, double (*)(size_t)> location;

    location[1] = &loc<1>;
    location[2] = &loc<2>;

    cout<<"what the -> "<<location[2](1)<<endl;

works fine! Is this a problem with my compiler or there is something
wrong with the syntax? I'm using gcc version 4.1.2. I know, I know...
I could just use regular functions and call them loc1, loc2 and so on
and forget about the template (this will definitely work), but hey,
I'm learning day by day and I just cannot give up that easily, right?

a²- Masquer le texte des messages précédents -

- Afficher le texte des messages précédents -

 

[aaragon]

Ok, so I decided to follow your advice but with a little twist.
Instead of having a map to a vector, I will have now a map to function
pointers. Inside those functions the arrays (known at compilation
time) are declared static so they're initialized only once (when I
call the function the first time). In this way, I don't need to
initialize what I won't use. Also, I don'tneed to have annoying switch
or if blocks. It looks like this:

// .h file
template <int v>
double loc(size_t);
// forward declarations of function specializations (defined in .cxx
file)
template <>
double loc<1>(size_t);
template <>
double loc<2>(size_t);
// and so on

Hi,
It is interesting. Could you fill the specific contents of the <>, so
I can learn something from you? Thanks a lot.

template <???????>
double loc<1>(size_t); // Really it is loc<1>?
template <???????>
double loc<2>(size_t);

template <
class MapPolicy = std::map<size_t, double (*)(size_t)>

struct Map {

typedef MapPolicy MapType;
MapType loc_;

Map() : loc_() {
// add location function pointers
loc_[1] = &loc<1>; // ERROR!!!
loc_[2] = &loc<2>; // ERROR!!!
// and so on
}
inline double loc(size_t i, size_t gp) {
return loc_[gp](i);
}

};

// .cxx file, partial specializations for the function
template<>
double loc<1>(size_t i) {
static const double loc[] = { 0.4 };
return loc;}

template<>
double loc<2>(size_t i) {
static const double loc[] = { 0.2, 0.6 };
return loc;}

// and so on until 30

Ok, this looks good and it's just what I want. However, for some
strange reason that I really don't see, I cannot compile this code. At
those ERROR lines I have the following message:

testMap.h: In constructor 'fea::Map<MapPolicy>::Map()':
testMap.h:36: error: expected primary-expression before ';' token

It doesn't allow me to take the address of the templated function. The
strange thing is that I can do the same from the main.cxx file, that
is:

// main.cxx

std::map<size_t, double (*)(size_t)> location;

location[1] = &loc<1>;
location[2] = &loc<2>;

cout<<"what the -> "<<location[2](1)<<endl;

works fine! Is this a problem with my compiler or there is something
wrong with the syntax? I'm using gcc version 4.1.2. I know, I know...
I could just use regular functions and call them loc1, loc2 and so on
and forget about the template (this will definitely work), but hey,
I'm learning day by day and I just cannot give up that easily, right?

a²- Masquer le texte des messages précédents -

- Afficher le texte des messages précédents -

Well, this is just a function templated by an integer constant that is
known at compilation time. So you can have the same function for
different values of the integer value. So first declare the function
but don't define it:

template <int v>
double loc(size_t);

and then using template specialization you can have as many functions
as you want with the same name:

template <>
double loc<1>(size_t) { // yes, it is actually loc<1>
// do whatever you want to do here
}
// and the same for all other functions

Then you can call the functions just by using

cout<<"using loc<1>: "<<loc<1>(5)<<endl;

The cool thing is that the map maps integer to function pointers, and
these execute the right function. I wanted to do this because I have
very big arrays to be initialized but for a particular run I don't use
them all. Therefore, it didn't make sense to me to initialize all of
them. So, I declared the known arrays as static arrays inside the
functions so they are initialized only once. And the best part, is
that those functions that I don't use, don't initialize any arrays...
=)
This is just what I was looking for.

Cheers,

a²

 

[fl]

Unless a single run is extremely fast, and you will be running this
program thousands of times per second, the extra time it take to
initialize all of the vectors is irrelevant. And if the run is extremely
fast and you are running the program thousands of times per second, then
you should be embedding this code in a program that makes several passes
per run.

So yes, it does make sense to initialize all of them.

Ok, so I decided to follow your advice but with a little twist.
Instead of having a map to a vector, I will have now a map to function
pointers. Inside those functions the arrays (known at compilation
time) are declared static so they're initialized only once (when I
call the function the first time). In this way, I don't need to
initialize what I won't use. Also, I don'tneed to have annoying switch
or if blocks. It looks like this:

// .h file
template <int v>
double loc(size_t);
// forward declarations of function specializations (defined in .cxx
file)
template <>
double loc<1>(size_t);
template <>
double loc<2>(size_t);
// and so on

template <
class MapPolicy = std::map<size_t, double (*)(size_t)>

struct Map {

  typedef MapPolicy MapType;
  MapType loc_;

  Map() : loc_() {
  // add location function pointers
  loc_[1] = &loc<1>;    // ERROR!!!
  loc_[2] = &loc<2>;    // ERROR!!!
  // and so on
  }
  inline double loc(size_t i, size_t gp) {
    return loc_[gp](i);
  }

};

// .cxx file, partial specializations for the function
template<>
double loc<1>(size_t i) {
  static const double loc[] = { 0.4 };
  return loc;}

template<>
double loc<2>(size_t i) {
  static const double loc[] = { 0.2, 0.6 };
  return loc;}

// and so on until 30

Ok, this looks good and it's just what I want. However, for some
strange reason that I really don't see, I cannot compile this code. At
those ERROR lines I have the following message:

testMap.h: In constructor 'fea::Map<MapPolicy>::Map()':
testMap.h:36: error: expected primary-expression before ';' token

It doesn't allow me to take the address of the templated function. The
strange thing is that I can do the same from the main.cxx file, that
is:

// main.cxx

    std::map<size_t, double (*)(size_t)> location;

    location[1] = &loc<1>;
    location[2] = &loc<2>;

    cout<<"what the -> "<<location[2](1)<<endl;

works fine! Is this a problem with my compiler or there is something
wrong with the syntax? I'm using gcc version 4.1.2. I know, I know...
I could just use regular functions and call them loc1, loc2 and so on
and forget about the template (this will definitely work), but hey,
I'm learning day by day and I just cannot give up that easily, right?

a²- Masquer le texte des messages précédents -

- Afficher le texte des messages précédents -

Hi,
I get the following error message. Why? What's wrong with me? Thanks.



error C2039:'map' is not a member of 'std'
----------------
// .h file
#include <iostream>

template <int v> double loc(size_t); // forward declarations of
function specializations (defined in .cxx file)
template <> double loc<1>(size_t);
template <> double loc<2>(size_t); // and so on
------------
#include <iostream>
#include "SomeClass.h"
using std::cout;
using std::endl;

int main()
{
std::map<size_t, double (*)(size_t)> location;

location[1] = &loc<1>;
location[2] = &loc<2>;
cout<<"using loc<1>: "<<loc<1>(1)<<endl;

return 0;
}

 

[jkherciueh]

On Dec 29, 10:52 am, "Daniel T." <[email protected]> wrote:

The problem with using a map is that it needs to be instantiated
with every element in it (all vectors needed to be created). I
wanted to use a function because in that way only the vectors that
I use are initialized. Most likely, I will be using only 1 of those
30 vectors for each run, so it doesn't make sense to initialize ALL
of them.

Unless a single run is extremely fast, and you will be running this
program thousands of times per second, the extra time it take to
initialize all of the vectors is irrelevant. And if the run is
extremely fast and you are running the program thousands of times per
second, then you should be embedding this code in a program that
makes several passes per run.

So yes, it does make sense to initialize all of them.

Ok, so I decided to follow your advice but with a little twist.
Instead of having a map to a vector, I will have now a map to function
pointers. Inside those functions the arrays (known at compilation
time) are declared static so they're initialized only once (when I
call the function the first time). In this way, I don't need to
initialize what I won't use. Also, I don'tneed to have annoying switch
or if blocks. It looks like this:

// .h file
template <int v>
double loc(size_t);
// forward declarations of function specializations (defined in .cxx
file)
template <>
double loc<1>(size_t);
template <>
double loc<2>(size_t);
// and so on

Hi,
It is interesting. Could you fill the specific contents of the <>, so
I can learn something from you? Thanks a lot.

template <???????>
double loc<1>(size_t); // Really it is loc<1>?
template <???????>
double loc<2>(size_t);

template <
class MapPolicy = std::map<size_t, double (*)(size_t)>

struct Map {

typedef MapPolicy MapType;
MapType loc_;

Map() : loc_() {
// add location function pointers
loc_[1] = &loc<1>; // ERROR!!!
loc_[2] = &loc<2>; // ERROR!!!
// and so on
}
inline double loc(size_t i, size_t gp) {
return loc_[gp](i);
}

};

// .cxx file, partial specializations for the function
template<>
double loc<1>(size_t i) {
static const double loc[] = { 0.4 };
return loc;}

template<>
double loc<2>(size_t i) {
static const double loc[] = { 0.2, 0.6 };
return loc;}

// and so on until 30

Ok, this looks good and it's just what I want. However, for some
strange reason that I really don't see, I cannot compile this code. At
those ERROR lines I have the following message:

testMap.h: In constructor 'fea::Map<MapPolicy>::Map()':
testMap.h:36: error: expected primary-expression before ';' token

It doesn't allow me to take the address of the templated function. The
strange thing is that I can do the same from the main.cxx file, that
is:

// main.cxx

std::map<size_t, double (*)(size_t)> location;

location[1] = &loc<1>;
location[2] = &loc<2>;

cout<<"what the -> "<<location[2](1)<<endl;

works fine! Is this a problem with my compiler or there is something
wrong with the syntax? I'm using gcc version 4.1.2. I know, I know...
I could just use regular functions and call them loc1, loc2 and so on
and forget about the template (this will definitely work), but hey,
I'm learning day by day and I just cannot give up that easily, right?

a²- Masquer le texte des messages précédents -

- Afficher le texte des messages précédents -

Well, this is just a function templated by an integer constant that is
known at compilation time. So you can have the same function for
different values of the integer value. So first declare the function
but don't define it:

template <int v>
double loc(size_t);

and then using template specialization you can have as many functions
as you want with the same name:

template <>
double loc<1>(size_t) { // yes, it is actually loc<1>
// do whatever you want to do here
}
// and the same for all other functions

Then you can call the functions just by using

cout<<"using loc<1>: "<<loc<1>(5)<<endl;

The cool thing is that the map maps integer to function pointers, and
these execute the right function. I wanted to do this because I have
very big arrays to be initialized but for a particular run I don't use
them all. Therefore, it didn't make sense to me to initialize all of
them. So, I declared the known arrays as static arrays inside the
functions so they are initialized only once. And the best part, is
that those functions that I don't use, don't initialize any arrays...
=)
This is just what I was looking for.

Hm. Although it is true that those functions that you don't execute don't
initialize arrays, it is still the case that the executable will contain
all the data that would be needed to initialize the arrays (after all, the
compiler cannot predict which array will be used at run-time). The actual
initialization of the array is probably a null-op since the compiler
already made the array reside in the data segment of the executable.


In order to access the one array that you actually need, the map will
perform a search that is going to use roughly 5 comparisons (given that
there are about 30 function pointers).

I would consider _faking_ the existence of several arrays:

struct double2d {

static
double const * begin ( unsigned int i ) {
static const double d [] =
{
0.1,
0.2, 0.3, 0.4,
0.2, 0.5
};
static const unsigned arr [] =
{ 0, 1, 4, 6 };
return ( &d[0] + arr );
}

static
double const * end ( unsigned int i ) {
return ( begin(i+1) );
}

static
unsigned int size ( void ) {
return ( 3 );
}

};

#include <iostream>
#include <algorithm>
#include <iterator>

int main ( void ) {
for ( unsigned int i = 0; i < double2d::size(); ++i ) {
std::copy( double2d::begin(i), double2d::end(i),
std:stream_iterator<double>( std::cout, " " ) );
std::cout << '\n';
}
}


Best

Kai-Uwe Bux

 

[aaragon]

The problem with using a map is that it needs to be instantiated
with every element in it (all vectors needed to be created). I
wanted to use a function because in that way only the vectors that
I use are initialized. Most likely, I will be using only 1 of those
30 vectors for each run, so it doesn't make sense to initialize ALL
of them.
Unless a single run is extremely fast, and you will be running this
program thousands of times per second, the extra time it take to
initialize all of the vectors is irrelevant. And if the run is
extremely fast and you are running the program thousands of times per
second, then you should be embedding this code in a program that
makes several passes per run.
So yes, it does make sense to initialize all of them.
Ok, so I decided to follow your advice but with a little twist.
Instead of having a map to a vector, I will have now a map to function
pointers. Inside those functions the arrays (known at compilation
time) are declared static so they're initialized only once (when I
call the function the first time). In this way, I don't need to
initialize what I won't use. Also, I don'tneed to have annoying switch
or if blocks. It looks like this:
// .h file
template <int v>
double loc(size_t);
// forward declarations of function specializations (defined in .cxx
file)
template <>
double loc<1>(size_t);
template <>
double loc<2>(size_t);
// and so on
Hi,
It is interesting. Could you fill the specific contents of the <>, so
I can learn something from you? Thanks a lot.
template <???????>
double loc<1>(size_t); // Really it is loc<1>?
template <???????>
double loc<2>(size_t);
template <
class MapPolicy = std::map<size_t, double (*)(size_t)>
struct Map {
typedef MapPolicy MapType;
MapType loc_;
Map() : loc_() {
// add location function pointers
loc_[1] = &loc<1>; // ERROR!!!
loc_[2] = &loc<2>; // ERROR!!!
// and so on
}
inline double loc(size_t i, size_t gp) {
return loc_[gp](i);
}
};
// .cxx file, partial specializations for the function
template<>
double loc<1>(size_t i) {
static const double loc[] = { 0.4 };
return loc;}
template<>
double loc<2>(size_t i) {
static const double loc[] = { 0.2, 0.6 };
return loc;}
// and so on until 30
Ok, this looks good and it's just what I want. However, for some
strange reason that I really don't see, I cannot compile this code. At
those ERROR lines I have the following message:
testMap.h: In constructor 'fea::Map<MapPolicy>::Map()':
testMap.h:36: error: expected primary-expression before ';' token
It doesn't allow me to take the address of the templated function. The
strange thing is that I can do the same from the main.cxx file, that
is:
// main.cxx
std::map<size_t, double (*)(size_t)> location;
location[1] = &loc<1>;
location[2] = &loc<2>;
cout<<"what the -> "<<location[2](1)<<endl;
works fine! Is this a problem with my compiler or there is something
wrong with the syntax? I'm using gcc version 4.1.2. I know, I know...
I could just use regular functions and call them loc1, loc2 and so on
and forget about the template (this will definitely work), but hey,
I'm learning day by day and I just cannot give up that easily, right?
a²- Masquer le texte des messages précédents -
- Afficher le texte des messages précédents -

Well, this is just a function templated by an integer constant that is
known at compilation time. So you can have the same function for
different values of the integer value. So first declare the function
but don't define it:

template <int v>
double loc(size_t);

and then using template specialization you can have as many functions
as you want with the same name:

template <>
double loc<1>(size_t) { // yes, it is actually loc<1>
// do whatever you want to do here
}
// and the same for all other functions

Then you can call the functions just by using

cout<<"using loc<1>: "<<loc<1>(5)<<endl;

The cool thing is that the map maps integer to function pointers, and
these execute the right function. I wanted to do this because I have
very big arrays to be initialized but for a particular run I don't use
them all. Therefore, it didn't make sense to me to initialize all of
them. So, I declared the known arrays as static arrays inside the
functions so they are initialized only once. And the best part, is
that those functions that I don't use, don't initialize any arrays...
=)
This is just what I was looking for.

Hm. Although it is true that those functions that you don't execute don't
initialize arrays, it is still the case that the executable will contain
all the data that would be needed to initialize the arrays (after all, the
compiler cannot predict which array will be used at run-time). The actual
initialization of the array is probably a null-op since the compiler
already made the array reside in the data segment of the executable.

In order to access the one array that you actually need, the map will
perform a search that is going to use roughly 5 comparisons (given that
there are about 30 function pointers).

I would consider _faking_ the existence of several arrays:

struct double2d {

static
double const * begin ( unsigned int i ) {
static const double d [] =
{
0.1,
0.2, 0.3, 0.4,
0.2, 0.5
};
static const unsigned arr [] =
{ 0, 1, 4, 6 };
return ( &d[0] + arr );
}

static
double const * end ( unsigned int i ) {
return ( begin(i+1) );
}

static
unsigned int size ( void ) {
return ( 3 );
}

};

#include <iostream>
#include <algorithm>
#include <iterator>

int main ( void ) {
for ( unsigned int i = 0; i < double2d::size(); ++i ) {
std::copy( double2d::begin(i), double2d::end(i),
std:stream_iterator<double>( std::cout, " " ) );
std::cout << '\n';
}

}

Best

Kai-Uwe Bux

Nope, that doesn't work for me. Imagine that you have to expand that
vector 30 times, the first array has only 1 element and the last one
has 30. It can be done, but why initialize the entire thing if it
won't be used? The memory in your approach is the same (the executable
will have the same size) but the run time will be much less if I only
initialize what I need.

Now I'm actually trying to initialize the static map with a function
to remove the constructor initialization. Why? Well, I thought it
would be cool if I actually don't need a type to call the loc
function, that is, to make that function also static.

Cheers!

a²

 

[aaragon]

Ok, so I decided to follow your advice but with a little twist.
Instead of having a map to a vector, I will have now a map to function
pointers. Inside those functions the arrays (known at compilation
time) are declared static so they're initialized only once (when I
call the function the first time). In this way, I don't need to
initialize what I won't use. Also, I don'tneed to have annoying switch
or if blocks. It looks like this:

// .h file
template <int v>
double loc(size_t);
// forward declarations of function specializations (defined in .cxx
file)
template <>
double loc<1>(size_t);
template <>
double loc<2>(size_t);
// and so on

template <
class MapPolicy = std::map<size_t, double (*)(size_t)>

struct Map {

typedef MapPolicy MapType;
MapType loc_;

Map() : loc_() {
// add location function pointers
loc_[1] = &loc<1>; // ERROR!!!
loc_[2] = &loc<2>; // ERROR!!!
// and so on
}
inline double loc(size_t i, size_t gp) {
return loc_[gp](i);
}

};

// .cxx file, partial specializations for the function
template<>
double loc<1>(size_t i) {
static const double loc[] = { 0.4 };
return loc;}

template<>
double loc<2>(size_t i) {
static const double loc[] = { 0.2, 0.6 };
return loc;}

// and so on until 30

Ok, this looks good and it's just what I want. However, for some
strange reason that I really don't see, I cannot compile this code. At
those ERROR lines I have the following message:

testMap.h: In constructor 'fea::Map<MapPolicy>::Map()':
testMap.h:36: error: expected primary-expression before ';' token

It doesn't allow me to take the address of the templated function. The
strange thing is that I can do the same from the main.cxx file, that
is:

// main.cxx

std::map<size_t, double (*)(size_t)> location;

location[1] = &loc<1>;
location[2] = &loc<2>;

cout<<"what the -> "<<location[2](1)<<endl;

works fine! Is this a problem with my compiler or there is something
wrong with the syntax? I'm using gcc version 4.1.2. I know, I know...
I could just use regular functions and call them loc1, loc2 and so on
and forget about the template (this will definitely work), but hey,
I'm learning day by day and I just cannot give up that easily, right?

a²- Masquer le texte des messages précédents -

- Afficher le texte des messages précédents -

Hi,
I get the following error message. Why? What's wrong with me? Thanks.

error C2039:'map' is not a member of 'std'
----------------
// .h file
#include <iostream>

template <int v> double loc(size_t); // forward declarations of
function specializations (defined in .cxx file)
template <> double loc<1>(size_t);
template <> double loc<2>(size_t); // and so on
------------
#include <iostream>
#include "SomeClass.h"
using std::cout;
using std::endl;

int main()
{
std::map<size_t, double (*)(size_t)> location;

location[1] = &loc<1>;
location[2] = &loc<2>;
cout<<"using loc<1>: "<<loc<1>(1)<<endl;

return 0;

}

You forgot to put 'using std::map;' or just put 'using namespace std;'
and don't forget to implement the actual loc<v> functions in the cpp
file.

a²

 

[jkherciueh]

On 29 déc, 15:09, aaragon <[email protected]> wrote:

On Dec 29, 10:52 am, "Daniel T." <[email protected]> wrote:

The problem with using a map is that it needs to be instantiated
with every element in it (all vectors needed to be created). I
wanted to use a function because in that way only the vectors
that I use are initialized. Most likely, I will be using only 1
of those 30 vectors for each run, so it doesn't make sense to
initialize ALL of them.

Unless a single run is extremely fast, and you will be running
this program thousands of times per second, the extra time it take
to initialize all of the vectors is irrelevant. And if the run is
extremely fast and you are running the program thousands of times
per second, then you should be embedding this code in a program
that makes several passes per run.

So yes, it does make sense to initialize all of them.

Ok, so I decided to follow your advice but with a little twist.
Instead of having a map to a vector, I will have now a map to
function pointers. Inside those functions the arrays (known at
compilation time) are declared static so they're initialized only
once (when I call the function the first time). In this way, I don't
need to initialize what I won't use. Also, I don'tneed to have
annoying switch or if blocks. It looks like this:

// .h file
template <int v>
double loc(size_t);
// forward declarations of function specializations (defined in .cxx
file)
template <>
double loc<1>(size_t);
template <>
double loc<2>(size_t);
// and so on

Hi,
It is interesting. Could you fill the specific contents of the <>, so
I can learn something from you? Thanks a lot.

template <???????>
double loc<1>(size_t); // Really it is loc<1>?
template <???????>
double loc<2>(size_t);

template <
class MapPolicy = std::map<size_t, double (*)(size_t)>

struct Map {

typedef MapPolicy MapType;
MapType loc_;

Map() : loc_() {
// add location function pointers
loc_[1] = &loc<1>; // ERROR!!!
loc_[2] = &loc<2>; // ERROR!!!
// and so on
}
inline double loc(size_t i, size_t gp) {
return loc_[gp](i);
}

};

// .cxx file, partial specializations for the function
template<>
double loc<1>(size_t i) {
static const double loc[] = { 0.4 };
return loc;}

template<>
double loc<2>(size_t i) {
static const double loc[] = { 0.2, 0.6 };
return loc;}

// and so on until 30

Ok, this looks good and it's just what I want. However, for some
strange reason that I really don't see, I cannot compile this code.
At those ERROR lines I have the following message:

testMap.h: In constructor 'fea::Map<MapPolicy>::Map()':
testMap.h:36: error: expected primary-expression before ';' token

It doesn't allow me to take the address of the templated function.
The strange thing is that I can do the same from the main.cxx file,
that is:

// main.cxx

std::map<size_t, double (*)(size_t)> location;

location[1] = &loc<1>;
location[2] = &loc<2>;

cout<<"what the -> "<<location[2](1)<<endl;

works fine! Is this a problem with my compiler or there is something
wrong with the syntax? I'm using gcc version 4.1.2. I know, I
know... I could just use regular functions and call them loc1, loc2
and so on and forget about the template (this will definitely work),
but hey, I'm learning day by day and I just cannot give up that
easily, right?

a²- Masquer le texte des messages précédents -

- Afficher le texte des messages précédents -

Well, this is just a function templated by an integer constant that is
known at compilation time. So you can have the same function for
different values of the integer value. So first declare the function
but don't define it:

template <int v>
double loc(size_t);

and then using template specialization you can have as many functions
as you want with the same name:

template <>
double loc<1>(size_t) { // yes, it is actually loc<1>
// do whatever you want to do here
}
// and the same for all other functions

Then you can call the functions just by using

cout<<"using loc<1>: "<<loc<1>(5)<<endl;

The cool thing is that the map maps integer to function pointers, and
these execute the right function. I wanted to do this because I have
very big arrays to be initialized but for a particular run I don't use
them all. Therefore, it didn't make sense to me to initialize all of
them. So, I declared the known arrays as static arrays inside the
functions so they are initialized only once. And the best part, is
that those functions that I don't use, don't initialize any arrays...
=)
This is just what I was looking for.

Hm. Although it is true that those functions that you don't execute don't
initialize arrays, it is still the case that the executable will contain
all the data that would be needed to initialize the arrays (after all,
the compiler cannot predict which array will be used at run-time). The
actual initialization of the array is probably a null-op since the
compiler already made the array reside in the data segment of the
executable.

In order to access the one array that you actually need, the map will
perform a search that is going to use roughly 5 comparisons (given that
there are about 30 function pointers).

I would consider _faking_ the existence of several arrays:

struct double2d {

static
double const * begin ( unsigned int i ) {
static const double d [] =
{
0.1,
0.2, 0.3, 0.4,
0.2, 0.5
};
static const unsigned arr [] =
{ 0, 1, 4, 6 };
return ( &d[0] + arr );
}

static
double const * end ( unsigned int i ) {
return ( begin(i+1) );
}

static
unsigned int size ( void ) {
return ( 3 );
}

};

#include <iostream>
#include <algorithm>
#include <iterator>

int main ( void ) {
for ( unsigned int i = 0; i < double2d::size(); ++i ) {
std::copy( double2d::begin(i), double2d::end(i),
std:stream_iterator<double>( std::cout, " " ) );
std::cout << '\n';
}

}

Best

Kai-Uwe Bux

Nope, that doesn't work for me. Imagine that you have to expand that
vector 30 times, the first array has only 1 element and the last one
has 30. It can be done, but why initialize the entire thing if it
won't be used? The memory in your approach is the same (the executable
will have the same size) but the run time will be much less if I only
initialize what I need.

I suggest you test that hypothesis by measuring. I bet, you will be
surprised.

You agreed that the size of the executable will be the same. How do you
think the data is encoded in the executable? It's just a binary dump of the
daty. Initialization of the variables d and arr above is probably a
null-op: the variable d will physically be placed whereever the program
loader has put the binary dump of the array from the executable. It doesn't
get any faster than that.

You seem to assume that after loading the executable into memory, there will
be a actual code executed copying the data into some other part of memory
thereby initializing d and arr. I strongly doubt that.


[snip]


Best

Kai-Uwe Bux

 

[Daniel T.]

The memory in your approach is the same (the executable
will have the same size) but the run time will be much less if I only
initialize what I need.

"More computing sins are committed in the name of efficiency (without
necessarily achieving it) than for any other single reason - including
blind stupidity." - W.A. Wulf

How much less is "much less"?