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 vSomeClass;

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

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

so I called the function like this:

double location = SomeClass<3>::l oc(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>::l oc_[] = { 0.4};
return loc_[i];
}
double locImpl(classB( 2), int i) {
const double SomeClass<2>::l oc_[] = { 0.2, 0.6 };
return loc_[i];
}
};

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.]

aaragon <al************ **@gmail.comwro te:

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.]

On 12月29æ—¥, 上å�ˆ11æ—¶08åˆ †, aaragon<alejand ro.ara...@gmail .comwrote:

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 vSomeClass;

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

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

// and so on until 30 partial specializations

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

so I called the function like this:

double location = SomeClass<3>::l oc(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>::l oc_[] = { 0.4};
Â* Â* return loc_[i];
Â* }
Â* double locImpl(classB( 2), int i) {
Â* Â* const double SomeClass<2>::l oc_[] = { 0.2, 0.6 };
Â* Â* return loc_[i];
Â* }

};

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\preproces sor. 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]
}

I suppose v is from 1 to 30.

[aaragon]

On Dec 28, 10:40 pm, "K.L." <windleaf_2...@ 163.comwrote:

On 12月29æ—¥, 上å�ˆ11æ—¶08åˆ †, aaragon <alejandro.ara. [e-mail] te:

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 vSomeClass;

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

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

// and so on until 30 partial specializations

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

so I called the function like this:

double location = SomeClass<3>::l oc(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>::l oc_[] = { 0.4};
return loc_[i];
}
double locImpl(classB( 2), int i) {
const double SomeClass<2>::l oc_[] = { 0.2, 0.6 };
return loc_[i];
}

};

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\preproces sor. 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]

}

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]

aaragon wrote:

On Dec 28, 10:40 pm, "K.L." <windleaf_2...@ 163.comwrote:

>On 12?29?, ??11?08?, aaragon <alejandro.ara. [e-mail] te:

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 vSomeClass;

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

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

// and so on until 30 partial specializations

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

so I called the function like this:

double location = SomeClass<3>::l oc(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>::l oc_[] = { 0.4};
return loc_[i];
}
double locImpl(classB( 2), int i) {
const double SomeClass<2>::l oc_[] = { 0.2, 0.6 };
return loc_[i];
}

};

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\preproces sor. 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]

}

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<dou ble the_map;

creates an empty map. The expression

the_map[i]

returns a reference to a vector<doublean d 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.]

aaragon <al************ **@gmail.comwro te:

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]

On Dec 29, 10:52 am, "Daniel T." <danie...@earth link.netwrote:

aaragon <alejandro.ara. [e-mail] te:

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

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[i];
}
template<>
double loc<2>(size_t i) {
static const double loc[] = { 0.2, 0.6 };
return loc[i];
}
// 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<MapPo licy>::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)loca tion;

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]

On Dec 29, 2:09 pm, aaragon <alejandro.ara. [e-mail] te:

On Dec 29, 10:52 am, "Daniel T." <danie...@earth link.netwrote:

aaragon <alejandro.ara. [e-mail] te:

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

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[i];}

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

// 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<MapPo licy>::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)loca tion;

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]

On 29 déc, 15:09, aaragon <alejandro.ara. [e-mail] te:

On Dec 29, 10:52 am, "Daniel T." <danie...@earth link.netwrote:

aaragon <alejandro.ara. [e-mail] te:

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[i];}

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

// 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<MapPo licy>::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)loca tion;

* * 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]

On Dec 29, 4:44 pm, fl <rxjw...@gmail. comwrote:

On 29 déc, 15:09, aaragon <alejandro.ara. [e-mail] te:

On Dec 29, 10:52 am, "Daniel T." <danie...@earth link.netwrote:

aaragon <alejandro.ara. [e-mail] te:
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[i];}

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

// 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<MapPo licy>::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)loca tion;

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)<<e ndl;

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²