0

The following lines are part from my really "useless" C++ program... which is calculating powers of 2 only up to 2^63 instead of 2^128 "which is being asked" due to the length of the "unsigned long long" variable which is proposed for numbers with 15 digits accuracy...!!!

Just that....I need a 16 bytes or more variable...which is not provided by:

-__int128(Visual Studio 2010 turns the letters to blue but a red line and a error in debug: "keyword not supported on this architecture"32-bit system)

-Boost::Projects...after I googled it due to the fact that I am a newcomer "I was lost in the universe" when I came across with professionals sites (does boost::bigint...exist??? not a rhetorical question)

(-Multi-typing long of' course)

int main()
{   
    unsigned long long result;
    int i;
    const int max=128;

    for(i=0, result=1ll; i <= max; ++i,result *=2 )
        cout<<setw(3)<< i <<setw(32)<< result <<endl;

    system("pause");
    return 0;
}
Étienne
  • 4,773
  • 2
  • 33
  • 58
foldingAthellas
  • 1
  • 1
  • On a side-note the bound checking in your loop is wrong, with 128 bits unsigned you can go from 2⁰ to 2exponent(128)-1. Your loop is being executed 129 times (0 to 128), it should be 128. – Étienne May 10 '13 at 22:35
  • @Étienne The first notice is true(I have faced this with smaller loops of 64,32 etc using 8 and 4 bytes variables....The second in the other hand is not true from my point of view.If `for(expressions;test;increasement)statements;` and has the order of `test=>statements=>increasement=>test=>statements etc`when it is "running" since x^0=1 if you run this programme will give you the output that: 2^0=1 , 2^1=2 , 2^2=4 2^3=8 etc. – foldingAthellas May 11 '13 at 14:06
  • With a 128 bits variable, it will display 2^0=1 2^1=2 2^3=8...2^128=0 because 2^128 will overflow. With the unsigned long long it already displays 2^64=0. – Étienne May 11 '13 at 14:37

3 Answers3

1

SSE and AVX intrinsics go up to 256 bytes, given a modern CPU. They're named __m128i and __m256i.

MSalters
  • 173,980
  • 10
  • 155
  • 350
  • But once he have it in the ram. How is going to print it? – felknight May 10 '13 at 22:40
  • Plus __m128 are 4 32bits floats. I belive he wants integer precision. Floats will end up being something like 1.329803e+36 – felknight May 10 '13 at 22:45
  • Eh, right, that should have been `__m256i` (note the i suffix). Printing is of course going to be your problem; `std::cout<<` doesn't know about SSE intrinsics. – MSalters May 10 '13 at 22:50
  • I found that is needed to #include but who you can calculate and print....I would be happy if anyone could give me a example of the adove programme using _m128int – foldingAthellas May 11 '13 at 13:15
1

You could find a "bigint" implementation in C++ that implements operator<<() to output to ostream's, but if all you want to do is print out powers of 2 to a console or text string, and you don't need to actually do "bigint" math (except to compute those powers-of-2), there's a simpler approach that will give you powers of 2 out to pretty much as large as you want to go & have the patience to look through:

Store each decimal digit (numbers 0 through 9) as a separate entity, perhaps as an array of chars or ints or in a std::list of the digits. Using a std::list has the advantage that you can easily add new digit places at the front as your number gets bigger, but you can do that almost as easily by storing the digits in reverse order in a std::vector (of course to print them, you have to iterate from the back to the front to print the digits in their proper order).

Once you figure out how you want to store the digits, your algorithm for doubling the number is as follows: Iterate over the digits of the large number, doubling each (mod 10 of course) and carrying any overflow (i.e. a bool that says if its result... before the %10... was greater than 9) from that digit to the next. On the next digit, double it first and then add 1 if the previous digit overflowed. And if that result overflows, carry that overflow on to the next digit & continue to the end of all of the digits. At the end of the digits, if doubling the last digit & adding any overflow from the previous digit caused an overflow in that last digit, then add a new digit & set it to 1. Then print the resulting list of digits.

With this algorithm, you can print powers-of-2 as large as you like. Of course they're not "numbers" in the sense that you can't use them directly in C++ math ops.

phonetagger
  • 7,701
  • 3
  • 31
  • 55
0

128 bit integer is a really big integer. You should implement your own data type. You can create an array of shorts, store there numbers (digits) and implement multiplying, just like you do in your math notebook, that's probably the simplest approach.

enter image description here

This one is not finished, of course! The '2' is still missing ;)

cubuspl42
  • 7,833
  • 4
  • 41
  • 65