一个十进制大数运算类，支持加减乘除模、n次乘方、n次开方等运算

yuxh

花了点时间写了这么个东西，目前只支持正整数的运算。
还有很多重要的功能，如素性的检测等还没有完成。
增加了负数 --20060823

decnum.h

1. #include <stdio.h>
   
2. #include <math.h>
   
3. #include <iostream>
   
4. 
   
5. using namespace std;
   
6. 
   
7. class decnum
   
8. {
   
9.     friend decnum pow(const decnum& x, int n);
   
10.     friend decnum root(const decnum& x, int n);
    
11.     friend decnum div(const decnum& x, const decnum& y, decnum& r);
    
12.     friend decnum abs(const decnum& x);
    
13.     friend bool operator==(const decnum& x, const decnum&y);
    
14.     friend bool operator!=(const decnum& x, const decnum&y);
    
15.     friend bool operator>(const decnum& x, const decnum&y);
    
16.     friend bool operator<(const decnum& x, const decnum&y);
    
17.     friend bool operator>=(const decnum& x, const decnum&y);
    
18.     friend bool operator<=(const decnum& x, const decnum&y);
    
19.     friend ostream& operator<<(ostream&os, const decnum& x);
    
20. 
    
21. public:
    
22.     decnum() : cap(0), num(0), sign(0), val(NULL) { }
    
23.     decnum(const char *v, int n)
    
24.     {
    
25.         int i, j;
    
26.         val = new char[n];
    
27.         if(v[0] == '-') {
    
28.             sign = 1;
    
29.             v++;
    
30.             n--;
    
31.         }
    
32.         else {
    
33.             sign = 0;
    
34.             if(v[0] == '+')
    
35.                 v++;
    
36.         }
    
37.         for(i = 0; i < n && v[i] == '0'; i++);
    
38.         for(j=0; i<n; i++, j++)
    
39.             if(v[n-1-i] >= '0' && v[n-1-i] <= '9')
    
40.                 val[j] = v[n-1-i] - '0';
    
41.             else
    
42.                 break;
    
43.         num = j;
    
44.         cap = n;
    
45.     }
    
46.     decnum(const decnum& x)
    
47.     {
    
48.         val = new char[x.num];
    
49.         memcpy(val, x.val, x.num);
    
50.         sign = x.sign;
    
51.         num = x.num;
    
52.         cap = x.num;
    
53.     }
    
54.     decnum(int x)
    
55.     {
    
56.         if(x==0) {
    
57.             cap = num = 0;
    
58.             val = NULL;
    
59.             return;
    
60.         }
    
61.         if(x < 0) {
    
62.             sign = 1;
    
63.             x = -x;
    
64.         }
    
65.         else
    
66.             sign = 0;
    
67.         char temp[20];
    
68.         sprintf(temp, "%d", x);
    
69.         int n = strlen(temp);
    
70.         num = cap = n;
    
71.         val = new char[n];
    
72.         for(int i=0; i<n; i++)
    
73.             val[i] = temp[n-1-i] - '0';
    
74.     }
    
75.     decnum(long long x)
    
76.     {
    
77.         if(x==0) {
    
78.             cap = num = 0;
    
79.             val = NULL;
    
80.             return;
    
81.         }
    
82.         if(x < 0) {
    
83.             sign = 1;
    
84.             x = -x;
    
85.         }
    
86.         else
    
87.             sign = 0;
    
88.         char temp[20];
    
89.         sprintf(temp, "%lld", x);
    
90.         int n = strlen(temp);
    
91.         num = cap = n;
    
92.         val = new char[n];
    
93.         for(int i=0; i<n; i++)
    
94.             val[i] = temp[n-1-i] - '0';
    
95.     }
    
96.     ~decnum() { delete[] val; }
    
97. 
    
98.     int size() const { return num; }
    
99. 
    
100.     decnum&
     
101.     operator=(const decnum& x)
     
102.     {
     
103.         if (this != &x) {
     
104.             if(cap < x.num) {
     
105.                 delete[] val;
     
106.                 val = new char[x.num];
     
107.                 cap = x.num;
     
108.             }
     
109.             memcpy(val, x.val, x.num);
     
110.             num = x.num;
     
111.             sign = x.sign;
     
112.         }
     
113.         return *this;
     
114.     }
     
115.     decnum&
     
116.     operator=(int x)
     
117.     {
     
118.         *this = decnum(x);
     
119.         return *this;
     
120.     }
     
121.     decnum&
     
122.     operator=(long long x)
     
123.     {
     
124.         *this = decnum(x);
     
125.         return *this;
     
126.     }
     
127. 
     
128.     decnum& abs()
     
129.     {
     
130.         sign = 0;
     
131.         return *this;
     
132.     }
     
133.     decnum& operator+=(const decnum& x);
     
134.     decnum& operator-=(const decnum& x);
     
135.     decnum& operator*=(const decnum& x);
     
136.     decnum& operator/=(const decnum& x);
     
137.     decnum& operator%=(const decnum& x);
     
138.     decnum  operator+(const decnum& x) const;
     
139.     decnum  operator-(const decnum& x) const;
     
140.     decnum  operator*(const decnum& x) const;
     
141.     decnum  operator/(const decnum& x) const;
     
142.     decnum  operator%(const decnum& x) const;
     
143. 
     
144.     bool ispow(int n, decnum& r) const;
     
145.     bool ispow() const;
     
146. private:
     
147.     int  cap;
     
148.     int  num;
     
149.     int  sign;
     
150.     char *val;
     
151. private:
     
152.     char root_1(int n);
     
153.     decnum& absadd(const decnum& x);
     
154.     decnum& abssub(const decnum& x);
     
155.     bool absge(const decnum& x);
     
156. };
     
157. 
     

复制代码

decnum.cpp

1. 
   
2. #include "decnum.h"
   
3. 
   
4. decnum&
   
5. decnum::absadd(const decnum& x)
   
6. {
   
7.     int i, max;
   
8.     char carry = 0, ch;
   
9. 
   
10.     if(x.num == 0) return *this;
    
11.     if(num < x.num)
    
12.         max = x.num + 1;
    
13.     else
    
14.         max = num + 1;
    
15.     if(max > cap)
    
16.     {
    
17.         cap = max;
    
18.         char *newval = new char[cap];
    
19.         memcpy(newval, val, num);
    
20.         memset(newval+num, 0, cap - num);
    
21.         delete[] val;
    
22.         val = newval;
    
23.     }
    
24.     else
    
25.     {
    
26.         memset(val+num, 0, max - num);
    
27.     }
    
28.     num = max-1;
    
29.     for(i=0; i<x.num; i++) {
    
30.         ch = val[i] + x.val[i] + carry;
    
31.         if(ch > 9) {
    
32.             carry = 1;
    
33.             val[i] = ch - 10;
    
34.         }
    
35.         else {
    
36.             carry = 0;
    
37.             val[i] = ch;
    
38.         }
    
39.     }
    
40.     for(; i<=num && carry == 1; i++) {
    
41.         ch = val[i] + 1;
    
42.         if(ch > 9) {
    
43.             carry = 1;
    
44.             val[i] = ch - 10;
    
45.         }
    
46.         else {
    
47.             carry = 0;
    
48.             val[i] = ch;
    
49.         }
    
50.     }
    
51.     if(i>num) num = i;
    
52.     return *this;
    
53. }
    
54. 
    
55. decnum&
    
56. decnum::abssub(const decnum& x)
    
57. {
    
58.     if(x.num == 0) return *this;
    
59.     int i;
    
60.     char carry = 0, ch;
    
61.     for(i=0; i<x.num; i++) {
    
62.         ch = val[i] - x.val[i] - carry;
    
63.         if(ch < 0) {
    
64.             carry = 1;
    
65.             val[i] = ch + 10;
    
66.         }
    
67.         else {
    
68.             carry = 0;
    
69.             val[i] = ch;
    
70.         }
    
71.     }
    
72.     for(; i<num && carry == 1; i++) {
    
73.         ch = val[i] - 1;
    
74.         if(ch < 0) {
    
75.             carry = 1;
    
76.             val[i] = ch + 10;
    
77.         }
    
78.         else {
    
79.             carry = 0;
    
80.             val[i] = ch;
    
81.         }
    
82.     }
    
83.     for(i=num; i>0 && val[i-1] == 0; i--);
    
84.     num = i;
    
85.     return *this;
    
86. }
    
87. 
    
88. bool
    
89. decnum::absge(const decnum& x)
    
90. {
    
91.     if(num > x.num) return true;
    
92.     if(num < x.num) return false;
    
93.     for(int i=num-1; i >= 0; i--)
    
94.         if(val[i] > x.val[i])
    
95.             return true;
    
96.         else if(val[i] < x.val[i])
    
97.             return false;
    
98.     return true;
    
99. }
    
100. 
     
101. decnum&
     
102. decnum::operator+=(const decnum& x)
     
103. {
     
104.     if(x.sign == sign)
     
105.         return absadd(x);
     
106.     else if(absge(x))
     
107.         return abssub(x);
     
108.     else {
     
109.         decnum tmp(*this);
     
110.         *this = x;
     
111.         return abssub(tmp);
     
112.     }
     
113. }
     
114. 
     
115. decnum&
     
116. decnum::operator-=(const decnum& x)
     
117. {
     
118.     if(x.sign != sign)
     
119.         return absadd(x);
     
120.     else if(absge(x))
     
121.         return abssub(x);
     
122.     else {
     
123.         decnum tmp(*this);
     
124.         *this = x;
     
125.         return abssub(tmp);
     
126.     }
     
127. }
     
128. 
     
129. decnum&
     
130. decnum::operator*=(const decnum& x)
     
131. {
     
132.     if(num == 0) return *this;
     
133.     if(x.num == 0) {
     
134.         num = 0;
     
135.         return *this;
     
136.     }
     
137.     if(sign == x.sign)
     
138.         sign = 0;
     
139.     else
     
140.         sign = 1;
     
141.     int mul, i, n, newcap, max;
     
142.     char ch, carry;
     
143.     char *newval = new char[num + x.num];
     
144.     newcap = num + x.num;
     
145.     memset(newval, 0, num + x.num);
     
146. 
     
147.     decnum a, b;
     
148.     char *ptr;
     
149.     for(i=0; i<num && val[i] == 0; i++);
     
150.     int na = i;
     
151.     a.val = val + i;
     
152.     a.num = num - i;
     
153.     for(i=0; i<num && x.val[i] == 0; i++);
     
154.     int nb = i;
     
155.     b.val = x.val + i;
     
156.     b.num = x.num - i;
     
157.     ptr = newval + na + nb;
     
158. 
     
159.     for(n=0; n <= a.num + b.num - 2; n++) {
     
160.         mul = 0;
     
161.         if(n > b.num - 1)
     
162.             i = n - b.num + 1;
     
163.         else
     
164.             i=0;
     
165.         max = n < a.num-1 ? n : a.num-1;
     
166.         for(; i<=max; i++)
     
167.             mul += a.val[i]*b.val[n-i];
     
168.         carry = 0;
     
169.         for(i=n; mul > 0 || carry > 0; mul /= 10, i++) {
     
170.             ch = ptr[i] + mul % 10 + carry;
     
171.             if(ch > 9) {
     
172.                 carry = 1;
     
173.                 ptr[i] = ch - 10;
     
174.             }
     
175.             else
     
176.             {
     
177.                 carry = 0;
     
178.                 ptr[i] = ch;
     
179.             }
     
180.         }
     
181.     }
     
182.     for(i=a.num + b.num; i>0 && ptr[i-1] == 0; i--);
     
183.     num = i + na + nb;
     
184.     if(cap >= num) {
     
185.         memcpy(val, newval, num);
     
186.         delete[] newval;
     
187.     }
     
188.     else {
     
189.         cap = newcap;
     
190.         delete[] val;
     
191.         val = newval;
     
192.     }
     
193.     a.val = b.val = NULL;
     
194.     return *this;
     
195. }
     
196. 
     
197. decnum&
     
198. decnum::operator/=(const decnum& x)
     
199. {
     
200.     char ch, carry, fac;
     
201.     decnum tmp;
     
202.     int i;
     
203.     if(x.num == 0) return *this;
     
204.     if(num < x.num) {
     
205.         num = 0;
     
206.         return *this;
     
207.     }
     
208.     if(sign == x.sign)
     
209.         sign = 0;
     
210.     else
     
211.         sign = 1;
     
212.     char *newval = new char[num - x.num + 1];
     
213.     memset(newval, 0, num - x.num + 1);
     
214.     carry = 0;
     
215.     fac = x.val[x.num-1] + 1;
     
216.     tmp.val = val + num - x.num + 1;
     
217.     tmp.cap = tmp.num = x.num -1;
     
218.     for(i=num-1; i>= x.num-1; i--) {
     
219.         tmp.val--;
     
220.         tmp.num++;
     
221.         ch = (carry * 10 + val[i]) / fac;
     
222.         tmp  -= x * ch;
     
223.         while(tmp >= x) {
     
224.             tmp -= x;
     
225.             ch++;
     
226.         }
     
227.         newval[i-x.num+1] = ch;
     
228.         carry = val[i];
     
229.     }
     
230.     tmp.val = NULL;
     
231.     for(i=num-x.num+1; i>0 && newval[i-1] == 0; i--);
     
232.     num = i;
     
233.     delete[] val;
     
234.     val = newval;
     
235.     return *this;
     
236. }
     
237. 
     
238. decnum&
     
239. decnum::operator%=(const decnum& x)
     
240. {
     
241.     char ch, carry, fac;
     
242.     decnum tmp;
     
243.     int i;
     
244.     if(x.num == 0) return *this;
     
245.     if(num < x.num) return *this;
     
246. 
     
247.     carry = 0;
     
248.     fac = x.val[x.num-1] + 1;
     
249.     tmp.val = val + num - x.num + 1;
     
250.     tmp.num = x.num - 1;
     
251.     for(i=num-1; i>= x.num-1; i--) {
     
252.         tmp.val--;
     
253.         tmp.num++;
     
254.         ch = (carry * 10 + val[i]) / fac;
     
255.         tmp  -= x * ch;
     
256.         while(tmp >= x) {
     
257.             tmp -= x;
     
258.             ch++;
     
259.         }
     
260.         carry = val[i];
     
261.     }
     
262.     tmp.val = NULL;
     
263.     num = tmp.num;
     
264.     return *this;
     
265. }
     
266. 
     
267. decnum
     
268. decnum::operator+(const decnum& x) const
     
269. {
     
270.     decnum tmp = *this;
     
271.     return tmp += x;
     
272. }
     
273. 
     
274. decnum
     
275. decnum::operator-(const decnum& x) const
     
276. {
     
277.     decnum tmp = *this;
     
278.     return tmp -= x;
     
279. }
     
280. 
     
281. decnum
     
282. decnum::operator*(const decnum& x) const
     
283. {
     
284.     decnum tmp = *this;
     
285.     return tmp *= x;
     
286. }
     
287. 
     
288. decnum
     
289. decnum::operator/(const decnum& x) const
     
290. {
     
291.     decnum tmp = *this;
     
292.     return tmp /= x;
     
293. }
     
294. 
     
295. decnum
     
296. decnum::operator%(const decnum& x) const
     
297. {
     
298.     decnum tmp = *this;
     
299.     return tmp %= x;
     
300. }
     
301. 
     
302. decnum abs(const decnum& x)
     
303. {
     
304.     decnum tmp(x);
     
305.     tmp.sign = 0;
     
306.     return tmp;
     
307. }
     
308. 
     
309. decnum pow(const decnum& x, int n)
     
310. {
     
311.     decnum tmp(1), fac(x);
     
312.     for(; n>0; n>>=1) {
     
313.         if(n&0x01)
     
314.             tmp *= fac;
     
315.         fac *= fac;
     
316.     }
     
317.     return tmp;
     
318. }
     
319. 
     
320. char decnum::root_1(int n)
     
321. {
     
322.     char r = (int)(pow(1+val[num-1], 1.0/n) * pow(10,(num-1.0)/n));
     
323.     for(; r>0 && pow(decnum(r), n) > *this; r--);
     
324.     return r;
     
325. }
     
326. 
     
327. bool decnum::ispow(int n, decnum& r) const
     
328. {
     
329.     if(num == 0) {
     
330.         r.num = 0;
     
331.         return true;
     
332.     }
     
333.     if(sign == 1 && (n&1 == 0)) {
     
334.         r.num = 0;
     
335.         return false;
     
336.     }
     
337.     decnum tmp, p;
     
338.     r.cap = r.num = (num+n-1) / n;
     
339.     r.val = new char[r.num];
     
340.     r.sign = sign;
     
341.     memset(r.val, 0, r.num);
     
342.     tmp.val = val + (r.num-1)*n;
     
343.     tmp.num = num - (r.num-1)*n;
     
344.     r.val[r.num-1] = tmp.root_1(n);
     
345. 
     
346.     tmp.val = new char[r.num+1];
     
347.     tmp.cap = r.num+1;
     
348.     int v;
     
349.     p = pow(r, n);
     
350.     if(p == *this) return true;
     
351.     for(int i=r.num-2; i>=0; i--) {
     
352.         memset(tmp.val, 0, i+1);
     
353.         tmp.val[i] = 1;
     
354.         tmp.num = i+1;
     
355.         tmp += r;
     
356.         p = (*this - p) / (pow(tmp, n) - p);
     
357.         if(p.num > 1)
     
358.             v = 9;
     
359.         else if(p.num > 0)
     
360.             v = p.val[0];
     
361.         else
     
362.             v = 0;
     
363.         for(; v>=0; v--) {
     
364.             r.val[i] = v;
     
365.             p = pow(r, n);
     
366.             if(p == *this)
     
367.                 return true;
     
368.             if(p < *this)
     
369.                 break;
     
370.         }
     
371.     }
     
372.     return false;
     
373. }
     
374. 
     
375. bool decnum::ispow() const
     
376. {
     
377.     decnum r, dec2("2", 1);
     
378.     if(ispow(2, r)) return true;
     
379.     for(int n=3; r > dec2; n+=2) {
     
380.         if(ispow(n, r)) return true;
     
381.     }
     
382.     return false;
     
383. }
     
384. 
     
385. decnum
     
386. root(const decnum& x, int n)
     
387. {
     
388.     decnum r;
     
389.     x.ispow(n, r);
     
390.     return r;
     
391. }
     
392. 
     
393. decnum
     
394. div(const decnum& x, const decnum& y, decnum& r)
     
395. {
     
396.     char ch, carry, fac;
     
397.     decnum d = x, tmp;
     
398.     int i;
     
399.     if(y.num == 0) return x;
     
400.     if(d.num < y.num) {
     
401.         r = x;
     
402.         d = 0;
     
403.         return d;
     
404.     }
     
405.     char *newval = new char[d.num - y.num + 1];
     
406.     memset(newval, 0, d.num - y.num + 1);
     
407.     carry = 0;
     
408.     fac = y.val[y.num-1] + 1;
     
409.     tmp.val = d.val + d.num - y.num + 1;
     
410.     tmp.num = y.num - 1;
     
411.     for(i=d.num-1; i>= y.num-1; i--) {
     
412.         tmp.val--;
     
413.         tmp.num++;
     
414.         ch = (carry * 10 + d.val[i]) / fac;
     
415.         tmp  -= y * ch;
     
416.         while(tmp >= y) {
     
417.             tmp -= y;
     
418.             ch++;
     
419.         }
     
420.         newval[i-y.num+1] = ch;
     
421.         carry = d.val[i];
     
422.     }
     
423.     r = tmp;
     
424.     tmp.val = NULL;
     
425.     for(i=d.num-y.num+1; i>0 && newval[i-1] == 0; i--);
     
426.     d.num = i;
     
427.     delete[] d.val;
     
428.     d.val = newval;
     
429.     return d;
     
430. }
     
431. 
     
432. bool operator==(const decnum& x, const decnum&y)
     
433. {
     
434.     if(x.sign != y.sign) return false;
     
435.     if(x.num != y.num) return false;
     
436.     for(int i=0; i < x.num; i++)
     
437.         if(x.val[i] != y.val[i])
     
438.             return false;
     
439.     return true;
     
440. }
     
441. 
     
442. bool operator!=(const decnum& x, const decnum&y)
     
443. {
     
444.     return !(x==y);
     
445. }
     
446. 
     
447. bool operator>(const decnum& x, const decnum&y)
     
448. {
     
449.     if(x.sign > y.sign) return false;
     
450.     if(x.sign < y.sign) return true;
     
451.     bool retval = (x.sign == 0);
     
452.     if(x.num > y.num) return retval;
     
453.     if(x.num < y.num) return !retval;
     
454.     for(int i=x.num-1; i >= 0; i--)
     
455.         if(x.val[i] > y.val[i])
     
456.             return retval;
     
457.         else if(x.val[i] < y.val[i])
     
458.             return !retval;
     
459.     return false;
     
460. }
     
461. 
     
462. bool operator<(const decnum& x, const decnum&y)
     
463. {
     
464.     return y > x;
     
465. }
     
466. 
     
467. bool operator>=(const decnum& x, const decnum&y)
     
468. {
     
469.     if(x.sign > y.sign) return false;
     
470.     if(x.sign < y.sign) return true;
     
471.     bool retval = (x.sign == 0);
     
472.     if(x.num > y.num) return retval;
     
473.     if(x.num < y.num) return !retval;
     
474.     for(int i=x.num-1; i >= 0; i--)
     
475.         if(x.val[i] > y.val[i])
     
476.             return retval;
     
477.         else if(x.val[i] < y.val[i])
     
478.             return !retval;
     
479.     return true;
     
480. }
     
481. 
     
482. bool operator<=(const decnum& x, const decnum&y)
     
483. {
     
484.     return y >= x;
     
485. }
     
486. 
     
487. ostream& operator<<(ostream&os, const decnum& x)
     
488. {
     
489.     if(x.size() == 0)
     
490.         os << 0;
     
491.     else {
     
492.         if(x.sign == 1)
     
493.             os << "-";
     
494.         for(int i = x.size()-1; i>=0; i--)
     
495.             os << (int)x.val[i];
     
496.     }
     
497.     return os;
     
498. }
     
499. 
     

复制代码

[ 本帖最后由 yuxh 于 2006-8-23 18:11 编辑 ]

yuxh

这个本来是为大素数的测试用的，这些是要用到的基本运算
可惜我的工作与加密算法无关，纯粹是业余爱好，代码也是业余水平的。
就效率而言，比较慢的就是求n次方根这个了：
root(x, n)
设x有m位，则算法应该是O(m^3*log(m)/n)的
检测一个数是否是某个数的整数次幂:
ispow()
这个就差不多是O(m^3*log(m)^2)的了

[ 本帖最后由 yuxh 于 2006-8-22 11:17 编辑 ]

yuxh

我写这个类的目的是想实现判断一个数是否是素数, 其中第一步就是判断这个数是否某个数的整数次幂
所以我关心的是运算的效率,而不是把它扩展成浮点数形式等更适用的情况
由于在推导一些公式时就是用10进制来考虑的,所以写的代码里也是用10进制数表示的,其实,对代码作一些相应的改动,是很方便换成16进制或别的基进制,(也可以扩展成浮点数的形式,但对我的应用来说,意义不大).

[ 本帖最后由 yuxh 于 2006-8-22 12:38 编辑 ]

yuxh

贴一段测试代码给大家玩玩

1. #include "decnum.h"
   
2. 
   
3. int main()
   
4. {
   
5.     decnum x, y, r;
   
6.     char *line = NULL;
   
7.     size_t  n = 0;
   
8.     int read;
   
9. 
   
10.     cout << "input x:" << endl;
    
11.     if((read = (int)getline(&line, &n, stdin)) != -1) {
    
12.         x = decnum(line, read-1);
    
13.     }
    
14.     else
    
15.         exit(-1);
    
16. 
    
17.     cout << "input y:" << endl;
    
18.     if((read = (int)getline(&line, &n, stdin)) != -1) {
    
19.         y = decnum(line, read-1);
    
20.     }
    
21.     else
    
22.         exit(-1);
    
23. 
    
24.     cout << "x = " << x << endl;
    
25.     cout << "y = " << y << endl;
    
26.     cout << "x * y =" << x * y << endl;
    
27.     cout << "x / y =" << x / y << endl;
    
28.     cout << "x % y =" << x % y << endl;
    
29.     cout << "div(x, y) =" << div(x , y, r) << endl;
    
30.     cout << "mod(x, y) =" << r << endl;
    
31.     cout << "y ^ 2 =" << pow(y, 2) << endl;
    
32.     cout << "x ^ 1/2 =" << root(x, 2) << endl;
    
33.     cout << "x is pow = " << x.ispow() << endl;
    
34. 
    
35.     return 0;
    
36. }

复制代码

input x:
12934891238741902347120934871230948712390487123904871239047812390847123094871230948712309487123904871230947123980471203948712309487120394712398471239048713256129834712903847120394781239084712930487231094712394087123094123481203333333333333333333333333333333333333333333888888888888888888888888888888888888888888888888222222222222222222222222222222222222221094387123908471293048721903487123908412903471290384712398471239847213984712938471209384172093847129834712093847123904123471290384712398471209348712093847120938471297340129341
input y:
87123904781239084712309487123094871230948712390487123
x = 12934891238741902347120934871230948712390487123904871239047812390847123094871230948712309487123904871230947123980471203948712309487120394712398471239048713256129834712903847120394781239084712930487231094712394087123094123481203333333333333333333333333333333333333333333888888888888888888888888888888888888888888888888222222222222222222222222222222222222221094387123908471293048721903487123908412903471290384712398471239847213984712938471209384172093847129834712093847123904123471290384712398471209348712093847120938471297340129341
y = 87123904781239084712309487123094871230948712390487123
x * y =1126938232639833173075933852454844491172426928514059866807740841770815249456423275828974308682129087476539239375374114934208988211619943619716558347499808789403504191997992053251495407207133672212198009872845450749525122406765537233683189166639249361344448037097903846536903047332910602617949715068386039572749284661323652396812507276858460341917936752512602597008627491342253724797935606421392773895578442187710885039658694980497445673861077574294718176507864939038642062979105391800654254681231524754223749316701123751673470225808955075291647887679573776980478625133783450814975943
x / y =148465467327484275048232812439334306695533671227089122007816650126394502951501427671718661140385906942393209068225081817296775831986299773922335101921640962699307587052445014486841122328740344708845214812651256032481988250472736002705523700302442398432754627409724200156670159012028113430398315975429449502269548763370786332836604219524721316400456079938591537603272259855595623013801608933716962712146970686555106278637839124034044858476557783789374654839217122223912234300207
x % y =79300951666803804539185154310166594060311523590394880
div(x, y) =148465467327484275048232812439334306695533671227089122007816650126394502951501427671718661140385906942393209068225081817296775831986299773922335101921640962699307587052445014486841122328740344708845214812651256032481988250472736002705523700302442398432754627409724200156670159012028113430398315975429449502269548763370786332836604219524721316400456079938591537603272259855595623013801608933716962712146970686555106278637839124034044858476557783789374654839217122223912234300207
mod(x, y) =79300951666803804539185154310166594060311523590394880
y ^ 2 =7590574784330414645380746230930586484532745231159928445672223588351361500455337820516206371351345228817129
x ^ 1/2 =3596510981318130543477927424759527967760623382196876121688918127992258229306117726707700713885454867164034990294666943466289844107281148419105171980209085534883218753821511324570335831894205011649807156193955342866243572062280023407886590191390520013437462254313721
x is pow = 0

yuxh

原帖由 思一克 于 2006-8-22 13:09 发表
yuxh 弄了一个伟大的工程呀

只是玩玩,呵呵~万里长征才走了第一步哇~

yuxh

增加了负数，但负数不支持取余(%)及相应的带余除法(div)
并用它解决了醉卧水云间 的pell方程的问题