iz binarne vrednosti v string

imam 2 spremenljivke unsigned __int64, ki predstavljajo __int128. Kako nj prikažem to v desetiškem številu?
Kako recimo prikažem vrednost 2^128? To je res HUGE številka. Rd bi pa še višje številke pa me zanima kako se to nardi. Pa ni treba pisat kode, lahko ni pa nujno.
Lahko kšno teorijo napišete al pa link kšne strani, ker js nism najdu nč. Lahko da sm narobe iskov.

Lahko recimo prebereš binary v mp* vrednost z GMP(lnx) ali MPIR(lnx+win) knjižnjico. Za dodeljevanje vrednosti in seštevanje s številom istega reda rabi okol 5s na 30MB datoteki.

Bom probu drgač razložit

Moj procesor je 8bitn. Tko da je največja številka, ki jo lahko izračuna 255.
Js pa hočem prikazat na 8bitnem procesorju 32bitno številko, ki pa je sestavljena iz 4ih 8bitnih vrednosti.
Primer 32bit integerja (vrednost = 1743819292)
0110 0111 1111 0000 1001 0010 0001 1100

Ampak js na mojem bitnem procesorju ne morem ker napisat itoa (1743819292), da pretvorm v string. Ker kako dobim string. Tisto cifro 1743819292 morem najprej delit s 1000000000 , da dobim vn 1. Potem odštet 1000000000 od prejšne številke, da dobim 743819292. Potem to delim z 100000000 in tako naprej...

Js pa ne morem delit s 1000000000, ker je največja številka 255 na mojem 8bitnem procesorčku.

Torej za 32bitno vrednost 1743819292, imam 4 registre.
1. register: 0110 0111 (103)
2. register: 1111 0000 (240)
3. register: 1001 0010 (146)
4. register: 0001 1100 (28)

Torej kako nj na zaslonu prikažem vrednot "1743819292"?
// tuki so moji integerji veliki 1bajt (8 bitov)
int a0 = 103;
int a1 = 240;
int a2 = 146;
int a3 = 28;
Zdej pa morem prikazat na zaslon da je to številka 1743819292. Zdej sm pa bled.

En predlog.

Vecino stvari verjamem da ves ampak zaradi razlage celoten pogled.

Binarno stevilo pretvoris v desetisko s pomocjo utezi posameznega bita.

0110 = 0x1 + 1x2 + 1x4 + 0x8 = 6

Enako velja za 32-bitno stevilo. Vse kar potrebujes je 32 utezi in operacijo sestevanja v string.
Utezi ni tezko izracunati - dvojna vrednost prejsne utezi. Torej ostane se samo operacija sestevanja v string.

Torej si na zacetku izracunas utezi za velikost tvojega stevila (128bit) potem pa izvedes sestevek vseh utezi.

Primer za 16-bitna na 8-bitnem:

stevilo: 0101 1110 0001 1110 (24094)

utez1 =
utez8 = 128 - to lahko izracunas normalno
utez9 = 128 + 128 - operacija + je nad string
...
utez16 = utez15 + utez15

rezultat = utez2 + utez3 + utez4 + utez5 + utez10 + utez11 + utez12 + utez13 + utez15
spet uporabis operacijo + nad string

Ja. ;)

typedef unsigned char byte;
// byte array b pomnozi z m in pristeje a. 0<=m<16 in 0<=a<16
void MulAdd(byte* b, byte len, byte m, byte a)
{
    byte i = len;
    byte over = 0;
    while (i--)
    {
        b[i]*=m;
        b[i] += over;
        over = b[i]/10;
        b[i] = b[i]%10;
        b[i] += a;
        a = b[i]/10;
        b[i] = b[i]%10;
    }
}
// bDec sluzi dvojnemu namenu: najprej ga polnimo z desne in vanj vpisujemo 
// izracunane enice, desetice, stotice, potem pa prenesemo izracunano na levo
// in pristejemo '0'(1 v '1', ...). na koncu ga terminiramo z 0.
byte itoa(byte* b, byte len, byte* bDec, byte decLen)
{
    // primer 1011(2) = x(10)
    // x = 0;
    // x = x*2 + 1;  // MulAdd(x, 2, 1)
    // x = x*2 + 0;  // MulAdd(x, 2, 0)
    // x = x*2 + 1;  // MulAdd(x, 2, 1)
    // x = x*2 + 1;  // MulAdd(x, 2, 1)
    // x == 11;
    // V tej funkciji pocnemo podobno, le da namesto dvojiskega uporabljamo stiriski sestav
    byte a0,a1,a2,a3;
    // bDec postavimo na 0
    for (byte i=0;i<decLen; ++i) bDec[i] = 0;
    for (byte i=0; i<len; ++i)
    {
        byte a = b[i];
        // byte a razbijemo na dvo-bite
        a0 = (a & 0xc0) >> 6;
        a1 = (a & 0x30) >> 4;
        a2 = (a & 0x0c) >> 2;
        a3 = (a & 0x03);
        MulAdd(bDec, decLen, 4, a0);
        MulAdd(bDec, decLen, 4, a1);
        MulAdd(bDec, decLen, 4, a2);
        MulAdd(bDec, decLen, 4, a3);
    }
    // sedaj prestavimo stevke iz desnega konca na zacetek: {0,0,0,2,5,7} v {'2','5','7',0,5,7}
    byte i = 0;
    while (i<decLen && bDec[i]==0) ++i;
    byte off = i;
    for (;i<decLen;++i)
        bDec[i-off] = bDec[i]+'0';
    byte retLen = i-off<decLen?i-off+1:decLen;
    bDec[retLen-1] = 0;
    return retLen;
}

Primer uporabe:

    byte bLen = 4;
    byte* b = new byte[4];
    // 1743819292
    b[0] = 103;
    b[1] = 240;
    b[2] = 146;
    b[3] = 28;
    byte decLen = 20;
    byte bDec[20];
    byte len = itoa(b,bLen, bDec, decLen);
    delete [] b;

Kot vidis, se vsepovsod uporablja samo byte.

Uff še en je neki napisu :). Ej hvala ker ste se potrudl :P. Nism mislu, da boste kr programčke pisal :). Hvala še enkrat ;)

Aja, sm tko na hit pogledu, pa je blo eno seštevanje, pa nism pogruntu, da si to naredu. Bom pol tut tisto pogledu. Je bla krajša zadeva. Sej use kar bi napisu je "ne ne zastopla sva se ćist prov" ;), pa bi bol natančn pregledu :).
Pa med pisanjem sm dojel kaj si mi u ZS naredu. Tista metoda mi je bol ušeč ja. Brez Množenja pa deljenja. Bom kr tisto uzeu pa mal predelu.
Hvala

Pa še nekej je blo narobe: funkcija mnozi(char*,int,char*) je delala pravilno samo do določene vrednosti, sm še dodal funkcijo mnozi(char*,char*,char*).
Evo.