 |
ÍÀÓ×ÍÀß ÁÈÁËÈÎÒÅÊÀ - ÐÅÔÅÐÀÒÛ - Íàáîð ïðîöåäóð ìàíèïóëèðîâàíèÿ ñ öåëûìè ÷èñëàìè ïðîèçâîëüíîé äëèíû
Íàáîð ïðîöåäóð ìàíèïóëèðîâàíèÿ ñ öåëûìè ÷èñëàìè ïðîèçâîëüíîé äëèíû
Îò÷åò òåñòîâîé ïðîãðàììû
Ïðîâåðêà ðàáîòû êîíñòðóêòîðîâ: Áåç èíèöèàëèçàöèè: unlim a; a=0 Èíèöèàëèçàöèÿ ñòðîêîé: unlim b="123" b=123 unlim c="-123" c=-123 unlim d="+123" d=123 unlim e="+"
Unlim class error: Sign without value. Value=0 e=0 unlim f="-"
Unlim class error: Sign without value. Value=0 f=0 unlim g="aaa"
Unlim class error: Not digit symbol in string. String ignored. Value=0 g=0 unlim h="4a123"
Unlim class error: Not digit symbol in string. String ignored. Value=0 h=0
Ïðîâåðêà âûâîäà, àðèôìåòèêè è ñðàâíåíèÿ:
Ââåäåíî: a=123 b=45
Ðåçóëüòàò: a=123 b=45
-a=-123
+a=123
a>b a>=b a!=b
a+b=168
a-b=78
a*b=5535
--------------------------------------------------
Ââåäåíî: a=+0000000000000000123 b=0000000000000000000000000000000045
Ðåçóëüòàò: a=123 b=45
-a=-123
+a=123
a>b a>=b a!=b
a+b=168
a-b=78
a*b=5535
--------------------------------------------------
Ââåäåíî: a=-123 b=-45
Ðåçóëüòàò: a=-123 b=-45
-a=123
+a=-123
a=b a!=b
a+b=78
a-b=168
a*b=-5535
--------------------------------------------------
Ââåäåíî: a=-123 b=45
Ðåçóëüòàò: a=-123 b=45
-a=123
+a=-123
a=b a!=b
a+b=1999999999999999999999999999999999999999999999
a-b=1
a*b=999999999999999999999999999999999999999999999000000000000000000000000000000000000000000000
--------------------------------------------------
Ââåäåíî: a=-100000000000000000000000000000000000000000000 b=999999999999999999999999999999999999999999999
Ðåçóëüòàò: a=-100000000000000000000000000000000000000000000 b=999999999999999999999999999999999999999999999
-a=100000000000000000000000000000000000000000000
+a=-100000000000000000000000000000000000000000000
a
ÌÎÑÊÎÂÑÊÈÉ ÈÍÑÒÈÒÓÒ ÐÀÄÈÎÒÅÕÍÈÊÈ ÝËÅÊÒÐÎÍÈÊÈ
È ÀÂÒÎÌÀÒÈÊÈ
ÌÅÆÄÓÍÀÐÎÄÍÛÉ ÔÀÊÓËÜÒÅÒ
ÈÍÔÎÐÌÀÒÈÊÈ
ÈÍÒÅÐ ÝÂÌ
Ê Ó Ð Ñ Î Â À ß Ð À Á Î Ò À
ïî äèñöèïëèíå "Àëãîðèòìè÷åñêèå ßçûêè è
Ïðîãðàììèðîâàíèå"
Ìîñêâà 1993ã
.
Ïîñòàíîâêà çàäà÷è:
Ñîñòàâèòü íàáîð ïðîöåäóð
ìàíèïóëèðîâàíèÿ ñ öåëûìè
÷èñëàìè ïðîèçâîëüíîé äëèíû. Ïðîöåäóðû äîëæíû îáåñïå÷èâàòü:
ôîðìèðîâàíèå è
ââîä öåëûõ ÷èñåë
ïðîèçâîëüíîé äëèíû,
ñëîæåíèå, âû÷èòàíèå,
ñðàâíåíèå è óìíîæåíèå
öåëûõ ÷èñåë.
Ðàáîòîñïîñîáíîñòü ïðîöåäóð ïðîäåìîíñòðèðîâàòü
íà
äåìîíñòðàöèîííîé
ïðîãðàììå.
.
Èñïîëüçîâàííûå ñðåäñòâà ÿçûêà:
Ìîäóëü, ðåàëèçóþùèé öåëûå
÷èñëà ïðîèçâîëüíîé äëèíû, è
òåñòîâàÿ
ïðîãðàììà íàïèñàíû íà ÿçûêå Ñ++.
Äëÿ ïðåäñòàâëåíèÿ öåëûõ
÷èñåë ïðîèçâîëüíîé äëèíû
îïðåäåëåí êëàññ
UNLIM. Îïåðàöèè íàä
ýòèìè ÷èñëàìè
ðåàëèçîâàíû
ïóòåì ïåðåîïðåäåëåíèÿ äëÿ êëàññà UNLIM ñëåäóþùèõ
îïåðàöèé:
+ (óíàðíûé è áèíàðíûé)
- (óíàðíûé è áèíàðíûé)
*
==
!=
<
>
<=
>=
<< (îïåðàöèÿ âûâîäà êëàññà OSTREAM)
.
Ñòðóêòóðà äàííûõ:
Àáñîëþòíàÿ âåëè÷èíà ÷èñëà ïðîèçâîëüíîé
äëèíû õðàíèòñÿ â
ïàìÿòè â âèäå ìàññèâà òèïà CHAR. Â êàæäîì ýëåìåíòå ìàññèâà
ìîæåò
íàõîäèòñÿ ÷èñëî îò 0 äî 99, òî åñòü äâà
ðàçðÿäà âñåãî
÷èñëà. Â
íóëåâîì ýëåìåíòå õðàíÿòñÿ ìëàäøèå äâà ðàçðÿäà, â
ïîñëåäíåì
ýëåìåíòå - ñòàðøèå äâà ðàçðÿäà. Åñëè
÷èñëî èìååò
íå÷åòíîå êîëè÷åñòâî
ðàçðÿäîâ, òî â
ïîñëåäíåì ýëåìåíòå
ìàññèâà
õðàíèòñÿ îäèí ïîñëåäíèé ðàçðÿä,
ò.å. ÷èñëî îò 0 äî
9. Ëèäèðóþùèå íóëè â ìàññèâå
íå õðàíÿòñÿ. ×èñëî
0
ïðåäñòàâëåíî
ìàññèâîì èç îäíîãî ýëåìåíòà, â êîòîðîì õðàíèòñÿ
0.
Ñ öåëüþ ìèíèìèçèðîâàòü êîïèðîâàíèå è
ðàñõîä ïàìÿòè êëàññ
UNLIM ðåàëèçîâàí òàê, ÷òî íà îäíî ïðåäñòàâëåíèå àáñîëþòíîé
âåëè÷èíû
ìîãóò ññûëàòüñÿ íåñêîëüêî ÷èñåë, ïðè
ýòîì âåäåòñÿ
ó÷åò
ññûëîê.
Îáúåêò êëàññà UNLIM ñîñòîèò èç ïîëÿ SIGN -
çíàêà ÷èñëà è
ïîëÿ PV -
óêàçàòåëÿ íà äåñêðèïòîð ïðåäñòàâëåíèÿ àáñîëþòíîé
âåëè÷èíû.
×èñëî 0 âñåãäà èìååò çíàê PLUS.
Äåñêðèïòîð ïðåäñòàâëåíèÿ àáñîëþòíîé âåëè÷èíû ÷èñëà
ïðåäñòàâëÿåò ñîáîé
îáúåêò ñòðóêòóðû DESCRIPTOR
è èìååò
ñëåäóþùèå
ïîëÿ:
body
- óêàçàòåëü íà ìàññèâ, â
êîòîðîì õðàíèòñÿ
ïðåäñòàâëåíèå àáñîëþòíîé
âåëè÷èíû ÷èñëà;
len
- äëèíà ìàññèâà body[] â áàéòàõ;
HowMany - êîëè÷åñòâî ññûëîê íà äàííîå
ïðåäñòàâëåíèå;
.
Ðåàëèçàöèÿ îïåðàöèé ñðàâíåíèÿ:
Èç îïåðàöèé ñðàâíåíèÿ òîëüêî < è != íàïðÿìóþ ñðàâíèâàþò
÷èñëà,
îñòàëüíûå îïåðàöèè âûðàæåíû ÷åðåç ýòè äâå. Ïðè ðàáîòå
îïåðàöèé < è != ñíà÷àëà ïðîâåðÿþòñÿ çíàêè è äëèíû
÷èñåë, è
òîëüêî â
ñëó÷àå èõ ñîâïàäåíèÿ
ïðîèçâîäèòñÿ ïîðàçðÿäíîå
ñðàâíåíèå ÷èñåë
(â êà÷åñòâå ðàçðÿäîâ çäåñü áåðóòñÿ öåëûå
áàéòû -
ò.å. ðàçðÿäû â ñèñòåìå ñ÷èñëåíèÿ ñ îñíîâàíèåì 100).
Ðåàëèçàöèÿ îïåðàöèé àðèôìåòèêè:
Îïåðàöèÿ óíàðíûé + ïðîñòî âîçâðàùàåò ñàìî
÷èñëî.
Îïåðàöèÿ óíàðíûé - âîçâðàùàåò íîâûé îáúåêò
êëàññà UNLIM,
êîòîðûé
ññûëàåòñÿ íà òî æå ïðåäñòàâëåíèå ìîäóëÿ ÷èñëà, ÷òî è
àðãóìåíò,
è èìååò çíàê, ïðîòèâîïîëîæíûé çíàêó àðãóìåíòà.
Îïåðàöèÿ áèíàðíûé + îïðåäåëåíà
è äëÿ ñëó÷àåâ, êîãäà
çíàêè
îïåðàíäîâ ñîâïàäàþò, è êîãäà ýòè çíàêè ðàçëè÷íû.
 ïåðâîì
ñëó÷àå çíàê ðåçóëüòàòà
ñîîòâåòñòâóåò çíàêó
îäíîãî (ëþáîãî) èç îïåðàíäîâ, à ìîäóëü ðåçóëüòàòà ÿâëÿåòñÿ
ðåçóëüòàòîì ñëîæåíèÿ
ìîäóëåé îïåðàíäîâ. Ïðè
ýòîì åñëè
êîëè÷åñòâî
ðàçðÿäîâ ïåðâîãî îïåðàíäà ðàâíî A, à âòîðîãî - B,
òî
êîëè÷åñòâî ðàçðÿäîâ îïåðàíäà ìîæåò
áûòü ëèáî max(A,B),
ëèáî
max(A,B)+1, ïîýòîìó ïðè âûäåëåíèè ïàìÿòè ïîä ìàññèâ äëÿ
ìîäóëÿ ðåçóëüòàòà áåðåòñÿ âòîðîå çíà÷åíèå.
Íèêàêîé
îïòèìèçàöèè ýòîãî
ìàññèâà ïîñëå ñëîæåíèÿ ìîäóëåé îïåðàíäîâ
íå
äåëàåòñÿ, òàê êàê â
äàííîì ñëó÷àå ïîòåðÿ
ïàìÿòè íà
ëèäèðóþùèå íóëè
ìîæåò áûòü ìàêñèìóì
1 áàéò, è âûãîäíåå
ñýêîíîìèòü
íà ñêîðîñòè, ÷åì íà ïàìÿòè.
 ñëó÷àå, êîãäà çíàêè îïåðàíäîâ
ðàçëè÷íû, çíàê
ðåçóëüòàòà
ðàâåí çíàêó îïåðàíäà ñ
ìàêñèìàëüíûì ìîäóëåì, à
ìîäóëü ðåçóëüòàòà
ïîëó÷àòñÿ âû÷èòàíèåì ìîäóëÿ îïåðàíäà ñ
ìèíèìàëüíûì ìîäóëåì
èç ìîäóëÿ îïåðàíäà
ñ ìàêñèìàëüíûì
ìîäóëåì. Ïðè
ýòîì ïîä ìîäóëü ðåçóëüòàòà
âûäåëÿåòñÿ ìàññèâ
äëèíû, ðàâíîé
íàèáîëüøåé èç äëèí
îïåðàíäîâ, íî ïîñëå
âû÷èòàíèÿ ÷èñåë
îí îïòèìèçèðóåòñÿ ôóíêöèåé
optimize(),
êîòîðàÿ
óäàëÿåò ëèäèðóþùèå íóëè (ñîçäàåò íîâûé ìàññèâ äëèíû,
íåîáõîäèìîé äëÿ õðàíåíèÿ ìîäóëÿ ÷èñëà áåç ëèäèðóþùèõ
íóëåé,
êîïèðóåò â
íåãî âñå çíà÷àùèå
ðàçðÿäû, ïåðåàäðåñîâûâàåò
ññûëêó
äåñêðèïòîðà íà ýòîò ìàññèâ è óäàëÿåò ñòàðûé ìàññèâ).
Ñëîæåíèå è âû÷èòàíèå ìîäóëåé
àðãóìåíòîâ ïðîèçâîäèòñÿ â
ñèñòåìå
ñ÷èñëåíèÿ ñ îñíîâàíèåì 100.
Îïåðàöèÿ áèíàðíûé - îïðåäåëåíà ÷åðåç
óíàðíûé ìèíóñ è
áèíàðíûé
ïëþñ.
Îïåðàöèÿ * ïðîèçâîäèòñÿ ïî òåõíîëîãèè, àíàëîãè÷íîé
óìíîæåíèþ
â ñòîëáèê. Ïðè ýòîì âñå äåéñòâèÿ âåäóòñÿ â ñèñòåìå
ñ÷èñëåíèÿ
ñ îñíîâàíèåì 100. Äëèíà ìàññèâà
ðåçóëüòàòà ìîæåò
áûòü
ðàâíà ëèáî ñóììå äëèí îïåðàíäîâ, ëèáî
ýòîé ñóììå ìèíóñ
1. Ýòà ñèòóàöèÿ àíàëîãè÷íà òîé, êîòîðàÿ áûëà ïðè ñëîæåíèè
÷èñåë ñ
îäèíàêîâûì çíàêîì, è
çäåñü òîæå íå
äåëàåòñÿ
îïòèìèçàöèè.
Îïåðàöèÿ << -
ïðîñòî îïåðàöèÿ âûâîäà êëàññà OSTREAM,
îïðåäåëåííàÿ
äëÿ êëàññà UNLIM. Ñíà÷àëà îíà âûâîäèò
'-' åñëè
çíàê
÷èñëà îòðèöàòåëüíûé, à çàòåì ñàìî ÷èñëî
ïîðàçðÿäíî (ïî
äåñÿòè÷íûì ðàçðÿäàì),
íà÷èíàÿ ñî ñòàðøåãî.
Ïðè ýòîì
èñïîëüçóåòñÿ ôóíêöèÿ
digit(number), êîòîðàÿ âîçâðàùàåò
çíà÷åíèå
äåñÿòè÷íîãî ðàçðÿäà ñ íîìåðîì number.
Ôóíêöèÿ- êîíñòðóêòîð unlim(char*) îáðàáàòûâàåò
èíèöèàëèçàöèþ ñèìâîëüíîé
ñòðîêîé. Ïðè ýòîì
ðàñïîçíàþòñÿ
ñëåäóþùèå
îøèáî÷íûå ñèòóàöèè: èíèöèàëèçàöèÿ
ïóñòîé ñòðîêîé;
íåäîïóñòèìûé ñèìâîë â ñòðîêå; ñòðîêà ñîäåðæèò çíàê, íî
íå
ñîäåðæèò çíà÷åíèÿ.
Âî âñåõ ýòèõ
ñëó÷àÿõ ÷èñëî
èíèöèàëèçèðóåòñÿ
íóëåì.
Ôóíêöèÿ- êîíñòðóêòîð unlim(unlim&) îáðàáàòûâàåò
èíèöèàëèçàöèþ
äðóãèì îáúåêòîì êëàññà UNLIM.
//#include
<string.h>
#include
<iostream.h>
#include
<fstream.h>
//#include
<values.h>
#include
"unlimit.h"
#define
CR "\n"
void
main()
{
ofstream r("report.txt",1);
ostream_withassign rc;
rc=cout;
cout<<"\nÒåñòîâàÿ ïðîãðàììà äëÿ
êëàññà UNLIM\n"
<<"(öåëûå ÷èñëà ñ
ïðîèçâîëüíîé òî÷íîñòüþ)\n"
;
cout=r;
r <<"Îò÷åò
òåñòîâîé ïðîãðàììû\n"
<<"\nÏðîâåðêà ðàáîòû
êîíñòðóêòîðîâ:\n"
<<" Áåç èíèöèàëèçàöèè:\n"
;
r <<" unlim a;\n";
unlim a;
r <<" a="<<a<<"\n"
<<" Èíèöèàëèçàöèÿ ñòðîêîé:\n"
<<" unlim b=\"123\"\n";
unlim b="123";
r <<" b="<<b<<CR
<<" unlim c=\"-123\"\n";
unlim c="-123";
r <<" c="<<c<<CR
<<" unlim d=\"+123\"\n";
unlim d="+123";
r <<" d="<<d<<CR
<<" unlim e=\"+\"\n";
unlim e="+";
r <<" e="<<e<<CR
<<" unlim f=\"-\"\n";
unlim f="-";
r <<" f="<<f<<CR
<<" unlim g=\"aaa\"\n";
unlim g="aaa";
r <<" g="<<g<<CR
<<" unlim h=\"4a123\"\n";
unlim h="4a123";
r <<"
h="<<h<<"\n\n"
<<"Ïðîâåðêà âûâîäà,
àðèôìåòèêè è ñðàâíåíèÿ:\n\n";
while ( a!="0" ||
b!="0" )
{
cout=rc;
cout<<"\nÂâîäèòå îäíî çà
äðóãèì 2 ÷èñëà; äëÿ îêîí÷àíèÿ - îáà íóëè\n";
char
aa[128],
bb[128];
cout<<" a=";
cin >>aa;
cout<<" b=";
cin >>bb;
cout=r;
r <<"Ââåäåíî:\n"
<<"
a="<<aa<<CR
<<"
b="<<bb<<CR
<<"\nÐåçóëüòàò:\n"
;
a=aa;
b=bb;
r <<"
a="<<a<<CR<<"
b="<<b<<"\n\n"
<<"-a="<<-a<<CR<<"+a="<<+a<<"\n\n";
if (a<b) r<<"a<b ";
if (a>b) r<<"a>b ";
if (a<=b)
r<<"a<=b ";
if (a>=b)
r<<"a>=b ";
if (a!=b)
r<<"a!=b\n";
if (a==b)
r<<"a==b\n";
r <<"\na+b="<<(a+b)<<CR
<<"a-b="<<(a-b)<<CR
<<"a*b="<<(a*b)
<<"\n\n--------------------------------------------------\n\n"
;
}
}
#include
<stdlib.h>
#include
<ctype.h>
#include
<string.h>
#include
<iostream.h>
#define
COUNT unsigned int
#define
TRUE 1
#define
FALSE 0
#define
ILLEGAL 10
enum
{
PLUS,
MINUS
};
class
unlim
{
public:
unlim(char*);
unlim();
unlim(unlim&);
~unlim();
unlim
&operator = (char*),
&operator = (unlim&);
friend int
operator ==
(unlim&,unlim&),
operator !=
(unlim&,unlim&),
operator > (unlim&,unlim&),
operator >=
(unlim&,unlim&),
operator < (unlim&,unlim&),
operator <=
(unlim&,unlim&);
friend unlim
operator + (unlim&), // unary
operator - (unlim&), // unary
operator +
(unlim&,unlim&), // binary
operator -
(unlim&,unlim&), // binary
operator *
(unlim&,unlim&),
abs(unlim&);
friend ostream
&operator <<
(ostream&,unlim&);
private:
struct descriptor
{
char
*body;
COUNT
len,
HowMany;
};
descriptor
*pv; //pointer to value descriptor
char
sign,
digit(COUNT number);
char &operator [](COUNT i)
{return pv->body[i];}
void
init0(), //init by zero
NotDigit(), //message "no digit" & init0
optimize(), //optimize length of body
error(char*); //display error
message
};
inline
void unlim::error(char *message)
{
cout <<"Unlim class error:
"
<<message
<<"\n";
}
void
unlim::init0()
{
(pv->body)=new char;
*(pv->body)=0;
(pv->len)=1;
sign=PLUS;
}
char
unlim::digit(COUNT number)
{
if ( number>=(pv->len) )
return ILLEGAL;
char byte=(pv->body)[number/2];
if (number%2==0)
return byte%10;
else
return byte/10;
}
unlim::unlim()
{
pv=new descriptor;
init0();
(pv->HowMany)=1;
}
unlim::~unlim()
{
if ( --(pv->HowMany)==0 )
{
delete pv->body;
delete pv;
}
}
char
DecVal(char symbol)
{
if ( isdigit(symbol) )
return symbol-'0';
return ILLEGAL;
}
unlim::unlim(char
*string)
{
pv=new descriptor;
(pv->HowMany)=1;
COUNT Length=strlen(string);
if (Length==0)
{
error("Empty string assigned.
Value=0");
init0();
return;
}
else
{
COUNT LeftLimit=0;
switch (string[0])
{
case '-':
sign=MINUS;
LeftLimit=1;
break;
case '+':
LeftLimit=1;
default:
sign=PLUS;
}
if (Length-LeftLimit==0)
{
error("Sign without
value. Value=0");
init0();
return;
}
else
{
while (string[LeftLimit]=='0')
LeftLimit++;
if ( (Length-=LeftLimit)==0 )
{
init0();
return;
}
COUNT
DestLength=Length/2+Length%2;
(pv->body)=new
char[DestLength];
for ( COUNT si=Length+LeftLimit-1, ki=0 ; ki<DestLength ;
si-=2,ki++ )
{
char
a=DecVal(string[si]);
if (a==ILLEGAL)
{
NotDigit();
return;
}
(pv->body)[ki]=a;
if (si!=LeftLimit)
{
char
a=DecVal(string[si-1]);
if (a==ILLEGAL)
{
NotDigit();
return;
}
(pv->body)[ki]+=10*a;
}
}
(pv->len)=Length;
}
}
}
void
unlim::NotDigit()
{
error("Not digit symbol in string.
String ignored. Value=0");
delete pv->body;
init0();
}
unlim::unlim(unlim
&arg)
{
(arg.pv)->HowMany++;
pv=arg.pv;
sign=arg.sign;
}
unlim
&unlim::operator=(unlim &arg)
{
(arg.pv)->HowMany++;
if ( --(pv->HowMany)==0 )
{
delete pv->body;
delete pv;
}
pv=arg.pv;
sign=arg.sign;
return *this;
}
unlim
&unlim::operator=(char *string)
{
return *this=unlim(string);
}
ostream
&operator<<(ostream &s,unlim &x)
{
if (x.sign==MINUS)
s << "-";
for ( COUNT i=((x.pv)->len) ; i>0 ;
i-- )
s << int(x.digit(i-1));
return s;
}
int
operator!=(unlim &a,unlim &b)
{
if ( (a.pv)->len != (b.pv)->len)
return TRUE;
if (a.sign!=b.sign)
return TRUE;
COUNT
length=((a.pv)->len)/2+((a.pv)->len)%2;
for ( COUNT i=0 ; i<length ; i++ )
if (a[i]!=b[i])
return TRUE;
return FALSE;
}
int
operator<(unlim &a,unlim &b)
{
if (a.sign!=b.sign)
return a.sign==MINUS;
if ( (a.pv)->len == (b.pv)->len )
{
COUNT i=((a.pv)->len)-1;
while ( a.digit(i) == b.digit(i) )
{
if (i==0)
return FALSE;
i--;
}
char
aLess= a.digit(i) <
b.digit(i),
SignPlus= a.sign==PLUS;
return ( aLess && SignPlus)
|| ( !aLess && !SignPlus );
}
else
)
}
inline
int operator ==(unlim &a,unlim &b)
{
return !(a!=b);
}
inline
int operator <=(unlim &a,unlim &b)
!(a!=b);
inline
int operator >=(unlim &a,unlim &b)
{
return !(a<b);
}
inline
int operator >(unlim &a,unlim &b)
{
return !(a<b) && (a!=b);
}
inline
unlim operator +(unlim &x)
{
return x;
}
unlim
abs(unlim &x)
{
unlim r=x;
r.sign=PLUS;
return r;
}
unlim
operator -(unlim &x)
{
if ( (x.pv)->len==1 && x[0]==0
)
{
unlim y;
return y;
}
unlim y=x;
if (x.sign==PLUS)
y.sign=MINUS;
else
y.sign=PLUS;
return y;
}
void
unlim::optimize()
{
COUNT i=pv->len/2+pv->len%2-1;
char optimized=FALSE;
while (pv->body[i]==0)
{
optimized=TRUE;
if (i--==0)
{
init0();
return;
}
}
if (optimized)
{
char *NewBody=new char[++i];
for (COUNT ni=0;ni<i;ni++)
NewBody[ni]=pv->body[ni];
delete pv->body;
pv->body=NewBody;
pv->len=(i--)*2;
}
if ( (pv->body[i]/10)==0 &&
(pv->len%2)==0 )
pv->len--;
}
inline
COUNT max (COUNT a,COUNT b)
{
return (a>b)?a:b;
}
unlim
operator +(unlim &a,unlim &b)
{
unlim r;
delete (r.pv)->body;
if (a.sign==b.sign)
{
r.sign=a.sign;
COUNT
rlen=max(
(a.pv)->len,(b.pv)->len )+1,
alen=(a.pv)->len/2+(a.pv)->len%2,
blen=(b.pv)->len/2+(b.pv)->len%2;
(r.pv)->len=rlen;
rlen=rlen/2+rlen%2;
(r.pv)->body=new char[rlen];
*(r.pv)->body=0;
for (COUNT i=0;i<rlen;i++)
{
unsigned char sum=( i<alen
? a[i] : 0)+( i<blen ? b[i] : 0);
r[i]+=sum%100;
r[i+1]=sum/100;
}
if ( r.digit( (r.pv)->len-1 )==0
)
(r.pv)->len--;
}
else
{
unlim
aa=a,
bb=b;
if (abs(a)<abs(b))
{
aa=b;
bb=a;
}
r.sign=aa.sign;
COUNT
rlen=(aa.pv)->len,
blen=(bb.pv)->len/2+(bb.pv)->len%2;
(r.pv)->len=rlen;
rlen=rlen/2+rlen%2;
(r.pv)->body=new char[rlen];
*(r.pv)->body=0;
for (COUNT i=0;i<rlen;i++)
{
char sub=aa[i]-( i<blen ?
bb[i] : 0 )+r[i];
if (sub<0)
{
r[i+1]=-1;
sub+=100;
}
else
r[i+1]=0;
r[i]=sub;
}
r.optimize();
}
return r;
}
unlim
operator -(unlim &a,unlim &b)
{
return a+(-b);
}
unlim
operator *(unlim &a,unlim &b)
{
unlim r;
delete (r.pv)->body;
if (a.sign==b.sign)
r.sign=PLUS;
else
r.sign=MINUS;
COUNT
rlen=(a.pv)->len+(b.pv)->len,
alen=(a.pv)->len/2+(a.pv)->len%2,
blen=(b.pv)->len/2+(b.pv)->len%2;
(r.pv)->len=rlen;
rlen=rlen/2+rlen%2;
(r.pv)->body=new char[rlen];
COUNT i;
for (i=0;i<rlen;i++)
r[i]=0;
for (i=0;i<alen;i++)
{
unsigned int
next=0,
mul;
for(COUNT j=0;j<blen;j++)
{
next+=r[i+j];
mul=a[i]*b[j]+next;
r[i+j]=mul%100;
next=mul/100;
}
r[i+blen]=next;
}
if ( r.digit((r.pv)->len-1)==0 )
(r.pv)->len--;
if ( r.digit((r.pv)->len-1)==0 )
r.init0();
return r;
}
#define
COUNT unsigned int
#define
TRUE 1
#define
FALSE 0
#define
ILLEGAL 10
enum
{
PLUS,
MINUS
};
extern
class unlim
{
public:
unlim(char*);
unlim();
unlim(unlim&);
~unlim();
unlim
&operator = (char*),
&operator = (unlim&);
friend int
operator ==
(unlim&,unlim&),
operator !=
(unlim&,unlim&),
operator > (unlim&,unlim&),
operator >=
(unlim&,unlim&),
operator < (unlim&,unlim&),
operator <=
(unlim&,unlim&);
friend unlim
operator + (unlim&), // unary
operator - (unlim&), // unary
operator +
(unlim&,unlim&), // binary
operator -
(unlim&,unlim&), // binary
operator *
(unlim&,unlim&),
abs(unlim&);
friend ostream
&operator <<
(ostream&,unlim&);
private:
struct descriptor
{
char
*body;
COUNT
len,
HowMany;
};
descriptor
*pv; //pointer to value descriptor
char
sign,
digit(COUNT number);
char
&operator [](COUNT i)
{return pv->body[i];}
void
init0(), //init by zero
NotDigit(), //message "no digit" & init0
optimize(), //optimize length of body
error(char*); //display error
message
};
inline
int operator ==(unlim &a,unlim &b)
{
return !(a!=b);
}
inline
int operator <=(unlim &a,unlim &b)
inline
int operator >=(unlim &a,unlim &b)
{
return !(a<b);
}
inline
int operator >(unlim &a,unlim &b)
{
return !(a<b) && (a!=b);
}
inline
unlim operator +(unlim &x)
{
return x;
}
| |
|
|
