Use a precomputed array or a function? [closed] - c++

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 8 years ago.
Improve this question
What's faster when compiling with GCC in C++,
using a precompute array of 2 columns and 300 rows,
or using a third grade polynomial, such as "x^3 + x^2 + x + 40"?
(Sorry for my english)
Edit:
Is faster searching in an array, (Input value the first column and output the second column.)
or using a function (The input and output of the polynomial is obvious)?
edit2:
using index

Answer 1

I think he is trying to compare the speed between a polynomial computation and a lookup table.
It depends. The lookup table is usually stored in memory and the LD instruction will be involved. If the lookup table is not cached then expect long delay from memory.
If you need to access the lookup table frequently and for multiple times, and the table is of reasonable size, try to use lookup table. it is because, very likely, the table will be cached. If you were able to store the table on stack, then do it. Since the data on stack are more likely to be cached than the data on heap.
On the other hand, if the calculation is not frequent, then using polynomial computation is fine. This can save you some memory and make your code more readable.

Answer 2

You should actually profile the code.
Polynomial Evaluation
The function is:
int Evaluate_Polynomial(int x)
{
register const int term1 = x * x * x;
register const int term2 = x * x;
register const int result = term1 + term2 + x + 40;
return result;
}
Note: In the above function, register is used to remind the compiler to use registers, even in the unoptimized version (a.k.a. debug).
Without optimization, the above function has 3 multiply operations and 3 addition operations, for a total of 6 data processing operations (not including load or store).
Table Lookup
The function is:
int Table_Lookup_Polynomial(int x)
{
int result = 0;
if ((x < 0) || (x > 300))
{
result = table[x];
}
else
{
// Handle array index out of bounds
}
return result;
}
In the above example, there is a possibility of 3 comparisons (jumps) and a pointer dereference. Verify importantly, there is a need for error handling.
Summary
The polynomial version may contain more instructions, but they are data processing instructions and can be easily inlined. They do not cause a processor's instruction cache to be reloaded.
The table lookup needs to perform boundary checking. The boundary checking will cause the processor to pause and maybe reload the instruction pipeline, which takes time. The error checking and handling may cause issues during maintenance if the range is ever changed.
The functions should be profiled to verify which algorithm is faster. The loss of time due to altering the execution flow may be longer than the pure math data processing functions of the polynomial evaluation.
The compiler may be able to use special processor functions to make the polynomial evaluation faster. For example, the ARM7 processor has instructions that can perform a multiply and add together.

Answer 3

Computing a 3rd grade polynomial will nearly always be faster.
People seem to forget they need to search a value in this "look-up" table. Which is O(log N).
Evaluating polynomial of 3rd grade is trivial enough, that the table would need to be uselessly small to outperform it.
The table has chance only, if you store exactly the values for arguments you will look for and you know where in the table the reside. So you do not have to perform a search. That would make it a real look-up table, and it would probably be faster.
The example I know where tables are indeed used are computing sine function with high precision (more on wiki). Although, there computation would be really expensive.