Около билиона!!!!

Мне тоже такая фишка нужна была. Берёш число допустим 10`n - ой степни в переменой х, делиш его так y=10`n-1 z=10`n-1 т.е при перемножении х получается, и всё

[ Это Сообщение было отредактировано Fopfop в 2001-12-07 0925 ]

Есть ещё феня, число 12345...n записываешь как y=1245... , a z=...n (смотри asm поможет)
А если чё мыль рашберёмся [EMAIL]polubog2001@mail.ru[/EMAIL]

Я бы использовал свой класс для этого, а для хранения естесственно указатель. То есть типа:

p:^byte;

GetMem(p,255^10); //eсли, конечно, памяти хватит.

Если нужно могу по подробнее.

Вот ссылочка , почитай http//forum.vingrad.ru/cgi-bin/YaBB/YaBB.pl?board=raznor_progr&action=display&num=995963678

Люди отвечают, реализуй длинную арифметику, если юзаешь десятичную систему счисления, то на цифру тебе хватит четырёх бит, в байте две цифры, это конечно поменьше двоичного представления, там можно и 256 различных значений закодировать, но зато длинные числа ограничаться только памятью. Удачи!

256^10 = (2^8)^10 = 2^80. Для хранения таких чисел требуется 81 бит. Так как наши процессоры (i80386+) всего лишь 32-битные, то производить операции над такими числами так же просто, как над LongInt'ами, не получится. Здесь Вам предлагают использовать двоично-десятичный формат(число хранится в памяти по цифрам(0..9), на каждую цифру как минимум 4 бита), но у этого способа серьезный недостаток: скорость вычислений будет весьма низкой, особенно при выполнении таких операций, как умножение (хотя ввод/вывод чисел в двоично-десятичном формате довольно просто реализуется). Я же предлагаю просто хранить эти числа в "нормальном" машинном виде, как 3 LongInt'а, и производить операции над этими LongInt'ами. Например, так можно реализовать сложение:


Program Addition;


Type
LargeInt = Record
p1,p2,p3: LongInt;
Align : LongInt;
End;
{Поле Align служит просто для выравнивания
длины структуры LargeInt на 128 бит}


Var
a,b: LargeInt;


Begin

{...}

Asm {****************Inc(a,b)****************}
PUSH EAX {<- Сохраняем модифицируемые}
PUSHFD {<- регистры в стеке}

CLC

MOV EAX,b.p1
ADD a.p1,EAX{<- Inc(a.p1,b.p1)}

MOV EAX,b.p2
ADC a.p2,EAX{<- Inc(a.p2,b.p2), а если
результат предыдущего сложения
не влез в 32 бита,
то еще Inc(a.p2)}

MOV EAX,b.p3
ADC a.p3,EAX{<- Inc(a.p3,b.p3), а если
результат предыдущего сложения
не влез в 32 бита,
то еще Inc(a.p3)}

POPFD {<- Восстанавливаем старые}
POP EAX {<- значения регистров}
End;{****************************************}

{...}

End.



Как видите, использованы 386-инструкции, поэтому чтобы скомпилировать эту программу потребуется хороший 32-битный Паскаль-компилятор. TMT-Pascal(tmt.com) - как раз то, что нужно.

А причем здесь размышления о 32-хбитности процов? Помоему все просто
1) заводишь новый тип, например массив на 100 байтовских элементов, в котором будет записано число.
2) процедура сложения (на пасе)

procedure add(a,btlong;var ctlong);
var
i,jinteger;
perbyte;
begin
per=0;
for i=1 to 100 do
begin
c=a+b+per;
per=c div 10;
c=c mod 10;
end;
end;

помоему все просто до невозможности.
чуть сложнее реализовывается процедура умножения, деления (еще сложнее) и возведение в степень ( ну конечно в данном случае лучше, чтоб степень не превышала какого-нить числа, например 100).

Если у тебя PIII, то тут есть SSE есть весёлые 128-битные регистры, а это 2^128... Медленно, но верно...ну или 80-битный регистр из FPU (max ~1.18*10^4932!!!)

(Нарой спецификации по командам, пригодится)


[ Это Сообщение было отредактировано NoVitchoc в 2002-03-28 0238 ]

SSE не подойдут - они используются только для упакованных вещественных чисел, то есть в один регистр помещается 4 32-разрядных вещественных числа типа single и все команды набора SSE выполняются над ними параллельно (или над одним 32-разрядным числом - самым младшим). А вот MMX подойдет - там есть все команды (не только арифметические, но и логические), но только для 64-разрядных.

SSE не подойдут - там в регистр помещаются 4 32-разрядных вещественных числа типа single, и все операции выполняются параллельно (или над одним из них - самым младшим). А вот MMX подойдут, но только для 64-разрядных чисел.