Efficient Power Calculation in C: Exponentiation with 2

[martix]

I'm trying to write a program that raises 2 to the specified power... and I need help.
And I don't mean an ordinary 2*2*2, n times and such.

The method used is slightly strange(kinda backwards).
For ex. take 256, what the program should do is
1. Take 2, check if the next digit is greater than 4. As it is there is an overflow which gets added to the product ot the first digit*2
2. Put the result in a string that is built piece by piece with concatenation.
3. Repeat for the next digit until the end. Then do the same for the next power, up to the desired one.

Issues I'm not sure of. Say you reach 512 - there is no zero digit to add the overflow of the first one. My guess is - artificially add one, right?

Then I have some questions - which will be faster?
1. Arrays or concatenation and substrings(a function which btw I did not find in the standart libraries).
2. This method or the usual mathematical ones.

 

[CRGreathouse]

Issues I'm not sure of. Say you reach 512 - there is no zero digit to add the overflow of the first one. My guess is - artificially add one, right?

Yes, unless you're trying to calculate mod some power of 10.

Then I have some questions - which will be faster?
1. Arrays or concatenation and substrings(a function which btw I did not find in the standart libraries).
2. This method or the usual mathematical ones.

I'm not sure what you mean by each of these:
* Most if not all methods for working with large numbers involve arrays on some level.
* Concatenation methods will be very slow in C, since you'll generally be forced to copy the string many times.
* Your method is slow, since it doesn't take advantage of the form of the problem or the fast machine instructions.
* There are many mathematical methods for calculating this, some of which are faster than others.

Since you're working on a binary computer, I'd expect the bit shift operator to be far faster than your method. "1ULL << 60" calculates 2^60 pretty quickly, around a nanosecond. Your method would take around a microsecond unless the cache slowed it down, in which case it might take 5-10 times as long.

Of course if you want to do this for really large numbers (ones that won't fit into a double word) you'll have to do some programming, but even then an array of integers would surely be much faster than a series of string arrays, right?

 

[ravenprp]

Thank you for sharing your approach to efficiently calculating powers of 2 in C. It seems like you have a unique solution that involves checking each digit and handling overflow with concatenation. While this may work, it may not be the most efficient approach.

To address your question about reaching 512, you are correct that you would need to artificially add a zero digit to the string for the overflow. However, this could potentially slow down the calculation process.

As for your questions about using arrays or concatenation and substrings, it really depends on the specific implementation and the size of the numbers you are working with. In general, using arrays may be more efficient for larger numbers as it allows for direct access and manipulation of each digit. Concatenation and substring operations may be faster for smaller numbers, but it also depends on the specific implementation and the efficiency of the substring function you are using.

In terms of comparing this method to more traditional mathematical approaches, it ultimately depends on the specific implementation and the size of the numbers you are working with. It may be worth testing and comparing different methods to see which one is more efficient for your specific use case.

Overall, it seems like you have a unique and interesting solution to efficiently calculating powers of 2 in C. However, I would suggest testing and comparing different methods to determine which one is the most efficient for your specific use case. Best of luck with your program!