Unfolding Constant Amount Of Arguments

Question

I want to write a simple gradient descent for a function with 5 parameters on C++. Now I stumble upon a implementation model problem: Should I sacrifice speed for folding my arguments in vector/arrays. Here is what I mean. I can implement funcition value and gradient calculation like this:

double function(double arg1, double arg2, ..., double arg5);
double functionGradient1(double arg1, double arg2, ..., double arg5);
double functionGradient2(double arg1, double arg2, ..., double arg5);
...
double functionGradient5(double arg1, double arg2, ..., double arg5);

or:

double function(double * args);
double functionGradientAt(double * args, int i);

The last one is easier to implement, however I am afraid I'll lose lots of speed if i am going to constantly allocate/free memory.

My questions are:

Which one would YOU pick?
If you ever implemented gradient descent, how did you handle the case?

Why not `double functionGradientAt(double arg1, double arg2, ..., double arg5, int i);`? — Christian Hackl, Mar 09 '15 at 10:28
I would use vectors. I don't think the speed sacrifice will be as big as you think, and it will look much nicer. — IVlad, Mar 09 '15 at 10:33
@ChristianHackl Ah yes, agreed - that one would be better, but thats not the point of the question :). — Bait Hoven, Mar 09 '15 at 13:35

score 1 · Accepted Answer · edited May 23 '17 at 11:56

Which one would YOU pick?

I would pick:

double function(const vector<double> &args);

Or if it must be from your examples, then:

double function(double * args);

The reason being that I don't believe unrolling the arguments like that adds any noticeable speedup, but it does make the code look ugly.

If you ever implemented gradient descent, how did you handle the case?

I handled it with vectors.

Gradient descent's speed will probably depend more on the number of iterations you do than on how you pass these parameters. If you want to be as fast as possible, I would suggest against implementing it yourself and instead find a library that has it implemented. This question has a lot of good suggestions for that.

That was exactly what I wanted. – Bait Hoven Mar 09 '15 at 13:35 — Bait Hoven, Mar 09 '15 at 13:35

score 0 · Answer 2 · answered Mar 09 '15 at 10:38

In both cases: double functionGradient5(double arg1, double arg2, ..., double arg5); as well as double function(double * args); you probably need the same amount of memory to be allocated. The first solution would allocate the memory in the heap the in the second you would have to handle it yourself so in would be less convenient for you, but you would be able on the other hand to iterate through the arguments so in some cases it could be better.

Unfolding Constant Amount Of Arguments

2 Answers2