символьные числа

Необходимо написать прогу умеююю оперироватьь с очень большими числами с очень большой точностью. Варианты FPU не катят. Необходим алгоритм перевода из одной системы исчисления в другую. Все остальное ерунда. Число предполагается задаватьь строкой. Максимальное основание  256

ну, раз необходимо, пиши:)))
думаю, это http://www.sources.ru/cpp/cpp_large_num.shtml
тебе несколько поможет.
приделай к нему перевод между системами счислений, и будет все ок:)

или тее единственное, что нужно сделать, так это перевод из одной системы счисления в другую?

Вообщето задача как раз в переводе из одной системы в другую, причем желательно быстрый алгоритм (без делений и умножений).

хм...:?)
вроде в общем случае перевод из одной системы счисления в другую только делением...
(есть конечно всякие оптимизации 16->10, не говоря уже о 2->16 но вот  7->10 так не пройдет)

кста, как ты думаешь задавать строкой числа в системе счисления с основанием 25?
а делением переводить довольно просто. возьми тот класс, на который я дал ссылку, там есть образование числа из строки, где оно записано в десятичной форме, и реализованы фунции деления и умножения. возьми их и используй...

Работа с числами (с целыми):
http://pascal.sources.ru/math/longar.htm

Алгоритм перевод (системы счисления):
http://pascal.sources.ru/cgi-bin/forum/YaBB.cgi?board=asm;action=display;num=1019347610

Цитата wall, 12.06.02, 01:17:19

Необходимо написать прогу умеююю оперироватьь с очень большими числами с очень большой точностью. Варианты FPU не катят. Необходим алгоритм перевода из одной системы исчисления в другую. Все остальное ерунда. Число предполагается задаватьь строкой. Максимальное основание  256

Довольно непростая задачка... где такие дают ?

Отвечаю всем:
Мне давали похожую задачу.
В: -Почему основание максимум 256?
О: -Да потому что в строке типа char * одной позицией можно представить только 256 вариантов "написания" т.е. 0x00, 0xfe, 0x3c.

А на счет операциий с большими числами... так я их все представляю с основанием 256 изначально, так как это есть машинный формат представления натуральных чисел. Если кто не знает - ну, извините, не спрашивайте.
Вот основные алгоритмы для Intel-формата (младший байт разрядов по младшему адресу, размер массива в 32-битных машинных словах):

//---------------------------------------------------------------------------
//advanced.h
//---------------------------------------------------------------------------

void mul(unsigned __int32 *mem1,unsigned __int32 *mem2,unsigned __int32 *mem3,unsigned __int32 size);
void add(unsigned __int32 *mem1,unsigned __int32 *mem2,unsigned __int32 *mem3,unsigned __int32 size);
void add(unsigned __int32 *mem1,unsigned __int32 value,unsigned __int32 size);
void add(unsigned __int32 *mem1,unsigned __int32 *mem2,unsigned __int32 size);
void cmp(unsigned __int32 *mem1,unsigned __int32 *mem2,unsigned __int32 *mem3,unsigned __int32 size);
void not(unsigned __int32 *mem1,unsigned __int32 size);
void mov(unsigned __int32 *mem1,unsigned __int32 *mem2,unsigned __int32 size);
void sub(unsigned __int32 *mem1,unsigned __int32 *mem2,unsigned __int32 size);
void sub(unsigned __int32 *mem1,unsigned __int32 value,unsigned __int32 size);

//---------------------------------------------------------------------------
//advanced.cpp
//---------------------------------------------------------------------------

void mul(unsigned __int32 *_mem1,unsigned __int32 *_mem2,unsigned __int32 *_mem3,unsigned __int32 _size)
{
   asm
   {
       mov     edi,_mem3
       mov     esi,_mem1
       mov     ecx,_size
   l1: lodsd
       push    esi
       push    ecx
       push    edi
       mov     ecx,eax
       jecxz   d2
       mov     ebx,eax
       mov     ecx,_size
       mov     esi,_mem2
   l2: push    ecx
       lodsd
       mov     ecx,eax
       jecxz   d1
       mov     edx,ebx
       mul     edx
       add     [edi],eax
       jnc     a
       push    edi
   za: add     edi,4
       inc     [edi]
       jz      za
       pop     edi
   a:  add     [edi+4],edx
       jnc     d1
       push    edi
   zd: add     edi,4
       inc     [edi+4]
       jz      zd
       pop     edi
   d1: add     edi,4
       pop     ecx
       loop    l2
   d2: pop     edi
       add     edi,4
       pop     ecx
       pop     esi
       loop    l1
   }
}

void add(unsigned __int32 *mem1,unsigned __int32 *mem2,unsigned __int32 *mem3,unsigned __int32 size)
{
   asm
   {
       mov     edi,mem3
       mov     esi,mem1
       push    esi
       mov     esi,mem2
       mov     ecx,size
   lp: xchg    esi,[esp]
       lodsd
       add     [edi],eax
       jnc     ai
       push    edi
   zi: add     edi,4
       inc     [edi]
       jz      zi
       pop     edi
   ai: xchg    esi,[esp]
       lodsd
       add     [edi],eax
       jnc     aj
       push    edi
   zj: add     edi,4
       inc     [edi]
       jz      zj
       pop     edi
   aj: add     edi,4
       loop    lp
       pop esi
   }
}

void add(unsigned __int32 *mem1,unsigned __int32 *mem2,unsigned __int32 size)
{
   asm
   {
       mov     edi,mem1
       mov     esi,mem2
       mov     ecx,size
  slp: lodsd
       cmp     eax,0
       je      seqz
       mov     edx,[edi]
       add     edx,eax
       jnc     sai
       push    edi
       push    edx
  szi: mov     [edi],edx
       add     edi,4
       mov     edx,[edi]
       inc     edx
       jz      szi
       mov     [edi],edx
       pop     edx
       pop     edi
  sai: mov     [edi],edx
 seqz: add     edi,4
       loop    slp
   }
}

void add(unsigned __int32 *mem,unsigned __int32 value,unsigned __int32 size)
{
   asm
   {
       mov     edi,mem
       mov     eax,value
       mov     ecx,size
       add     [edi],eax
       jnc     nc
   ci: add     edi,4
       inc     [edi]
       jz      ci
   nc:
   }
}

void not(unsigned __int32 *mem,unsigned __int32 size)
{
   asm
   {
       mov     esi,mem
       mov     edi,esi
       mov     ecx,size
   _l: lodsd
       not     eax
       stosd
       loop    _l
   }
}

void cmp(unsigned __int32 *mem1,unsigned __int32 *mem2,unsigned __int32 *mem3,unsigned __int32 size)
{
   asm
   {
       mov     esi,mem1
       push    esi
       mov     esi,mem2
       mov     edi,mem3
       mov     [edi],0
       mov     ecx,size
  _lp: xchg    esi,[esp]
       lodsd
       mov     edx,eax
       xchg    esi,[esp]
       lodsd
       cmp     eax,edx
       je      _e
       cmp     eax,edx
       jl      ls
       inc     [edi]
       jmp     _x
   _e: loop    _lp
       jmp     _x
   ls: dec     [edi]
   _x: pop esi
   }
}

void mov(unsigned __int32 *mem1,unsigned __int32 *mem2,unsigned __int32 size)
{
   asm
   {
       mov     esi,mem2
       mov     edi,mem1
       mov     ecx,size
   _a: lodsd
       stosd
       loop    _a
   }
}

void sub(unsigned __int32 *mem1,unsigned __int32 *mem2,unsigned __int32 size)
{
   asm
   {
       mov     esi,mem2
       mov     edi,mem1
       mov     ecx,size
_loops: lodsd
       sbb     [edi],eax
       mov     eax,[edi]
       stosd
       loop    _loops
   }
}

void sub(unsigned __int32 *mem1,unsigned __int32 value,unsigned __int32 size)
{
   asm
   {
       mov     esi,mem1
       mov     edi,mem1
       mov     ecx,size
       inc     esi
       dec     ecx
       mov     eax,value
       sbb     [edi],eax
       mov     eax,[edi]
       stosd
___lps: lodsd
       sbb     [edi],0
       mov     eax,[edi]
       stosd
       loop    ___lps
   }
}

всё проверено и протестировано, так что багов не ищите!  :)
надеюсь, все понятно.

Интересно и где здесь перевод чисел ???