找到几个数论算法的源代码

无心人

http://www.mindspring.com/~pate/course/chap09.html
APRCL.c
还少一个大数的库
似乎在lip.h里定义的

1. /*
   
2.   Author:  Pate Williams (c) 1997
   
3. 
   
4.   Lucas-Lehmer primality test.
   
5.   See "Implementation of a New Primality Test",
   
6.   Mathematics of Computation, Volume 48, Number 177,
   
7.   January 1987, pages 103 - 121 by H. Cohen and
   
8.   A. K. Lenstra.
   
9. */
   
10. 
    
11. #include <ctype.h>
    
12. #include <stdio.h>
    
13. #include <stdlib.h>
    
14. #include "lip.h"
    
15. 
    
16. #define BOUND 1000000l
    
17. #define t 25200l
    
18. 
    
19. int trial_division(long bound, verylong zn,
    
20.                    long *lm, long *lmSize,
    
21.                    long *lp, long *lpSize,
    
22.                    verylong *zfm,
    
23.                    verylong *zfp,
    
24.                    verylong *znp,
    
25.                    verylong *znm,
    
26.                    verylong *zrm,
    
27.                    verylong *zrp)
    
28. /* returns 0 if number is composite 1 if prime
    
29.    2 if proved prime by trial division */
    
30. {
    
31.   int factored = 0, flag = 0;
    
32.   long b, p, r;
    
33.   verylong za = 0, zs = 0, zn1 = 0;
    
34. 
    
35.   *lmSize = *lpSize = 0;
    
36.   zsadd(zn, - 1l, znm);
    
37.   zsadd(zn, + 1l, znp);
    
38.   zcopy(*znm, zrm);
    
39.   zcopy(*znp, zrp);
    
40.   zcopy(*znp, &zn1);
    
41.   zpstart2();
    
42.   p = zpnext();
    
43.   zsqrt(zn, &zs, &za);
    
44.   if (zscompare(zs, bound) > 0)
    
45.     b = bound;
    
46.   else {
    
47.     flag = 1;
    
48.     b = ztoint(zs);
    
49.   }
    
50.   while (!factored && p <= b) {
    
51.     r = zsmod(*znp, p);
    
52.     factored = r == 1;
    
53.     if (!factored) {
    
54.       if (r == 0) {
    
55.         do {
    
56.           zsdiv(*zrp, p, &za);
    
57.           zcopy(za, zrp);
    
58.         } while (zsmod(*zrp, p) == 0);
    
59.         lp[*lpSize] = p;
    
60.         *lpSize = *lpSize + 1;
    
61.       }
    
62.       if (r == 2) {
    
63.         do {
    
64.           zsdiv(*zrm, p, &za);
    
65.           zcopy(za, zrm);
    
66.         } while (zsmod(*zrm, p) == 0);
    
67.         lm[*lmSize] = p;
    
68.         *lmSize = *lmSize + 1;
    
69.       }
    
70.     }
    
71.     p = zpnext();
    
72.   }
    
73.   zdiv(*znm, *zrm, zfm, &za);
    
74.   zdiv(*znp, *zrp, zfp, &za);
    
75.   zfree(&za);
    
76.   zfree(&zs);
    
77.   zfree(&zn1);
    
78.   if (!factored && flag && p > b) factored = 2;
    
79.   else factored = !factored;
    
80.   return factored;
    
81. }
    
82. 
    
83. void ring_mul(long a, long r, long u,
    
84.               verylong zn,
    
85.               verylong *zx, verylong *zy,
    
86.               verylong *zz)
    
87. {
    
88.   verylong za = 0, zb = 0, zc = 0;
    
89.   verylong zp0 = 0, zp1 = 0, zs0 = 0, zs1 = 0;
    
90. 
    
91.   zmulmod(zx[0], zy[0], zn, &zp0);
    
92.   zmulmod(zx[1], zy[1], zn, &zp1);
    
93.   zaddmod(zx[0], zx[1], zn, &zs0);
    
94.   zaddmod(zy[0], zy[1], zn, &zs1);
    
95.   if (r == 1) {
    
96.     zsmulmod(zp1, a, zn, &za);
    
97.     zaddmod(zp0, za, zn, &zz[0]);
    
98.     zmulmod(zs0, zs1, zn, &za);
    
99.     zsubmod(za, zp0, zn, &zb);
    
100.     zsubmod(zb, zp1, zn, &zz[1]);
     
101.   }
     
102.   else if (r == 3) {
     
103.     zaddmod(zp0, zp1, zn, &zz[0]);
     
104.     zsmulmod(zp1, u - 1, zn, &za);
     
105.     zmulmod(zs0, zs1, zn, &zb);
     
106.     zaddmod(zb, za, zn, &zc);
     
107.     zsubmod(zc, zp0, zn, &zz[1]);
     
108.   }
     
109.   zfree(&za);
     
110.   zfree(&zb);
     
111.   zfree(&zc);
     
112.   zfree(&zp0);
     
113.   zfree(&zp1);
     
114.   zfree(&zs0);
     
115.   zfree(&zs1);
     
116. }
     
117. 
     
118. void ring_sqr(long u, verylong zn,
     
119.               verylong *zx, verylong *zz)
     
120. {
     
121.   verylong za = 0, zb = 0, zs = 0;
     
122. 
     
123.   zsmulmod(zx[1], u, zn, &za);
     
124.   zsmulmod(zx[0], 2l, zn, &zb);
     
125.   zaddmod(za, zb, zn, &zs);
     
126.   zmulmod(zx[0], zs, zn, &za);
     
127.   zsadd(za, - 1l, &zb);
     
128.   zmod(zb, zn, &zz[0]);
     
129.   zmulmod(zx[1], zs, zn, &zz[1]);
     
130.   zfree(&za);
     
131.   zfree(&zb);
     
132.   zfree(&zs);
     
133. }
     
134. 
     
135. void ring_pow(long a, long u,
     
136.               verylong ze,
     
137.               verylong zn,
     
138.               verylong *zx,
     
139.               verylong *zz)
     
140. /* calculates z = x ^ e in the ring
     
141.    (Z / nZ)[T]/(T ^ 2 - u * T - 1) */
     
142. {
     
143.   long i, r = zsmod(zn, 4l);
     
144.   verylong za = 0, zb = 0;
     
145.   verylong zA[2], zS[2], zT[2];
     
146. 
     
147.   zA[0] = zA[1] = zS[0] = zS[1] = zT[0] = zT[1] = 0;
     
148.   zcopy(ze, &za);
     
149.   zzero(&zA[1]);
     
150.   zone(&zA[0]);
     
151.   zcopy(zx[0], &zS[0]);
     
152.   zcopy(zx[1], &zS[1]);
     
153.   while (zscompare(za, 0l) != 0) {
     
154.     if (zodd(za)) {
     
155.       ring_mul(a, r, u, zn, zA, zS, zz);
     
156.       zcopy(zz[0], &zA[0]);
     
157.       zcopy(zz[1], &zA[1]);
     
158.     }
     
159.     zrshift(za, 1l, &zb);
     
160.     zcopy(zb, &za);
     
161.     if (zscompare(za, 0l) != 0) {
     
162.       ring_sqr(u, zn, zS, zT);
     
163.       zcopy(zT[0], &zS[0]);
     
164.       zcopy(zT[1], &zS[1]);
     
165.     }
     
166.   }
     
167.   zfree(&za);
     
168.   zfree(&zb);
     
169.   for (i = 0; i < 2; i++) {
     
170.     zfree(&zA[i]);
     
171.     zfree(&zS[i]);
     
172.     zfree(&zT[i]);
     
173.   }
     
174. }
     
175. 
     
176. int test_for_nm(int *flag,
     
177.                 verylong zn,
     
178.                 verylong znm,
     
179.                 verylong zp,
     
180.                 verylong *zprod,
     
181.                 verylong **zbeta)
     
182. /* returns - 1 if test fails, 0 if n is composite,
     
183.    1 otherwise */
     
184. {
     
185.   int found = 0, value;
     
186.   long i, l, p, q, x;
     
187.   verylong za = 0, zb = 0, zo = 0, zx = 0;
     
188. 
     
189.   zpstart2();
     
190.   for (i = 0; !found && i < 50; i++) {
     
191.     x = zpnext();
     
192.     zdiv(znm, zp, &za, &zb);
     
193.     zintoz(x, &zx);
     
194.     zexpmod(zx, za, zn, &zb);
     
195.     found = zscompare(zb, 1l) != 0;
     
196.   }
     
197.   if (found) {
     
198.     zexpmod(zx, znm, zn, &za);
     
199.     value = zscompare(za, 1l) == 0;
     
200.     if (value) {
     
201.       zcopy(*zprod, &zo);
     
202.       zsadd(zb, - 1l, &za);
     
203.       zmulmod(*zprod, za, zn, &zb);
     
204.       zcopy(zb, zprod);
     
205.       value = zscompare(*zprod, 0l) == 0;
     
206.       if (value) {
     
207.         zgcd(zo, zn, &za);
     
208.         printf("factor = ");  zwriteln(za);
     
209.         value = 0;
     
210.       }
     
211.       else if (zprobprime(zp, 5l)) {
     
212.         zpstart();
     
213.         l = 1;
     
214.         p = ztoint(zp);
     
215.         do {
     
216.           q = pow(p, l);
     
217.           if (t % q == 0) {
     
218.             flag[q] = 1;
     
219.             for (i = 0; i < q - 1; i++) {
     
220.               zsmul(znm, i, &za);
     
221.               zsdiv(za, q, &zb);
     
222.               zexpmod(zx, zb, zn, &zbeta[q][i]);
     
223.             }
     
224.           }
     
225.           l++;
     
226.         } while (q < t);
     
227.         value = 1;
     
228.       }
     
229.       else value = 1;
     
230.     }
     
231.   }
     
232.   else value = - 1;
     
233.   if (!value) printf("composite by n - 1 test\n");
     
234.   zfree(&za);
     
235.   zfree(&zb);
     
236.   zfree(&zo);
     
237.   zfree(&zx);
     
238.   return value;
     
239. }
     
240. 
     
241. int test_for_np(long a, long u,
     
242.                 verylong zn,
     
243.                 verylong znp,
     
244.                 verylong zp,
     
245.                 verylong *zprod)
     
246. /* returns
     
247.   - 1 if test fails, 0 if n is composite,
     
248.   + 1 otherwise */
     
249. {
     
250.   int factored = 0, found = 0, value;
     
251.   long d, m;
     
252.   verylong za = 0, zd = 0, ze = 0, zi = 0;
     
253.   verylong zx[2], zz[2];
     
254. 
     
255.   zx[0] = zx[1] = zz[0] = zz[1] = 0;
     
256.   zdiv(znp, zp, &ze, &za);
     
257.   for (m = 1; !factored && !found && m <= 50; m++) {
     
258.     d = m * (m + u) - a;
     
259.     zintoz(d, &zd);
     
260.     zinvmod(zd, zn, &zi);
     
261.     factored = zscompare(zi, 0l) == 0;
     
262.     if (!factored) {
     
263.       zintoz(m * m + a, &za);
     
264.       zmulmod(za, zi, zn, &zx[0]);
     
265.       zintoz((2 * m + u) * a, &za);
     
266.       zmulmod(za, zi, zn, &zx[1]);
     
267.       ring_pow(a, u, ze, zn, zx, zz);
     
268.       found = zscompare(zz[0], 1l) != 0 ||
     
269.               zscompare(zz[1], 0l) != 0;
     
270.     }
     
271.   }
     
272.   if (!factored && found) {
     
273.     ring_pow(a, u, znp, zn, zx, zz);
     
274.     factored = zscompare(zz[0], 1l) == 1 &&
     
275.                zscompare(zz[1], 0l) == 0;
     
276.     if (!factored) {
     
277.       if (zscompare(zx[0], 0l) != 0)
     
278.         zmulmod(*zprod, zx[0], zn, &za);
     
279.       else
     
280.         zmulmod(*zprod, zx[1], zn, &za);
     
281.       factored = zscompare(za, 0l) == 0;
     
282.       if (factored) {
     
283.         zgcd(*zprod, zn, &za);
     
284.         printf("factor: ");
     
285.         zwriteln(za);
     
286.       }
     
287.       else zcopy(za, zprod);
     
288.       if (factored) value = 0; else value = 1;
     
289.     }
     
290.   }
     
291.   else if (factored) value = 0;
     
292.   else value = - 1;
     
293.   zfree(&za);
     
294.   zfree(&zd);
     
295.   zfree(&ze);
     
296.   zfree(&zi);
     
297.   zfree(&zx[0]);
     
298.   zfree(&zx[1]);
     
299.   zfree(&zz[0]);
     
300.   zfree(&zz[1]);
     
301.   if (!value) printf("composite by n + 1 test\n");
     
302.   return value;
     
303. }
     
304. 
     
305. void norm(long a, long u, verylong zn,
     
306.           verylong *znorm, verylong *zx)
     
307. {
     
308.   verylong za = 0, zb = 0, zc = 0;
     
309. 
     
310.   zmulmod(zx[0], zx[0], zn, &za);
     
311.   zmulmod(zx[0], zx[1], zn, &zb);
     
312.   zsmulmod(zb, u, zn, &zc);
     
313.   zaddmod(za, zc, zn, &zb);
     
314.   zmulmod(zx[1], zx[1], zn, &za);
     
315.   zsmulmod(za, - a, zn, &zc);
     
316.   zaddmod(zb, zc, zn, znorm);
     
317.   zfree(&za);
     
318.   zfree(&zb);
     
319.   zfree(&zc);
     
320. }
     
321. 
     
322. int Lucas_Lehmer(int *flag, long bound, long lmSize,
     
323.                  long *lm, long lpSize, long *lp,
     
324.                  verylong zn,
     
325.                  verylong zfm, verylong zfp,
     
326.                  verylong znm, verylong znp,
     
327.                  verylong zrm, verylong zrp,
     
328.                  verylong **zbeta)
     
329. /* returns
     
330.   - 4 could not find suitable a,
     
331.   - 3 could not find suitable u,
     
332.   - 2 if n - 1 test fails,
     
333.   - 1 n + 1 test fails, 0 if n is composite,
     
334.   + 1 if passed  */
     
335. {
     
336.   int f4_1, factored = 0, found = 0, test = 1;
     
337.   long a, d, i, l, m, p, r, u;
     
338.   verylong za = 0, zd = 0, ze = 0, zi = 0, zm = 0;
     
339.   verylong zp = 0, zu = 0, zprod = 0, zx[2], zz[2];
     
340. 
     
341.   zx[0] = zx[1] = zz[0] = zz[1] = 0;
     
342.   zone(&zprod);
     
343.   for (i = 0; test && i < lmSize; i++) {
     
344.     p = lm[i];
     
345.     zintoz(p, &zp);
     
346.     test = test_for_nm(flag, zn, znm, zp, &zprod, zbeta);
     
347.   }
     
348.   if (test == 1) {
     
349.     if (zcompare(zfm, zfp) > 0) zcopy(zfm, &za);
     
350.     else zcopy(zfp, &za);
     
351.     zmul(za, zfm, &zd);
     
352.     zmul(zd, zfp, &ze);
     
353.     zintoz(bound, &za);
     
354.     zsexp(za, 3l, &zm);
     
355.     zmul(ze, zm, &za);
     
356.     f4_1 = zcompare(zn, za) < 0;
     
357.     if (f4_1 && zscompare(zrm, 1l) != 0)
     
358.       test = test_for_nm(flag, zn, znm, zrm, &zprod, zbeta);
     
359.   }
     
360.   if (test == 1) {
     
361.     r = zsmod(zn, 4l);
     
362.     if (r == 1) {
     
363.       zrshift(znm, 1l, &ze);
     
364.       zpstart2();
     
365.       for (i = 1; !found && i <= 50; i++) {
     
366.         a = zpnext();
     
367.         zintoz(a, &za);
     
368.         zexpmod(za, ze, zn, &zm);
     
369.         found = zcompare(zm, znm) == 0;
     
370.       }
     
371.       if (!found) test = - 4;
     
372.       else {
     
373.         l = 1;
     
374.         do {
     
375.           p = pow(2, l);
     
376.           zintoz(a, &za);
     
377.           if (t % p == 0 && flag[p]) {
     
378.             for (i = 0; i < p; i++) {
     
379.               zsmul(znm, i, &zd);
     
380.               zsdiv(zd, p, &ze);
     
381.               zexpmod(za, ze, zn, &zbeta[p][i]);
     
382.             }
     
383.           }
     
384.           l++;
     
385.         } while (p < sqrt(t));
     
386.       }
     
387.     }
     
388.     else {
     
389.       a = 1;
     
390.       for (i = 1; !found && i <= 50; i++) {
     
391.         zintoz(i * i + 4l, &zu);
     
392.         found = zjacobi(zu, zn) == - 1;
     
393.         if (found) u = i;
     
394.       }
     
395.       if (!found) test = - 3;
     
396.       else {
     
397.         found = 0;
     
398.         for (m = 1; !factored && !found && m <= 50; m++) {
     
399.           d = m * (m + u) - a;
     
400.           zintoz(d, &zd);
     
401.           zinvmod(zd, zn, &zi);
     
402.           factored = zscompare(zi, 0l) == 0;
     
403.           if (!factored) {
     
404.             found = 1;
     
405.             zintoz(m * m + a, &za);
     
406.             zmulmod(za, zi, zn, &zx[0]);
     
407.             zintoz((2 * m + u) * a, &za);
     
408.             zmulmod(za, zi, zn, &zx[1]);
     
409.           }
     
410.         }
     
411.         if (!factored && !found) test = - 2;
     
412.         else if (found) {
     
413.           zone(&zx[0]);
     
414.           zintoz(u, &zx[1]);
     
415.           zrshift(znp, 1l, &ze);
     
416.           ring_pow(a, u, ze, zn, zx, zz);
     
417.           test = zcompare(zz[0], znm) == 0 &&
     
418.                  zscompare(zz[1], 0l) == 0;
     
419.         }
     
420.         else test = 0;
     
421.       }
     
422.     }
     
423.   }
     
424.   else if (test == - 1) test = - 2;
     
425.   if (test == 1) {
     
426.     for (i = 0; test && i < lpSize; i++) {
     
427.       zintoz(lp[i], &zp);
     
428.       test = test_for_np(a, u, zn, znp, zp, &zprod);
     
429.     }
     
430.     if (test == 1) {
     
431.       if (f4_1) {
     
432.         if (zscompare(zrp, 1l) == 0) test = 2;
     
433.         else  {
     
434.           test = test_for_np(a, u, zn, znp, zrp, &zprod);
     
435.           if (test) test = 2;
     
436.         }
     
437.       }
     
438.     }
     
439.   }
     
440.   if (test == 1) {
     
441.     zgcd(zprod, zn, &zd);
     
442.     test = zscompare(zd, 1l) == 0;
     
443.   }
     
444.   zfree(&za);
     
445.   zfree(&zd);
     
446.   zfree(&ze);
     
447.   zfree(&zi);
     
448.   zfree(&zm);
     
449.   zfree(&zp);
     
450.   zfree(&zu);
     
451.   zfree(&zprod);
     
452.   zfree(&zx[0]);
     
453.   zfree(&zx[1]);
     
454.   zfree(&zz[0]);
     
455.   zfree(&zz[1]);
     
456.   return test;
     
457. }
     
458. 
     
459. int main(void)
     
460. {
     
461.   char answer[256];
     
462.   int flag[256], td;
     
463.   long cols, rows;
     
464.   long lm[256], lp[256], lmSize, lpSize;
     
465.   long i, j, l, n = 0, p, q, r[32], tt;
     
466.   verylong zn = 0;
     
467.   verylong zfm = 0, zfp = 0, znm = 0, znp = 0;
     
468.   verylong zrm = 0, zrp = 0;
     
469.   verylong **zbeta;
     
470. 
     
471.   zpstart2();
     
472.   do {
     
473.     p = zpnext();
     
474.     if (t % p == 0) {
     
475.       r[n++] = p;
     
476.       l = 2;
     
477.       do {
     
478.         q = pow(p, l);
     
479.         if (t % q == 0) r[n++] = q;
     
480.         l++;
     
481.       } while (q < sqrt(t));
     
482.     }
     
483.   } while (p < sqrt(t));
     
484.   for (i = 0; i < n - 1; i++)
     
485.     for (j = i + 1; j < n; j++)
     
486.       if (r[i] > r[j])
     
487.         tt = r[i], r[i] = r[j], r[j] = tt;
     
488.   cols = rows = r[n - 1] + 1;
     
489.   zbeta = calloc(rows, sizeof(verylong *));
     
490.   if (!zbeta) {
     
491.     fprintf(stderr, "fatal error\ninsufficient memory\n");
     
492.     exit(1);
     
493.   }
     
494.   for (i = 0; i < rows; i++) {
     
495.     zbeta[i] = calloc(cols, sizeof(verylong));
     
496.     if (!zbeta[i]) {
     
497.       fprintf(stderr, "fatal error\ninsufficient memory\n");
     
498.       exit(1);
     
499.     }
     
500.   }
     
501.   do {
     
502.     printf("enter the number to be tested below:\n");
     
503.     zread(&zn);
     
504.     zwriteln(zn);
     
505.     if (zprobprime(zn, 5l)) {
     
506.       td = trial_division(BOUND, zn, lm, &lmSize,
     
507.                          lp, &lpSize,  &zfm, &zfp, &znp,
     
508.                          &znm, &zrm, &zrp);
     
509.       if (td == 1) {
     
510.         for (i = 0; i < 256; i++) flag[i] = 0;
     
511.         switch (Lucas_Lehmer(flag, BOUND, lmSize,
     
512.                              lm, lpSize, lp, zn,
     
513.                              zfm, zfp, znm, znp,
     
514.                              zrm, zrp, zbeta)) {
     
515.           case - 4 :
     
516.             printf("failed could not find suitable a\n");
     
517.             break;
     
518.           case - 3 :
     
519.             printf("failed could not find suitable u\n");
     
520.             break;
     
521.           case - 2 :
     
522.             printf("Lucas-Lehmer n - 1 test failed\n");
     
523.             break;
     
524.           case - 1 :
     
525.             printf("Lucas-Lehmer n + 1 test failed\n");
     
526.             break;
     
527.           case + 0 :
     
528.             break;
     
529.           case + 1 :
     
530.             printf("number passed Lucas-Lehmer test\n");
     
531.             break;
     
532.           case + 2 :
     
533.             printf("number proven prime by Lucas-Lehmer test\n");
     
534.             break;
     
535.         }
     
536.       }
     
537.       else if (!td)
     
538.         printf("number composite by trial division\n");
     
539.       else
     
540.         printf("number proven prime by trial division\n");
     
541.     }
     
542.     else printf("number composite by Miller-Rabin\n");
     
543.     printf("another number (n or y) ? ");
     
544.     scanf("%s", answer);
     
545.   } while (tolower(answer[0]) == 'y');
     
546.   zfree(&zn);
     
547.   zfree(&zfm);
     
548.   zfree(&zfp);
     
549.   zfree(&znm);
     
550.   zfree(&znp);
     
551.   zfree(&zrm);
     
552.   zfree(&zrp);
     
553.   for (i = 0; i < rows; i++) {
     
554.     for (j = 0; j < cols; j++)
     
555.       zfree(&zbeta[i][j]);
     
556.     free(zbeta[i]);
     
557.   }
     
558.   free(zbeta);
     
559.   return 0;
     
560. }
     

复制代码

无心人

1. 
   
2. *
   
3.   Author:  Pate Williams (c) 1997
   
4. 
   
5.   Aldleman-Pomerance-Rumely-Cohen-Lenstra primality
   
6.   test. See "Implementation of a New Primality Test",
   
7.   Mathematics of Computation, Volume 48, Number 177,
   
8.   January 1987, pages 103 - 121 by H. Cohen and
   
9.   A. K. Lenstra. Table generation.
   
10. */
    
11. 
    
12. #include <limits.h>
    
13. #include <stdio.h>
    
14. #include <stdlib.h>
    
15. #include "lip.h"
    
16. 
    
17. #define t 25200l
    
18. 
    
19. struct power {long x, p;};
    
20. struct long_factor {long expon, prime;};
    
21. struct very_factor {int expon; verylong prime;};
    
22. 
    
23. void long_trial_division(long bound, verylong zn,
    
24.                          struct long_factor *f,
    
25.                          long *count)
    
26. {
    
27.   int one = 0, pri = 0, value;
    
28.   long e, p;
    
29.   verylong za = 0, zb = 0;
    
30. 
    
31.   *count = 0;
    
32.   zcopy(zn, &za);
    
33.   zpstart2();
    
34.   do {
    
35.     p = zpnext();
    
36.     if (zsmod(za, p) == 0) {
    
37.       e = 0;
    
38.       do {
    
39.         e++;
    
40.         zsdiv(za, p, &zb);
    
41.         zcopy(zb, &za);
    
42.       } while (zsmod(za, p) == 0);
    
43.       f[*count].expon = e;
    
44.       f[*count].prime = p;
    
45.       *count = *count + 1;
    
46.       one = zscompare(za, 1l) == 0;
    
47.       if (!one) pri = zprobprime(za, 5l);
    
48.     }
    
49.   } while (!one && !pri && p <= bound);
    
50.   if (pri) {
    
51.     f[*count].expon = 1;
    
52.     f[*count].prime = ztoint(za);
    
53.     *count = *count + 1;
    
54.     value = zscompare(za, LONG_MAX) > 0;
    
55.   }
    
56.   if (value || p > bound) {
    
57.     fprintf(stderr, "fatal error\ncan't factor number");
    
58.     exit(1);
    
59.   }
    
60.   zfree(&za);
    
61.   zfree(&zb);
    
62. }
    
63. 
    
64. void compute_e_of_t(verylong zt, long *Q,
    
65.                     verylong *ze, long *Q_count)
    
66. {
    
67.   int found;
    
68.   long e, i, lf_count, p, q;
    
69.   struct long_factor lf[16];
    
70.   verylong zq = 0, zr = 0;
    
71. 
    
72.   *Q_count = 0;
    
73.   long_trial_division(1000000l, zt, lf, &lf_count);
    
74.   printf("t = "); zwriteln(zt);
    
75.   printf("prime factorization of t\n");
    
76.   for (i = 0; i < lf_count; i++) {
    
77.     printf("%2ld", lf[i].prime);
    
78.     if (lf[i].expon == 1) printf("\n");
    
79.     else printf(" ^ %ld\n", lf[i].expon);
    
80.   }
    
81.   zintoz(2l, ze);
    
82.   zpstart2();
    
83.   do {
    
84.     p = zpnext();
    
85.     q = p - 1;
    
86.     if (zsmod(zt, q) == 0) {
    
87.       Q[*Q_count] = p;
    
88.       *Q_count = *Q_count + 1;
    
89.       e = 1;
    
90.       found = 0;
    
91.       for (i = 0; !found && i < lf_count; i++) {
    
92.         if (p == lf[i].prime) {
    
93.           found = 1;
    
94.           e += lf[i].expon;
    
95.         }
    
96.       }
    
97.       zintoz(p, &zq);
    
98.       zsexp(zq, e, &zr);
    
99.       zmul(*ze, zr, &zq);
    
100.       zcopy(zq, ze);
     
101.     }
     
102.   } while (zscompare(zt, q) >= 0);
     
103.   zfree(&zq);
     
104.   zfree(&zr);
     
105. }
     
106. 
     
107. void very_trial_division(long bound, verylong zn,
     
108.                          struct very_factor *f,
     
109.                          long *count)
     
110. {
     
111.   int e, one = 0, pri = 0;
     
112.   long p;
     
113.   verylong za = 0, zb = 0;
     
114. 
     
115.   *count = 0;
     
116.   zcopy(zn, &za);
     
117.   zpstart2();
     
118.   do {
     
119.     p = zpnext();
     
120.     if (zsmod(za, p) == 0) {
     
121.       e = 0;
     
122.       do {
     
123.         e++;
     
124.         zsdiv(za, p, &zb);
     
125.         zcopy(zb, &za);
     
126.       } while (zsmod(za, p) == 0);
     
127.       f[*count].expon = e;
     
128.       zintoz(p, &f[*count].prime);
     
129.       *count = *count + 1;
     
130.       one = zscompare(za, 1l) == 0;
     
131.       if (!one) pri = zprobprime(za, 5l);
     
132.     }
     
133.   } while (!one && !pri && p <= bound);
     
134.   if (pri) {
     
135.     f[*count].expon = 1;
     
136.     zcopy(za, &f[*count].prime);
     
137.     *count = *count + 1;
     
138.   }
     
139.   if (p > bound) {
     
140.     fprintf(stderr, "fatal error\ncan't factor number");
     
141.     exit(1);
     
142.   }
     
143.   zfree(&za);
     
144.   zfree(&zb);
     
145. }
     
146. 
     
147. void primitive_root(verylong zp, verylong *za)
     
148. {
     
149.   long i, k;
     
150.   struct very_factor f[16];
     
151.   verylong zb = 0, ze = 0, zq = 0, zr = 0, zp1 = 0;
     
152. 
     
153.   for (i = 0; i < 16; i++) f[i].prime = 0;
     
154.   zsadd(zp, - 1l, &zp1);
     
155.   very_trial_division(1000000l, zp1, f, &k);
     
156.   zone(za);
     
157.   L2:
     
158.   i = 0;
     
159.   zsadd(*za, 1l, &zb);
     
160.   zcopy(zb, za);
     
161.   L3:
     
162.   zdiv(zp1, f[i].prime, &zq, &zr);
     
163.   zexpmod(*za, zq, zp, &ze);
     
164.   if (zscompare(ze, 1l) == 0) goto L2;
     
165.   if (++i < k) goto L3;
     
166.   zfree(&zb);
     
167.   zfree(&ze);
     
168.   zfree(&zq);
     
169.   zfree(&zr);
     
170.   zfree(&zp1);
     
171.   for (i = 0; i < 16; i++) zfree(&f[i].prime);
     
172. }
     
173. 
     
174. int fcmp(const void *g1, const void *g2)
     
175. {
     
176.   struct power *p1 = (struct power *) g1;
     
177.   struct power *p2 = (struct power *) g2;
     
178. 
     
179.   if (p1->p < p2->p) return - 1;
     
180.   if (p1->p > p2->p) return + 1;
     
181.   return 0;
     
182. }
     
183. 
     
184. void build_f_table(long q, verylong zg, verylong zq, FILE *file)
     
185. {
     
186.   long f, q1 = q - 1, q2 = q - 2, x;
     
187.   long *h = calloc(q, sizeof(long));
     
188.   struct power *g, key, *ptr;
     
189.   verylong zr = 0, zs = 0, zt = 0;
     
190. 
     
191.   g = calloc(q, sizeof(struct power));
     
192.   if (!g || !h) {
     
193.     fprintf(stderr, "fatal error\ninsufficient memory\n");
     
194.     exit(1);
     
195.   }
     
196.   zone(&zr);
     
197.   g[0].x = 0;
     
198.   g[0].p = 1;
     
199.   for (x = 1; x <= q2; x++) {
     
200.     zsexpmod(zg, x, zq, &zs);
     
201.     zsubmod(zr, zs, zq, &zt);
     
202.     g[x].x = x;
     
203.     g[x].p = ztoint(zs);
     
204.     h[x] = ztoint(zt);
     
205.   }
     
206.   qsort(g, q1, sizeof(struct power), fcmp);
     
207.   fwrite(&q, sizeof(q), 1, file);
     
208.   for (x = 1; x <= q2; x++) {
     
209.     key.x = x;
     
210.     key.p = h[x];
     
211.     ptr = bsearch(&key, g, q1, sizeof(struct power), fcmp);
     
212.     if (!ptr) {
     
213.       fprintf(stderr, "fatal error\ncan't find logarith\n");
     
214.       exit(1);
     
215.     }
     
216.     f = ptr->x;
     
217.     fwrite(&f, sizeof(f), 1, file);
     
218.   }
     
219.   free(g);
     
220.   free(h);
     
221.   zfree(&zr);
     
222.   zfree(&zs);
     
223.   zfree(&zt);
     
224. }
     
225. 
     
226. void generate_f_table(long q_count, long *q)
     
227. {
     
228.   long i, i0, p;
     
229.   FILE *file = fopen("f_table.dat", "w+b");
     
230.   verylong zg = 0, zp = 0;
     
231. 
     
232.   if (!file) {
     
233.     fprintf(stderr, "fatal error\ncan't open file\n");
     
234.     exit(1);
     
235.   }
     
236.   if (q[0] == 2) i0 = 1; else i0 = 0;
     
237.   for (i = i0; i < q_count; i++) {
     
238.     printf("\b\b%ld", i);
     
239.     p = q[i];
     
240.     zintoz(p, &zp);
     
241.     primitive_root(zp, &zg);
     
242.     build_f_table(p, zg, zp, file);
     
243.   }
     
244.   zfree(&zg);
     
245.   zfree(&zp);
     
246.   fclose(file);
     
247. }
     
248. 
     
249. void generate_j_table(long q_count, long q0)
     
250. {
     
251.   long A, B, *a, *f, i, k, l, m, p, pk;
     
252.   long pk1, pk3, q, q1, r, r0, x;
     
253.   FILE *f_file = fopen("f_table.dat", "r+b");
     
254.   FILE *j_file = fopen("j_table.dat", "w+b");
     
255. 
     
256.   if (!f_file || !j_file) {
     
257.     fprintf(stderr, "fatal error\ncan't open file(s)\n");
     
258.     exit(1);
     
259.   }
     
260.   if (q0 == 2) r0 = 1; else r0 = 0;
     
261.   for (r = r0; r < q_count; r++) {
     
262.     printf("\b\b%ld", r);
     
263.     fread(&q, sizeof(q), 1, f_file);
     
264.     f = calloc(q, sizeof(long));
     
265.     if (!f) {
     
266.       fprintf(stderr, "fatal error\ninsufficient memory\n");
     
267.       exit(1);
     
268.     }
     
269.     for (i = 1; i <= q - 2; i++)
     
270.       fread(&f[i], sizeof(f[i]), 1, f_file);
     
271.     q1 = q - 1;
     
272.     zpstart2();
     
273.     do {
     
274.       p = zpnext();
     
275.       if (q1 % p == 0) {
     
276.         k = 0;
     
277.         do {
     
278.           k++;
     
279.           q1 /= p;
     
280.         } while (q1 % p == 0);
     
281.       }
     
282.       pk = pow(p, k);
     
283.       pk1 = pow(p, k - 1);
     
284.       m = (p - 1) * pk1;
     
285.       a = calloc(m, sizeof(long));
     
286.       if (!a) {
     
287.         fprintf(stderr, "fatal error\ninsufficient memory\n");
     
288.         exit(1);
     
289.       }
     
290.       if (pk != 2) {
     
291.         for (i = 0; i < m; i++) a[i] = 0;
     
292.         A = B = 1;
     
293.         for (x = 1; x <= q - 2; x++) {
     
294.           l = (A * x + B * f[x]) % pk;
     
295.           if (l < m) a[l]++;
     
296.           else
     
297.             for (i = 1; i < p; i++)
     
298.               a[((l - i) * pk1) % l]--;
     
299.         }
     
300.         fwrite(&m, sizeof(m), 1, j_file);
     
301.         for (i = 0; i < m; i++)
     
302.           fwrite(&a[i], sizeof(a[i]), 1, j_file);
     
303.       }
     
304.       else if (p == 2 && k >= 3) {
     
305.         for (i = 0; i < m; i++) a[i] = 0;
     
306.         A = 2, B = 1;
     
307.         for (x = 1; x <= q - 2; x++) {
     
308.           l = (A * x + B * f[x]) % pk;
     
309.           if (l < m) a[l]++;
     
310.           else
     
311.             for (i = 1; i < p; i++)
     
312.               a[((l - i) * pk1) % l]--;
     
313.         }
     
314.         fwrite(&m, sizeof(m), 1, j_file);
     
315.         for (i = 0; i < m; i++)
     
316.           fwrite(&a[i], sizeof(a[i]), 1, j_file);
     
317.         for (i = 0; i < m; i++) a[i] = 0;
     
318.         pk3 = pow(2, k - 3);
     
319.         A = 3 * pk3, B = pk3;
     
320.         for (x = 1; x <= q - 2; x++) {
     
321.           l = (A * x + B * f[x]) % pk;
     
322.           if (l < m) a[l]++;
     
323.           else
     
324.             for (i = 1; i < p; i++)
     
325.               a[((l - i) * pk1) % l]--;
     
326.         }
     
327.         fwrite(&m, sizeof(m), 1, j_file);
     
328.         for (i = 0; i < m; i++)
     
329.           fwrite(&a[i], sizeof(a[i]), 1, j_file);
     
330.       }
     
331.       free(a);
     
332.     } while (q1 != 1);
     
333.   }
     
334.   free(f);
     
335.   fclose(f_file);
     
336.   fclose(j_file);
     
337. }
     
338. 
     
339. int main(void)
     
340. {
     
341.   long q_count, q[64];
     
342.   verylong ze = 0, zt = 0;
     
343. 
     
344.   zintoz(t, &zt);
     
345.   compute_e_of_t(zt, q, &ze, &q_count);
     
346.   printf("e(t) = "); zwriteln(ze);
     
347.   printf("log10(e(t)) = %lf\n", zln(ze) / log(10.0));
     
348.   printf("number of q primes = %ld\n", q_count);
     
349.   generate_f_table(q_count, q);
     
350.   printf("\ngenerated f_table\n");
     
351.   generate_j_table(q_count, q[0]);
     
352.   printf("\ngenerated j_table\n");
     
353.   zfree(&ze);
     
354.   zfree(&zt);
     
355.   return 0;
     
356. }
     

复制代码

无心人

1. 
   
2. /*
   
3.   Author:  Pate Williams (c) 1997
   
4. 
   
5.   Algorithm 10.3.3 (Lenstra's ECM). See "A Course
   
6.   in Computational Algebraic Number Theory" by
   
7.   Henri Cohen page 488.
   
8. */
   
9. 
   
10. #include <ctype.h>
    
11. #include <stdio.h>
    
12. #include <stdlib.h>
    
13. #include "lip.h"
    
14. 
    
15. #define CURVES 50l
    
16. 
    
17. struct point {verylong zx, zy, zz;};
    
18. 
    
19. int partial_addition(verylong za,
    
20.                      verylong zn,
    
21.                      struct point P,
    
22.                      struct point Q,
    
23.                      struct point *R,
    
24.                      verylong *zd)
    
25. /* returns 0 if sum is found or 1 if divisor is found */
    
26. {
    
27.   int value = 0;
    
28.   verylong zb = 0, zc = 0, zl = 0, zs = 0, zt = 0;
    
29.   verylong zx = 0, zy = 0, zy2 = 0;
    
30. 
    
31.   if (zcompare(P.zx, Q.zx) == 0 &&
    
32.       zscompare(P.zy, 0l) == 0 &&
    
33.       zscompare(Q.zy, 0l) == 0) {
    
34.     zzero(&R->zx);
    
35.     zone(&R->zy);
    
36.     return 0;
    
37.   }
    
38.   zsub(zn, Q.zy, &zb);
    
39.   if (zcompare(P.zx, Q.zx) == 0 &&
    
40.       zcompare(P.zy, zb) == 0) {
    
41.     zzero(&R->zx);
    
42.     zone(&R->zy);
    
43.     zfree(&zb);
    
44.     return 0;
    
45.   }
    
46.   if (zscompare(P.zx, 0l) == 0 &&
    
47.       zscompare(P.zy, 1l) == 0 &&
    
48.       zscompare(P.zz, 0l) == 0) {
    
49.     /* O + Q = Q */
    
50.     zcopy(Q.zx, &R->zx);
    
51.     zcopy(Q.zy, &R->zy);
    
52.     zcopy(Q.zz, &R->zz);
    
53.     value = 0;
    
54.   }
    
55.   else if (zscompare(Q.zx, 0l) == 0 &&
    
56.            zscompare(Q.zy, 1l) == 0 &&
    
57.            zscompare(Q.zz, 0l) == 0) {
    
58.     /* P + O = P */
    
59.     zcopy(P.zx, &R->zx);
    
60.     zcopy(P.zy, &R->zy);
    
61.     zcopy(P.zz, &R->zz);
    
62.     value = 0;
    
63.   }
    
64.   else {
    
65.     /* P != O and Q != O */
    
66.     zcopy(Q.zy, &zy2);
    
67.     znegate(&zy2);
    
68.     if (zcompare(P.zx, Q.zx) == 0  &&
    
69.         zcompare(P.zy, zy2)  == 0) {
    
70.       zzero(&R->zx);
    
71.       zone(&R->zy);
    
72.       zzero(&R->zz);
    
73.     }
    
74.     else {
    
75.       if (zcompare(P.zx, Q.zx) != 0) {
    
76.         zsubmod(P.zx, Q.zx, zn, &zx);
    
77.         zexteucl(zx, &zs, zn, &zt, zd);
    
78.         if (zscompare(*zd, 1l) != 0) goto L1;
    
79.         zsubmod(P.zy, Q.zy, zn, &zy);
    
80.         zmulmod(zs, zy, zn, &zl);
    
81.       }
    
82.       else {
    
83.         zaddmod(P.zy, Q.zy, zn, &zy);
    
84.         zexteucl(zy, &zs, zn, &zt, zd);
    
85.         if (zscompare(*zd, 1l) != 0) goto L1;
    
86.         zmulmod(P.zx, P.zx, zn, &zb);
    
87.         zsmulmod(zb, 3l, zn, &zc);
    
88.         zaddmod(zc, za, zn, &zb);
    
89.         zmulmod(zs, zb, zn, &zl);
    
90.       }
    
91.       zmulmod(zl, zl, zn, &zb);
    
92.       zaddmod(P.zx, Q.zx, zn, &zc);
    
93.       zsubmod(zb, zc, zn, &zx);
    
94.       zcopy(zx, &R->zx);
    
95.       zsubmod(zx, P.zx, zn, &zb);
    
96.       zmulmod(zl, zb, zn, &zc);
    
97.       zaddmod(zc, P.zy, zn, &zy);
    
98.       znegate(&zy);
    
99.       zcopy(zy, &R->zy);
    
100.       zone(&R->zz);
     
101.       goto L2;
     
102.       L1:
     
103.       value = 1;
     
104.       L2:
     
105.     }
     
106.   }
     
107.   zfree(&zb);
     
108.   zfree(&zc);
     
109.   zfree(&zl);
     
110.   zfree(&zs);
     
111.   zfree(&zt);
     
112.   zfree(&zx);
     
113.   zfree(&zy);
     
114.   return value;
     
115. }
     
116. 
     
117. int multiply(long k,
     
118.              verylong za,
     
119.              verylong zn,
     
120.              struct point P,
     
121.              struct point *R,
     
122.              verylong *zd)
     
123. {
     
124.   int value = 0;
     
125.   struct point A, S, T;
     
126. 
     
127.   A.zx = A.zy = A.zz = S.zx = S.zy = S.zz = 0;
     
128.   T.zx = T.zy = T.zz = 0;
     
129.   zzero(&R->zx);
     
130.   zone(&R->zy);
     
131.   zzero(&R->zz);
     
132.   zcopy(P.zx, &S.zx);
     
133.   zcopy(P.zy, &S.zy);
     
134.   zcopy(P.zz, &S.zz);
     
135.   while (!value && k != 0) {
     
136.     if (k & 1) {
     
137.       value = partial_addition(za, zn, *R, S, &A, zd);
     
138.       zcopy(A.zx, &R->zx);
     
139.       zcopy(A.zy, &R->zy);
     
140.       zcopy(A.zz, &R->zz);
     
141.     }
     
142.     k >>= 1;
     
143.     if (!value && k != 0) {
     
144.       value = partial_addition(za, zn, S, S, &T, zd);
     
145.       zcopy(T.zx, &S.zx);
     
146.       zcopy(T.zy, &S.zy);
     
147.       zcopy(T.zz, &S.zz);
     
148.     }
     
149.   }
     
150.   if (zscompare(R->zy, 0l) < 0) {
     
151.     zadd(R->zy, zn, &A.zy);
     
152.     zcopy(A.zy, &R->zy);
     
153.   }
     
154.   zfree(&A.zx);
     
155.   zfree(&A.zy);
     
156.   zfree(&A.zz);
     
157.   zfree(&S.zx);
     
158.   zfree(&S.zy);
     
159.   zfree(&S.zz);
     
160.   zfree(&T.zx);
     
161.   zfree(&T.zy);
     
162.   zfree(&T.zz);
     
163.   return value;
     
164. }
     
165. 
     
166. int LenstrasECM(verylong *zN, verylong *zg)
     
167. {
     
168.   int expon = 0, found;
     
169.   long B = 2000000l, i, j, k = 0, l, *p, q, q1;
     
170.   struct point x, y;
     
171.   verylong za[CURVES], zb = 0, zd = 0;
     
172. 
     
173.   for (i = 0; i < CURVES; i++) za[i] = 0;
     
174.   x.zx = x.zy = x.zz = y.zx = y.zy = y.zz = 0;
     
175.   zpstart2();
     
176.   do { q = zpnext(); k++; } while (q < B);
     
177.   p = calloc(k, sizeof(long));
     
178.   if (!p) {
     
179.     fprintf(stderr, "fatal error\ninsufficient memory\n");
     
180.     exit(1);
     
181.   }
     
182.   zpstart2();
     
183.   for (i = 0; i < k; i++) p[i] = zpnext();
     
184.   for (i = 0; i < CURVES; i++)
     
185.     zrandomb(*zN, &za[i]);
     
186.   L2:
     
187.   zone(&x.zx);
     
188.   zone(&x.zy);
     
189.   zzero(&x.zz);
     
190.   i = - 1;
     
191.   L3:
     
192.   i++;
     
193.   if (i == k) {
     
194.     for (i = 0; i < CURVES; i++)
     
195.       zrandomb(*zN, &za[i]);
     
196.     goto L2;
     
197.   }
     
198.   q = p[i];
     
199.   q1 = q;
     
200.   l = B / q;
     
201.   while (q1 <= l) q1 *= q;
     
202.   found = 0;
     
203.   for (j = 0; !found && j < CURVES; j++)
     
204.     found = multiply(q1, za[j], *zN, x, &y, &zd);
     
205.   if (!found) goto L3;
     
206.   zcopy(y.zx, &x.zx);
     
207.   zcopy(y.zy, &x.zy);
     
208.   zcopy(y.zz, &x.zz);
     
209.   zgcd(zd, *zN, zg);
     
210.   if (zcompare(*zg, *zN) == 0) {
     
211.     for (j = 0; j < CURVES; j++)
     
212.       zrandomb(*zN, &za[j]);
     
213.     goto L2;
     
214.   }
     
215.   do {
     
216.     zdiv(*zN, *zg, &zb, &zd);
     
217.     zcopy(zb, zN);
     
218.     zmod(*zN, *zg, &zd);
     
219.     expon++;
     
220.   } while (zscompare(zd, 0l) == 0);
     
221.   for (i = 0; i < CURVES; i++) zfree(&za[i]);
     
222.   zfree(&zb);
     
223.   zfree(&zd);
     
224.   zfree(&x.zx);
     
225.   zfree(&x.zy);
     
226.   zfree(&x.zz);
     
227.   zfree(&y.zx);
     
228.   zfree(&y.zy);
     
229.   zfree(&y.zz);
     
230.   return expon;
     
231. }
     
232. 
     
233. int main(void)
     
234. {
     
235.   int cant, expon, one, pri;
     
236.   char answer[256];
     
237.   verylong zN = 0, zd = 0, zg = 0;
     
238. 
     
239.   do {
     
240.     printf("enter the number to be factored below:\n");
     
241.     zread(&zN);
     
242.     if (zprobprime(zN, 5l))
     
243.       printf("number is prime\n");
     
244.     else {
     
245.       printf("number is composite\n");
     
246.       zintoz(6l, &zg);
     
247.       zgcd(zN, zg, &zd);
     
248.       if (zscompare(zd, 1l) != 0)
     
249.         printf("number can't be factored using Lenstra's ECM\n");
     
250.       else {
     
251.         printf("factors:\n");
     
252.         cant = 0, pri = 0;
     
253.         do {
     
254.           expon = LenstrasECM(&zN, &zg);
     
255.           zwrite(zg);
     
256.           if (expon == 1) printf("\n");
     
257.           else printf(" ^ %d\n", expon);
     
258.           one = zscompare(zN, 1l) == 0;
     
259.           if (!one) pri = zprobprime(zN, 5l);
     
260.           zintoz(6l, &zg);
     
261.           zgcd(zN, zg, &zd);
     
262.           if (zscompare(zd, 1l) != 0) {
     
263.             printf("number can't be factored using Lenstra's ECM\n");
     
264.             cant = 1;
     
265.           }
     
266.         } while (!cant && !one && !pri);
     
267.         if (pri) zwriteln(zN);
     
268.         if (cant) {
     
269.           zwriteln(zN);
     
270.           printf("last factor is composite\n");
     
271.         }
     
272.       }
     
273.     }
     
274.     printf("another number (n or y)? ");
     
275.     scanf("%s", answer);
     
276.   } while (tolower(answer[0]) == 'y');
     
277.   zfree(&zN);
     
278.   zfree(&zd);
     
279.   zfree(&zg);
     
280.   return 0;
     
281. }
     

复制代码

无心人

需要freelip库

ftp://ftp.ox.ac.uk/pub/math/freelip/
要休息了
明天想办法下载下来这个库
就补全了

xiugakei

斑竹果然是强人

无心人

http://cr.yp.to/arith.html
几个算法，没仔细看

无心人

http://topic.csdn.net/t/20011210/22/414003.html

freelip_1.1.tar.gz (197.02 KB, 下载次数: 18)

2008-12-1 17:20 上传

点击文件名下载附件

winxos

原帖由 无心人 于 2008-12-1 17:20 发表
http://topic.csdn.net/t/20011210/22/414003.html

602

我一直很诧异，为什么各位经常可以搞到这么多我看来这么离奇的地方的奇怪的东西？

gxqcn

说是无心实乃有心人。

只是呼吸

我只能写VB的，对C还不会，就像上面的那两个几百行的程序，我把它复制下来，在C++6.0上却通不过编译器。
这两个程序在编译时都指出是#include "lip.h"这一行出了问题，通不过。而我又不知道这是为什么。烦啊。