Факторизация методом больного воображения

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

 

Хвалиться знанием матемматики я не буду, так что за доводами обращайся на соответствующий форум. Я человек практичный, и поэтому о всем сужу только по результатам. Если у меня есть GNFS, которым реально факторизовать 512 бит на небольшой распределеной сети, то мне не нужны никакие другие методы, если они не дотягивают до него в эффективности. Поэтому хотелось бы увидеть твои бенчмарки хотя-бы для 256 битных чисел (в сравнении с MPQS и GNFS).

 

Тоже самое могу сказать и о себе)) - разберусь с архиватором, тогда пропишу ету методу иль кто-нить пропишет и практика поставит все точки над i, хотя эта метода далеко не то, что я хотел бы узреть))

 

вот код почти усех метод, кои я настрокал, так же есть код full order и родственного ему шифта. Если кто хочет тест драйва - либу gmp и все нужные хедеры берите тут: http://xproject-all.narod.ru/csc_algo_debug_ver.7z
----------------------------------------------------------------------------------------------------------
Результаты опубликуйте здесь или сообщите мне по мылу, плзззззззззззззз..зз
----------------------------------------------------------------------------------------------------------

Код (Text):

1. // Catcher_of_Secret_Key.cpp : Defines the entry point for the console application.
2. //
3.  
4. #include "stdafx.h"
5. #include <stdio.h>
6. #include <stdlib.h>
7. #include <windows.h>
8. //#include "windows.h"
9. //#include "Winuser.h"
10. //#include "Wincon.h"
11. //#include "Wingdi.h"
12. #include <math.h>
13. //#include "stdio.h"
14. #include "conio.h"
15. //#include <iostream>
16. #include "iso646.h"
17. #include <locale.h>
18. //#include <stdlib.h>
19. #include <time.h>
20. #include "gmpxx.h"
21. #include "gmp.h"
22. #include "mpfr.h"
23.  
24. #include "mpf2mpfr.h"
25. #pragma comment (lib, "gmp1.lib")
26. //#pragma comment (lib, "gmpd.lib")
27. //#pragma comment (lib, "libbz2.lib")
28. //#pragma comment (lib, "libbz2d.lib")
29. //#pragma comment (lib, "zlib.lib")
30. //#pragma comment (lib, "zlibd.lib")
31. //#pragma comment (lib, "wingmp.lib")
32.  
33. //#include "mpfrxx.h"
34.  
35. //#include "gmp.h"
36. //#include "gmp.h"
37.  
38. //#using <gmp.dll>
39. mpz_t nl;
40. typedef unsigned long ul;
41. typedef unsigned __int64 ui64;
42. using namespace std;
43.  
44. void inline mod(mpz_t n, mpz_t *q, mpz_t *tmp){
45.    // mpf_t tmp;
46.     if(mpz_cmp_ui(*q,1)>0){
47.         mpz_div(*tmp, n, *q);
48. //        mpz_floor(tmp, tmp);
49.         mpz_mul(*tmp,*q, *tmp);
50.         mpz_sub(n, n, *tmp);
51.        // n-=floor(n/abs(*q))**q;
52.         }
53.     return;
54.     }
55. //long double mod(long double n, long double *q){
56. //   if(*q>1) n-=floor(n/abs(*q))**q;
57. //    return n;
58. //    }
59. void series(mpz_t &n, mpz_t &base_c, ui64 basis, ui64 iter){
60.     mpz_set_ui(base_c, basis);
61.     for(;iter>0; iter--){
62.         mpz_mul_ui(base_c, base_c, 2);
63.         mpz_add_ui(base_c, base_c, 1);
64.     }
65.     return;
66. }
67. int inline test_frac(mpf_t *p){
68.     mpf_t tmp;
69.     mpf_floor(tmp, *p);
70.     if (mpf_cmp(*p, tmp)>0) return 2;
71.     else return 0;
72.     }
73. BOOL WINAPI welcome(
74.   DWORD msg
75.   ){
76.       if(msg==CTRL_CLOSE_EVENT){MessageBox(0, "GOO..OD LUCK to YOU!!", "Thanks for using this app", MB_ICONWARNING|MB_DEFAULT_DESKTOP_ONLY);
77.            ExitProcess(0);}
78.      // if(msg==CTRL_C_EVENT) ShellExecuteW(0,L"",L"http://xproject-all.narod.ru/prgsale.htm",L"",L"", 0);
79.      // getch();
80.      
81.      
82. //else return 0;
83.       }
84.  
85. int _tmain(int argc, _TCHAR* argv[])
86. {
87. HGLOBAL   hglb;
88.     char* clrstr=new char[150000];
89.     char *str_n=new char[150000];
90.     char *str_p=new char[150000];
91.     char *str_q=new char[150000];
92.     char* lptstr = new char[150000];
93.     DWORD num_write;
94.      HANDLE file;
95.      file=CreateFile("ans.txt" ,
96.       GENERIC_WRITE|GENERIC_READ,0,0, OPEN_ALWAYS,FILE_FLAG_SEQUENTIAL_SCAN, 0);
97. mpz_t n, base, div, save_q, sub, save_n, /*mod_arr[2048]*/ tmp, zp, zq, zero, base_c, prime, sqrt, sum, count_step, delta, mod,
98. save_p, dist_p, dist_q, cdist_q, cdist_p, sqr, up_limit, down_limit;
99. mpf_t distance_p, distance_q;
100. int clr_bad_dgt=0, i;
101. //mpz_init2(count, 1);
102. //mpfr_init_set_ui(distance_p, 2, 5);
103. //mpf_set_prec(distance_p, 2500);
104. //mpf_init2(distance_q, 2500);
105. mpz_init_set_ui(base_c, 1);
106. mpz_init(up_limit);
107. mpz_init(down_limit);
108.    mpz_init_set_ui(base, 1);
109.    mpz_init_set_ui(delta, 1);
110.    mpz_init_set_ui(n, 1);
111.    mpz_init_set_ui(tmp, 0);
112.    mpz_init_set_ui(zp, 1);
113.    mpz_init_set_ui(zq, 1);
114.    mpz_init_set_ui(sub, 1);
115.     mpz_init_set_ui(dist_p, 1);
116.      mpz_init_set_ui(dist_q, 1);
117.      mpz_init_set_ui(cdist_q, 1);
118.      mpz_init_set_ui(cdist_p, 1);
119.      mpz_ui_pow_ui(cdist_p, 10, 190);
120.      mpz_ui_pow_ui(cdist_q, 10, 2);
121.      mpz_get_str(lptstr, 10, dist_q);
122. cout<<lptstr<<"\n";
123.      mpz_mul_ui(cdist_q, cdist_q, 4);
124. mpz_get_str(lptstr, 10, dist_q);
125. cout<<lptstr<<"\n";
126.  
127.     mpz_init_set_ui(sqrt, 1);
128. //mpz_init2(t, 2);
129. unsigned __int64   ceven=0, bit=1, one=1, remainder, odd, inv_curr, t=2, count=1, basis;
130. int test_p=1, flg, flg1;
131. //ui64* mod_arr=new ui64[1024];
132. //mpz_array_init (mod_arr[0], 2048, 3072);
133. bool test_even=false;
134.  
135.             //GlobalUnlock(hglb);
136.            
137.             /*;
138.             if (!OpenClipboard(NULL))
139.                 return 0; */
140. //MessageBox(0, lptstr, "Thanks for using this app", MB_ICONWARNING|MB_DEFAULT_DESKTOP_ONLY);
141. //CloseClipboard();
142. //
143. //            }}
144. SetConsoleCtrlHandler(&welcome, true);
145. SetConsoleTitle("GOO..OD PRESENT to Public Key Cryption (^w^)--------------------> LN  ED!T!ON !!!                                 2007");
146. MessageBox(0, "Special thanks to Eugene Chukhlomin for support of this project\n<c> KnyazhEV Evgeney\nWEB:\nhttp://xproject-all.narod.ru/prgsale.htm", "Thanks for using this app", MB_ICONWARNING|MB_DEFAULT_DESKTOP_ONLY);
147. SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_RED|FOREGROUND_INTENSITY);
148. start: system("cls");
149. cout<<"VERSION IV\n\nApp is using GMP Lib (ver. 4.2.1) for support of long numbers\n\n";
150. //cout<<"(CTRL+BREAK) Welcome to my web\n";
151. cout<<"p ----> Paste number from clipboard.\nt -----> Type number";
152. mpz_init_set_ui(prime, 0);
153. mpz_sqrt(prime, n);
154. switch(getch()){
155.     case 'p':
156.         {
157.         /*if (!IsClipboardFormatAvailable(CF_TEXT))
158.             return 0; */
159.         if (!OpenClipboard(NULL)){
160.             MessageBox(0, "Access to clipboard is denied: try again.", "Err.", MB_ICONWARNING|MB_DEFAULT_DESKTOP_ONLY);
161.             goto start;
162.             }
163.         hglb = GetClipboardData(CF_TEXT);
164.         if (hglb != NULL)
165.         {
166.             lptstr = (char*)GlobalLock(hglb);
167.             if (lptstr == NULL)
168.                 {
169.                 MessageBox(0, "Clipboard is empty.", "Err.", MB_ICONWARNING|MB_DEFAULT_DESKTOP_ONLY);
170.             goto start;
171.                 }
172.             else{
173.                 clr_bad_dgt=i=0;
174.                 while(lptstr[i]!=0) {
175.                     if(isdigit(lptstr[i])){
176.                         clrstr[clr_bad_dgt]=lptstr[i];
177.                         clr_bad_dgt++;
178.                     }
179.                     i++;
180.                 }
181.                 clrstr[clr_bad_dgt]=0;
182.                 //strcpy(lptstr, clrstr);
183.                 mpz_set_str(n, clrstr, 10);
184.                 printf("\nEnter, Please, n=pq: %s\n",clrstr);
185.                  CloseClipboard();
186.                 }
187.         }
188.     }
189.         break;
190.     case 't':
191.         printf("\nEnter, Please, n=pq: ");
192.         cin>>clrstr;
193.          mpz_set_str(n, clrstr, 10);
194.          memset(clrstr, 0, sizeof(clrstr));
195.          mpz_get_str(clrstr, 10, n);
196. //       printf("%s", clrstr);
197. break;
198.     default:
199.         goto start;
200.     }
201. bit=1;
202. //cin>>n;
203. mpz_init_set(save_n, n);
204. if(mpz_even_p(n))
205.     {
206.     MessageBox(0, "Number must be odd", "Err:", MB_ICONWARNING|MB_DEFAULT_DESKTOP_ONLY);
207.     goto start;
208.     }
209. cout<<"Choose method for breaking down n:\np------> Dee..ep (basis A)\nh -------> Dual Catch (eXt. of Dee..ep)\nr------> Dee..ep (basis 2p+1)\ni -----> Back Step (basis A)\nc -----> Down Fix -- (basis A)\np------> Dee..ep (basis Variat!ON)\na--------> Dee..ep Ver.II(basis A)\nq -------> Dee..ep Root (basis A) \nd ----> String (Down Limit)\nn ----> n^t (APPLY IT, IF METHOD(S) NOT EFFECTIVE FOR n)\n\n e -----> Enter new number\nt------->To Set t mmanually\nz ----->n*z\n s ----------> n^(1/2)\n ";
210. //base=3;
211. //odd=(unsigned __int64)n;
212. //one&=(__int64)mod(n, &base);
213. //count=1;
214. //div=mpz_class(n);
215. //mpz_sqrt(prime, n);
216. mpz_set(prime, n);
217.  
218. mpz_t dlt_high, max, addxy, subxy, peak, block, period, step, sumOne, sum2, saveSumOne,
219. saveSum2, inv, z, head; mpz_init(head);
220. size_t start_base, count_step_local;
221. mpz_init(period); mpz_init(block); mpz_init(step); mpz_init(sumOne); mpz_init(sum2); mpz_init(inv); mpz_init(saveSumOne);
222. mpz_init(z);
223. int size_of_num;
224. mpf_t mpf;
225. gmp_randstate_t rnd;
226. //mpf_init(mpf);
227. enter: switch(getch()){
228. case 'F':
229. cout<<"FULL ORDER"<<"\n";
230. mpz_sqrt(sqr, save_n);
231. mpz_set_ui(zp, 1);
232. size_of_num=ceil((double)mpz_sizeinbase(save_n, 2)/2);
233. gmp_randinit_mt(rnd);
234. while(mpz_cmp(head, sqr)<0) mpz_urandomm(head, rnd, save_n);
235. for(;mpz_cmp_ui(zp,1)==0;)
236. {
237.     for(int i=0; i<size_of_num+1 && mpz_cmp_ui(zp,1)==0; i++)
238.     {
239.         //mpz_mul_2exp(sumOne, save_n, i);
240.         mpz_add(head, head, save_n);
241.         mpz_set(sum2, head);
242.         for(int z=0; z<size_of_num+1 && mpz_cmp_ui(zp,1)==0; z++)
243.         {          
244.             mpz_fdiv_q_ui(sum2, sum2, 2);
245.             mpz_gcd(zp, save_n, sum2);
246.         }
247.     }
248. }
249. mpz_fdiv_q(zq, save_n, zp);
250. break;
251. case 'S':
252. cout<<"SH!FT"<<"\n";
253. mpz_sqrt(sqr, save_n);
254. mpz_set_ui(zp, 1);
255. size_of_num=ceil((double)mpz_sizeinbase(save_n, 2)/2);
256. gmp_randinit_mt(rnd);
257. while(mpz_cmp(head, sqr)<0) mpz_urandomm(head, rnd, save_n);
258. for(;mpz_cmp_ui(zp,1)==0;)
259. {
260.     for(int i=0; i<size_of_num+1 && mpz_cmp_ui(zp,1)==0; i++)
261.     {
262.         mpz_mul_2exp(sumOne, save_n, i);
263.         mpz_add(head, head, sumOne);
264.         mpz_set(sum2, head);
265.         for(int z=0; z<size_of_num+1 && mpz_cmp_ui(zp,1)==0; z++)
266.         {          
267.             mpz_fdiv_q_ui(sum2, sum2, 2);
268.             mpz_gcd(zp, save_n, sum2);
269.         }
270.     }
271. }
272. mpz_fdiv_q(zq, save_n, zp);
273. break;
274. case 'L':
275.     cout<<"Length TeA"<<"\n";
276. mpz_sqrt(z, save_n);
277. //mpz_set(dlt_high, z);
278. mpz_mul_ui(z, z, 2);
279. mpz_set_ui(zp,1);
280. while(mpz_cmp_ui(zp,1)==0)
281. {
282.     mpz_set(sum2, z);
283.     mpz_init_set(dlt_high, z);
284.     while(mpz_cmp_ui(dlt_high, 1)>0)
285.     {
286.         mpz_cdiv_q_ui(dlt_high, dlt_high, 2);
287.         mpz_mul(sumOne, sum2, dlt_high);
288.         mpz_gcd(zp, save_n, sumOne);
289.         if(mpz_cmp_ui(zp, 1)>0 || mpz_cmp_ui(dlt_high,1)==0) break;
290.         if(mpz_cmp(save_n, sumOne)>0)mpz_add(sum2, sum2, dlt_high);
291.         else mpz_sub(sum2, sum2, dlt_high);
292.        
293.     }
294.     mpz_add_ui(z, z, 137438953472);
295. }
296. mpz_fdiv_q(zq, save_n, zp);
297. break;
298. case 'K':
299. mpz_set_ui(zp, 1);
300. start_base=mpz_sizeinbase(save_n, 2);
301. mpz_set_ui(sumOne, 0);
302.     for(int i=0; i<start_base; i++){
303.         mpz_set_ui(sum2, 0);
304.         for(int z=0; z<i+1; z++){
305.             if(mpz_tstbit(save_n, start_base-z-1)==true) mpz_setbit(sum2, i-z);
306.         }
307.         mpz_gcd(zp, sum2, save_n);
308. if(mpz_cmp_ui(zp,1)>0 && mpz_cmp(zp,save_n)!=0) break;
309. mpz_add(sumOne, sumOne, sum2);
310. mpz_gcd(zp, sumOne, save_n);
311. if(mpz_cmp_ui(zp,1)>0 && mpz_cmp(zp,save_n)!=0) break;
312.     }
313.     mpz_fdiv_q(zq, save_n, zp);
314.  break;
315. case 'M':
316.     mpz_set(sum2, save_n);
317.     mpz_set(sumOne, save_n);
318.  for(;;)
319.  {
320.     mpz_fdiv_q_ui(sum2, sum2, 2);
321.         if(mpz_cmp_ui(sum2, 0)==0) break;
322. mpz_xor(sumOne, sum2, sumOne);
323. mpz_gcd(zp, save_n, sumOne);
324. if(mpz_cmp_ui(zp,1)>0) break;
325. start_base=mpz_sizeinbase(sumOne, 2);
326. mpz_ui_pow_ui(inv, 2, start_base);
327. mpz_sub_ui(inv, inv, 1);
328. mpz_xor(inv,inv, sumOne);
329. mpz_gcd(zp, save_n, inv);
330. if(mpz_cmp_ui(zp,1)>0) break;
331.  }
332.  mpz_fdiv_q(zq, save_n, zp);
333.  break;
334. case 's':
335.     mpz_sqrt(n, n);
336.         goto enter;
337. case 'k':
338.     /********************************************** Suture **********************************************************/
339. cout<<"Used method: "<<"Suture (Shov)\n";
340.     start_base=mpz_sizeinbase(n, 2)-1;
341.     mpz_add(sumOne, save_n, n);
342.     mpz_set(sum2, n);
343.     mpz_ui_pow_ui(period, 2, start_base);
344.     mpz_sqrt(sqr, save_n);
345.     start_base=mpz_sizeinbase(sqr, 2)-1;
346.     mpz_ui_pow_ui(block, 2, start_base);
347.     mpz_sub(sumOne, sumOne, block);
348.     mpz_set_ui(zp, 1);
349.     count_step_local=0;
350.     count=0;
351.     cout<<"Choose Ver.\nl ----> Lite\nAny key ------> Full\n";
352.     if (getch()=='l') mpz_mul_ui(period, block, 2);
353.     while(mpz_cmp(period, block)>=0 && mpz_cmp_ui(zp,1)==0){
354.         mpz_init_set(saveSumOne, sumOne);
355.         mpz_init_set(saveSum2, sum2);
356.         while(mpz_cmp(sum2, period)>0 && mpz_cmp_ui(zp,1)==0)
357.         {
358.             mpz_sub(sumOne, sumOne, period);
359.             //mpz_sub(sum2, sum2, period);
360.             mpz_gcd(zp, sumOne, save_n);
361.             //if (mpz_cmp_ui(zp,1)==0) mpz_gcd(zp, sum2, save_n);
362.             if (mpz_cmp(block, period)==0) count_step_local++;
363.             count++;
364.             mpz_sub(sumOne, sumOne, block);
365.         }
366.         mpz_cdiv_q_ui(period, period, 2);
367.         mpz_init_set(sumOne, saveSumOne);
368.         mpz_init_set(sum2, saveSum2);
369.     }
370.     cout<<"Count of Step: "<<"All: "<<count<<"; Local: "<<count_step_local<<"\n";
371.     mpz_div(zq, save_n, zp);
372.     break;
373.     /********************************************** Suture **********************************************************/
374. case 'u':
375.     /************************** Dual BSF **********************************************************/
376.     {
377. mpz_set(up_limit, save_n);
378. mpz_init_set(dlt_high, save_n);
379. mpz_init(max);
380. mpz_init(peak);
381. mpz_init(addxy);
382. mpz_init(subxy);
383. mpz_cdiv_q_ui(dlt_high, dlt_high, 2);
384. mpz_set_ui(zp, 1);
385. mpz_sqrt(sqr, save_n);
386. //mpz_set_ui(count, 0);
387. count=0;
388. while(mpz_cmp_ui(zp, 1)==0 || mpz_cmp(zp, save_n)==0){
389.     mpz_gcd(zp, save_n, max);
390.             if( mpz_cmp_ui(zp, 1)>0 && mpz_cmp(zp, save_n)!=0) break;
391.     mpz_fdiv_q_ui(down_limit, up_limit, 2);
392.     //mpz_add(addxy, up_limit, down_limit);
393.     mpz_sub(subxy, up_limit, down_limit);
394.     mpz_mul(max, subxy, down_limit);
395.     if(mpz_cmp(max,save_n)<0 && mpz_cmp(up_limit, sqr)>0 || mpz_cmp(save_n,peak)<0){
396.         mpz_add(up_limit, up_limit, dlt_high);
397.         //mpz_add(count, count, 1);
398.         count++;
399.     }
400.     else{
401.         mpz_set(down_limit, sqr);
402.         mpz_cdiv_q_ui(delta, sqr, 2);
403.         while(mpz_cmp_ui(delta, 1)>0/* && mpz_cmp_ui(zp, 1)==0*/){
404.             //mpz_add(count, count, 1);
405.             count++;
406.             mpz_gcd(zp, save_n, max);
407.             if( mpz_cmp_ui(zp, 1)>0 || mpz_cmp_ui(delta, 1)==0) break;
408.             if(mpz_cmp(max, n)>0) mpz_add(down_limit, down_limit, delta);
409.             //else if( mpz_cmp(subx2y2, n)==0) mpz_gcd(zp, save_n, addxy);
410.             else mpz_sub(down_limit, down_limit, delta);
411.             //if(mpz_cmp_ui(subxy, 1)>0 && mpz_cmp_ui(delta, 1)==0) break;
412.             mpz_cdiv_q_ui(delta, delta, 2);
413.            
414.             mpz_sub(subxy, up_limit, down_limit);
415.             mpz_mul(max, subxy, down_limit);
416.  
417.         }
418.         mpz_sub(up_limit, up_limit, dlt_high);
419.         mpz_set(peak, max);
420.         //else mpz_set(dlt_high, up_limit);
421.     }
422.     if(mpz_cmp_ui(dlt_high, 1)==0) mpz_set(dlt_high, up_limit);
423. mpz_fdiv_q_ui(dlt_high, dlt_high, 2);
424. }
425. mpz_cdiv_q(zq, save_n, zp);
426.  
427.     }
428.     cout<<"Count of iter."<<count<<"\n";
429.     break;
430.     /************************** Dual BSF **********************************************************/
431. case 'b':
432.     {
433. /********************** TRY BSF *****************************************************************************/
434. mpz_init(save_p);
435. mpz_init(save_q);
436. mpz_init(mod);
437. mpz_mul(cdist_q, cdist_q, n);
438. mpz_sqrt(sqrt, cdist_q);
439. mpz_init(sqr);
440. mpz_sqrt(sqr, save_n);
441. mpz_cdiv_q_ui(delta, n, 2);
442. mpz_set(zp, save_n);
443. mpz_set_ui(zq, 1);
444. mpz_set(n, save_n);
445. //mpz_sub(zp, zp, delta);
446. while(mpz_cmp_ui(delta, 1)>0 && mpz_cmp_ui(zq, 1)==0){
447.     mpz_pow_ui(n, zp, 2);
448.     mpz_sub(div, n, save_n);
449.     mpz_fdiv_qr(div,mod, div, zp);
450.     mpz_sub(sub, zp, div);
451. mpz_mul(dist_p, cdist_p, zp);
452. mpz_fdiv_q(dist_p, dist_p, sqrt);
453. mpz_fdiv_q(dist_q, save_n, sub);
454. //flg=;
455. flg1=mpz_cmp(zp, sqr);
456. mpz_get_str(lptstr, 10, dist_q);
457. cout<<*lptstr<<"\n";
458.     if(mpz_cmpabs(div,sqr)>0 || (mpz_cmp(zp, dist_q)>0 && flg1>0 && mpz_cmp(dist_q, sqr)>0))
459.         mpz_sub(zp, zp, delta);
460.     else mpz_add(zp, zp, delta);
461.     mpz_gcd(zq, save_n, zp);
462. mpz_cdiv_q_ui(delta, delta, 2);
463. }
464. if(mpz_cmp_ui(zq, 0)>0) mpz_div(zp, save_n, zq);
465. break;
466. /********************** TRY BSF *****************************************************************************/
467.     }
468. case 'y':
469.     {
470.           cout<<"Used method: "<<" Pyramid (basis A)\n";
471.               count=2;
472. //        div=0;
473.         mpz_init_set_ui(zero, 1);
474.         mpz_init_set_ui(base, 1);
475.         while( mpz_cmp_ui(zero, 0)>0 && mpz_cmp(n, base)>0){
476.             mpz_ui_pow_ui(base, 2, count);
477.             mpz_fdiv_qr(save_q, tmp, n, base);
478.             mpz_add(zq, zq, save_q);
479.            // mpz_set(mod_arr[(ui64)count], tmp);
480.            // mpz_init_set_ui(zq,0);
481.             for(inv_curr=0; inv_curr<count && mpz_cmp_ui(zero, 0)>0; inv_curr++){
482.                 //mpf_set_z(tmp_f, );
483.                 mpz_add(zq, zq, tmp);
484.                  // mpf_set_z(tmp_f, n);
485.                     mpz_gcd(zero,n,zq);
486.                     if(mpz_cmp_ui(zero, 1)>0){
487.                         mpz_set(zq, zero);
488.                         mpz_set_ui(zero, 0);
489.                         break;
490.                     }
491.                       mpz_ui_pow_ui(base_c, 2, count-inv_curr);
492.                       mpz_mod(tmp,n, base_c);
493.                 }
494.         count++;
495.             }
496.            
497.        if(mpz_cmp_ui(zq, 0)>0) mpz_div(zp, save_n, zq);
498.    // q=n/p;
499.     break;
500.  
501. /**************** Dee..ep (basis A) *************************************************/
502.         }
503.         case 'h':
504.         {
505.          /**************** Dual Catch (eXt. of Dee..ep) *************************************************/
506.         cout<<"Used method: "<<"Dual Catch (eXt. of Dee..ep)\n";
507.               count=1;
508. //        div=0;
509.         mpz_init_set_ui(zero, 1);
510.         mpz_init_set_ui(base, 1);
511.         while( mpz_cmp_ui(zero, 0)>0 && mpz_cmp(n, base)>0){
512.             mpz_init(zq);
513.             mpz_ui_pow_ui(base, 2, count);
514.             mpz_fdiv_qr(zq, tmp, n, base);
515.            // mpz_set(mod_arr[(ui64)count], tmp);
516.              mpz_gcd(zero,n,zq);
517.            if(mpz_cmp_ui(zero, 1)>0){
518.                         mpz_set(zq, zero);
519.                         mpz_set_ui(zero, 0);
520.                         break;
521.                     }
522.             for(inv_curr=0; inv_curr<count && mpz_cmp_ui(zero, 0)>0; inv_curr++){
523.                 //mpf_set_z(tmp_f, );
524.                 mpz_add(zq, zq, tmp);
525.                  // mpf_set_z(tmp_f, n);
526.                     mpz_gcd(zero,n,zq);
527.                     if(mpz_cmp_ui(zero, 1)>0){
528.                         mpz_set(zq, zero);
529.                         mpz_set_ui(zero, 0);
530.                         break;
531.                     }
532.                       mpz_ui_pow_ui(base_c, 2, count-inv_curr);
533.                       mpz_mod(tmp,n, base_c);
534.                 }
535.         count++;
536.             }
537.            
538.         if(mpz_cmp_ui(zq,0)>0) mpz_div(zp, n, zq);
539.    // q=n/p;
540.     break;
541.  
542. /**************** Dee..ep (basis A) *************************************************/
543.         }
544.          case 'r':
545.         {
546.          /**************** Dee..ep (basis 2p+1) *************************************************/
547.         cout<<"Used method: "<<"Dee..ep (basis 2p+1)\n";
548.         cout<<"Enter, Please, basis\n";
549.         cin>>basis;
550.               count=2;
551. //        div=0;
552.         mpz_init_set_ui(zero, 1);
553.         mpz_init_set_ui(base, 1);
554.         while( mpz_cmp_ui(zero, 0)>0 && mpz_cmp(n, base)>0){
555.             mpz_ui_pow_ui(base, basis, count);
556.             mpz_mod(tmp, n, base);
557.            // mpz_set(mod_arr[(ui64)count], tmp);
558.             mpz_init_set_ui(zq,1);
559.             for(inv_curr=0; inv_curr<count && mpz_cmp_ui(zero, 0)>0; inv_curr++){
560.                 //mpf_set_z(tmp_f, );
561.                 mpz_add(zq, zq, tmp);
562.                  // mpf_set_z(tmp_f, n);
563.                     mpz_gcd(zero,n,zq);
564.                     if(mpz_cmp_ui(zero, 1)>0){
565.                         mpz_set(zq, zero);
566.                         mpz_set_ui(zero, 0);
567.                         break;
568.                     }
569.                       series(n, base_c, basis, count-inv_curr);
570.                       mpz_mod(tmp,n, base_c);
571.                 }
572.         count++;
573.             }
574.            
575.     if(mpz_cmp_ui(zq,0)>0) mpz_div(zp, n, zq);
576.    // q=n/p;
577.     break;
578.  
579. /**************** Dee..ep (basis A) *************************************************/
580.         }
581.         case 'a':
582.         {
583.          /**************** Dee..ep Ver.II(basis A) *************************************************/
584.         cout<<"Used method: "<<"Dee..ep Ver.II (basis A)\n";
585.               count=2;
586. //        div=0;
587.         mpz_init_set_ui(zero, 1);
588.         mpz_init_set_ui(base, 1);
589.         mpz_sqrt(sqrt, n);
590.         while( mpz_cmp_ui(zero, 0)>0 && mpz_cmp(n, base)>0){
591.             mpz_ui_pow_ui(base, 2, count);
592.             mpz_mod(tmp, n, base);
593.            // mpz_set(mod_arr[(ui64)count], tmp);
594.             mpz_init_set(zq,sqrt);
595.             for(inv_curr=0; inv_curr<count && mpz_cmp_ui(zero, 0)>0; inv_curr++){
596.                 //mpf_set_z(tmp_f, );
597.                 mpz_add(zq, zq, tmp);
598.                  // mpf_set_z(tmp_f, n);
599.                     mpz_gcd(zero,n,zq);
600.                     if(mpz_cmp_ui(zero, 1)>0){
601.                         mpz_set(zq, zero);
602.                         mpz_set_ui(zero, 0);
603.                         break;
604.                     }
605.                       mpz_ui_pow_ui(base_c, 2, count-inv_curr);
606.                       mpz_mod(tmp,n, base_c);
607.                 }
608.         count++;
609.             }
610.            
611.        if(mpz_cmp_ui(zq,0)>0) mpz_div(zp, n, zq);
612.    // q=n/p;
613.     break;
614.  
615. /**************** Dee..ep (basis A) *************************************************/
616.         }
617.          case 'v':
618.         {
619.          /**************** Dee..ep (basis Variat!ON) *************************************************/
620.         cout<<"Used method: "<<"Dee..ep (basis Variat!ON)\n";
621.         cout<<"Enter, Please, basis\n";
622.         cin>>basis;
623.               count=2;
624. //        div=0;
625.         mpz_init_set_ui(zero, 1);
626.         while( mpz_cmp_ui(zero, 0)>0 && mpz_cmp(n, base)>0){
627.             mpz_ui_pow_ui(base, basis, count);
628.             mpz_mod(tmp, n, base);
629.            // mpz_set(mod_arr[(ui64)count], tmp);
630.             mpz_init_set_ui(zq,1);
631.             for(inv_curr=0; inv_curr<count && mpz_cmp_ui(zero, 0)>0; inv_curr++){
632.                 //mpf_set_z(tmp_f, );
633.                 mpz_add(zq, zq, tmp);
634.                  // mpf_set_z(tmp_f, n);
635.                     mpz_gcd(zero,n,zq);
636.                     if(mpz_cmp_ui(zero, 1)>0){
637.                         mpz_set(zq, zero);
638.                         mpz_set_ui(zero, 0);
639.                         break;
640.                     }
641.                       mpz_ui_pow_ui(base_c, basis, count-inv_curr);
642.                       mpz_mod(tmp,n, base_c);
643.                 }
644.         count++;
645.             }
646.            
647.     if(mpz_cmp_ui(zq,0)>0) mpz_div(zp, n, zq);
648.    // q=n/p;
649.     break;
650.  
651. /**************** Dee..ep (basis A) *************************************************/
652.         }
653.         case 'w':
654.         {
655.          /**************** Dee..ep Ver.II(basis A) *************************************************/
656.         cout<<"Used method: "<<"Dee..ep Ver.II (basis A)\n";
657.               count=2;
658. //        div=0;
659.         mpz_init_set_ui(zero, 1);
660.         mpz_sqrt(sqrt, n);
661.         while( mpz_cmp_ui(zero, 0)>0 && mpz_cmp(n, base)>0){
662.             mpz_ui_pow_ui(base, 2, count);
663.             mpz_mod(tmp, n, base);
664.            // mpz_set(mod_arr[(ui64)count], tmp);
665.             mpz_init_set(zq,sqrt);
666.             for(inv_curr=0; inv_curr<count && mpz_cmp_ui(zero, 0)>0; inv_curr++){
667.                 //mpf_set_z(tmp_f, );
668.                 mpz_add(zq, zq, tmp);
669.                  // mpf_set_z(tmp_f, n);
670.                     mpz_gcd(zero,n,zq);
671.                     if(mpz_cmp_ui(zero, 1)>0){
672.                         mpz_set(zq, zero);
673.                         mpz_set_ui(zero, 0);
674.                         break;
675.                     }
676.                       mpz_ui_pow_ui(base_c, 2, count-inv_curr);
677.                       mpz_mod(tmp,n, base_c);
678.                 }
679.         count++;
680.             }
681.            
682.         if(mpz_cmp_ui(zq,0)>0) mpz_div(zp, n, zq);
683.    // q=n/p;
684.     break;
685.  
686. /**************** Dee..ep (basis A) *************************************************/
687.         }
688.         case 'q':
689.     {
690.       /**************** Dee..ep Root (basis A) *************************************************/
691.          cout<<"Used method: "<<"Dee..ep Root (basis A)\n";
692.         mpz_init_set_ui(zero, 1);
693.          mpz_sqrt(sqrt, n);
694.               count=2;
695. //        div=0;
696.        
697.         while( mpz_cmp_ui(zero, 0)>0 && mpz_cmp(sqrt, base)>0){
698.             mpz_ui_pow_ui(base, 2, count);
699.             mpz_mod(tmp, n, base);
700.            // mpz_set(mod_arr[(ui64)count], tmp);
701.             mpz_init_set(zq,sqrt);
702.             for(inv_curr=0; inv_curr<count && mpz_cmp_ui(zero, 0)>0; inv_curr++){
703.                 //mpf_set_z(tmp_f, );
704.                 mpz_gcd(zero,n,zq);
705.                 mpz_sub(zq, zq, tmp);
706.                  // mpf_set_z(tmp_f, n);
707.                    
708.                     if(mpz_cmp_ui(zero, 1)>0){
709.                         mpz_set(zq, zero);
710.                         mpz_set_ui(zero, 0);
711.                         break;
712.                     }
713.                       mpz_ui_pow_ui(base_c, 2, count-inv_curr);
714.                       mpz_mod(tmp,n, base_c);
715.                 }
716.         count++;
717.             }
718.            
719.       if(mpz_cmp_ui(zq, 0)>0)  mpz_div(zp, n, zq);
720.    // q=n/p;
721.     break;
722.     }
723. /**************** Dee..ep (basis A) *************************************************/
724. case 'd':
725.     /********************************************* String (Down Limit) ************************************************/
726.     mpz_init_set(sqrt, n);
727.     mpz_init_set_ui(count_step, 1);
728.     mpz_init_set_ui(sum, 0);
729.     mpz_gcd(zq, save_n, sqrt);
730.     if(mpz_cmp_ui(zq,1)>0 && mpz_cmp(save_n,zq)!=0 ) break;
731. //  mpz_init_set(sum, sqrt);
732.     while(mpz_cmp_ui(sum, 1)>0 || mpz_cmp_ui(sum, 0)==0){
733.         if(mpz_cmp_ui(zq,1)>0 && mpz_cmp(save_n,zq)!=0 ) break;
734.         while(mpz_cmp_ui(sqrt, 1)>0){
735.             mpz_fdiv_q_ui(sqrt, sqrt, 2);
736.             mpz_gcd(zq, save_n, sqrt);
737.             if(mpz_cmp_ui(zq,1)>0 && mpz_cmp(save_n,zq)!=0 ) break;
738.             mpz_add(sum, sum, sqrt);
739.             mpz_gcd(zq, save_n, sum);
740.             if(mpz_cmp_ui(zq,1)>0 && mpz_cmp(save_n,zq)!=0 ) break;
741.             mpz_add_ui(count_step, count_step, 1);
742.         }
743.         //mpz_sub_ui(sum, sum, 2);
744.         mpz_set(sqrt, sum);
745.         if(mpz_cmp_ui(sum, 1)!=0)mpz_set_ui(sum, 0);
746.        
747.     }
748.     mpz_get_str(lptstr, 10, count_step);
749.     printf("Number of Step: %s\n", lptstr);
750. break;
751.     /********************************************* String (Down Limit) ************************************************/
752. case 'e':
753.     t=2;
754.     goto start;
755. case 'n':
756.    mpz_set(n,save_n);
757. mpz_pow_ui(n, n, t);
758. mpz_get_str(str_n, 10, n);
759. printf("n^%i=", t++) ; cout<<str_n<<"\n";
760. goto enter;
761. case 'm':
762.       //mpz_set(n,save_n);
763. mpz_mul_ui(n, n, 2);
764. mpz_get_str(str_n, 10, n);
765. printf("2*n=") ; cout<<str_n<<"\n";
766. goto enter;
767.     //case 'M':
768.       //  {
769. /****************** Select of Way (basis B'k)*********************************************************
770.         base=1;
771. for(count=1; base<n; count++){
772.   base=pow((long double)2.0, count);
773.   cout<<mod(n, &base)<<"\n";
774.      
775.     }
776. ****************** Select of Way (basis B'k)*********************************************************/
777. //break;
778.   //      }
779. //    case 'l':
780. //        {
781. ///****************** Delta - Left eXt (basis A)*********************************************************/
782. //        cout<<"Used method: "<<"Delta - Left (basis A)\n";
783. //        //mpz_set_ui(mod_arr[0],1);
784. //        count=1;
785. ////        div=0;
786. //      mpz_init_set_ui(zero, 1);
787. //        while( mpz_cmp_ui(zero, 0)>0 && mpz_cmp(n, base)>0){
788. //            mpz_ui_pow_ui(base, 2, count+1);
789. //            mpz_mod(tmp, n, base);
790. //           // mpz_set(mod_arr[(ui64)count], tmp);
791. //            mpz_init_set_ui(zq,0);
792. //            for(inv_curr=0; inv_curr<count && mpz_cmp_ui(zero, 0)>0; inv_curr++){
793. //                //mpf_set_z(tmp_f, );
794. //                mpz_add(zq, zq, tmp);
795. //                 // mpf_set_z(tmp_f, n);
796. //                    mpz_gcd(zero,n,zq);
797. //                  if(mpz_cmp_ui(zero, 1)>0){
798. //                      mpz_set(zq, zero);
799. //                      mpz_set_ui(zero, 0);
800. //                      break;
801. //                  }
802. //                    mpz_ui_pow_ui(base_c, 2, count-inv_curr);
803. //                    mpz_set_ui(tmp, 0);
804. //                    mpz_mod(tmp,n, base_c);
805. //                }
806. //        count++;
807. //            }
808. //            
809. //        mpz_div(zp, n, zq);
810. //   // q=n/p;
811. //    break;
812. ///****************** Delta - Left eXt (basis A)*********************************************************/
813. //
814. //        }
815.  
816.     case 'p':
817.         {
818.          /**************** Dee..ep (basis A) *************************************************/
819.         cout<<"Used method: "<<"Dee..ep (basis A)\n";
820.               count=2;
821. //        div=0;
822.         mpz_init_set_ui(zero, 1);
823.         while( mpz_cmp_ui(zero, 0)>0 && mpz_cmp(n, base)>0){
824.             mpz_ui_pow_ui(base, 2, count);
825.             mpz_mod(tmp, n, base);
826.            // mpz_set(mod_arr[(ui64)count], tmp);
827.             mpz_init_set_ui(zq,0);
828.             for(inv_curr=0; inv_curr<count && mpz_cmp_ui(zero, 0)>0; inv_curr++){
829.                 //mpf_set_z(tmp_f, );
830.                 mpz_add(zq, zq, tmp);
831.                  // mpf_set_z(tmp_f, n);
832.                     mpz_gcd(zero,n,zq);
833.                     if(mpz_cmp_ui(zero, 1)>0){
834.                         mpz_set(zq, zero);
835.                         mpz_set_ui(zero, 0);
836.                         break;
837.                     }
838.                       mpz_ui_pow_ui(base_c, 2, count-inv_curr);
839.                       mpz_mod(tmp,n, base_c);
840.                 }
841.         count++;
842.             }
843.            
844.        if(mpz_cmp_ui(zq, 0)>0) mpz_div(zp, n, zq);
845.    // q=n/p;
846.     break;
847.  
848. /**************** Dee..ep (basis A) *************************************************/
849.         }
850.     case 'i':
851.         {
852.      /**************** Back Step (basis A) *************************************************/
853.         cout<<"Used method: "<<"Back Step (basis A)\n";
854. //mpz_set_ui(mod_arr[0],1);
855.         count=2;
856.    mpz_init_set_ui(zero, 1);
857.    mpz_init_set_ui(base, 1);
858.         while( mpz_cmp_ui(zero, 0)>0 && mpz_cmp(n, base)>0){
859.             mpz_ui_pow_ui(base, 2, count);
860.             mpz_mod(zero, n, base);
861.               mpz_set(zq, base);
862.              // mpz_set(tmp, zero);
863.             //  mpz_set(mod_arr[(ui64)count], zero);
864.             for(inv_curr=1; inv_curr<count && mpz_cmp_ui(zero, 0)>0; inv_curr++){
865.                 mpz_ui_pow_ui(base_c, 2, count-inv_curr);
866.                      mpz_mod(tmp,n, base_c);
867.                  mpz_add(zq, zq, tmp);
868.                   mpz_gcd(zero,n,zq);
869.                     if(mpz_cmp_ui(zero, 1)>0){
870.                         mpz_set(zq, zero);
871.                         mpz_set_ui(zero, 0);
872.                         break;
873.                     }  
874.            //     if(mpz_cmp_ui(zq, 1)>0 ){
875.            //         mpz_mod(zero,n, zq);
876.            //         mpz_set(zp, zero);
877.            //         }
878.            //    mpz_set(save_q,zq);
879.            //    for(; mpz_cmp(zero,0)>0;){
880.            //        mpz_mod(zero, zq, zp);
881.            //        mpz_set(repair,zp);
882.            //        mpz_set(zp,zero);
883.            //        mpz_set(zq, repair);
884.            //        }
885.  
886.            //if(mpz_cmp_ui(zp, 1)>0){
887.            //    mpz_mod(zero, n, zp);
888.            //    if(mpz_cmp(zero, 0)>0)break;
889.            //    }
890.            //    //else p=.5;
891.            //    mpz_set(zq,save_q);
892.              
893.              //  if(p==1 || p/2==floor(p/2)) p=.5;
894.                 }
895.         count++;
896.             }
897.    if(mpz_cmp_ui(zq, 0)>0) mpz_div(zp, n, zq);
898.     break;
899. /**************** Back Step (basis A) *************************************************/
900.         }
901.        case 'c':
902.         {
903.  /**************** Down Fix -- (basis A) *************************************************/
904.         cout<<"Used method: "<<"Down Fix -- (basis A)\n";
905. //mpz_set_ui(mod_arr[0],1);
906.         count=2;
907. //        div=0;
908.   mpz_init_set_ui(zero, 1);
909.   mpz_init_set_ui(base, 1);
910.         while( mpz_cmp_ui(zero, 0)>0 && mpz_cmp(n, base)>0){
911.             mpz_ui_pow_ui(base, 2, count);
912.             mpz_mod(zero, n, base);
913.   //           mpz_set(mod_arr[(ui64)count], zero);
914.  
915.            mpz_add(zq,base, zero);
916.     for(inv_curr=1; inv_curr<count && mpz_cmp_ui(zero, 0)>0; inv_curr++){
917.                 /*if(mpz_cmp_ui(zq, 1)>0 ){
918.                     mpz_mod(zero,n, zq);
919.                     mpz_set(zp, zero);
920.                     }*/
921.                  mpz_gcd(zero,n,zq);
922.                     if(mpz_cmp_ui(zero, 1)>0){
923.                         mpz_set(zq, zero);
924.                         mpz_set_ui(zero, 0);
925.                         break;
926.                     }
927.            //    mpz_set(save_q,zq);
928.            //    for(; mpz_cmp(zero,0)>0;){
929.            //        mpz_mod(zero, zq, zp);
930.            //        mpz_set(repair,zp);
931.            //        mpz_set(zp,zero);
932.            //        mpz_set(zq, repair);
933.            //        }
934.  
935.            //if(mpz_cmp_ui(zp, 1)>0){
936.            //    mpz_mod(zero, n, zp);
937.            //    if(mpz_cmp(zero, 0)>0)break;
938.            //    }
939.            //    //else p=.5;
940.            //    mpz_set(zq,save_q);
941.                mpz_ui_pow_ui(base_c, 2, count-inv_curr);
942.                mpz_mod(tmp,n, base_c);
943.                mpz_sub(zq, zq, tmp);
944.                 }
945.         count++;
946.             }
947.    if(mpz_cmp_ui(zq, 0)>0) mpz_div(zp, n, zq);
948.     break;
949. /**************** Down Fix -- (basis A) *************************************************/
950.         }
951.        case 't':
952.            cout<<"Set t="; cin>>t;
953.            mpz_pow_ui(n, save_n, t);
954.            mpz_get_str(lptstr, 10, n);
955.            cout<<"n^"<<t<<"="<<lptstr<<endl;
956.             goto enter;
957.        case 'z':
958.  
959.            mpz_nextprime(prime, prime);
960.            mpz_mul(n, n, prime);
961.            mpz_get_str(lptstr, 10, n);
962.                cout<<"n*z="<<lptstr<<"\n";
963.            goto enter;
964.          }
965. //if(odd==floor(odd))
966.          if(mpz_cmp(zq, zp)>0 && mpz_cmp_ui(zp,1)>0) mpz_set(zq, zp);
967.          while(mpz_cmp(zq, save_n)>0) mpz_div(zq, zq, save_n);
968.          mpz_gcd(zq, zq, save_n);
969.          mpz_div(zp, save_n, zq);
970.          mpz_mul(tmp, zp, zq);
971.     if( mpz_cmp(tmp, save_n)!=0){
972.       cout<<"'n - solid number: you can to transform n (t++, n^t) & to try again or Enter new number\n";
973.         }
974. else if(mpz_cmp_ui(zq, 1)==0 || mpz_cmp_ui(zp, 1)==0) {
975.     cout<<"Sorry, Maybe method make a blunder, apply 'n^t' to n & then try any method\n";
976. //printf("p: %.0f, q: %.0f\n", p, q);
977.     }
978. else{
979.     mpz_get_str(str_p, 10, zp);
980.     mpz_get_str(str_q, 10, zq);
981.     mpz_get_str(str_n, 10, save_n);
982.     cout<<"p="<<str_p<<"\n"<<"q="<<str_q<<"\n";
983.     memset(lptstr, 0, sizeof(lptstr));
984.     strcat(lptstr, "n=");
985.     strcat(lptstr, str_n);
986.     strcat(lptstr, "\x0D");
987.     strcat(lptstr, "p=");
988.     strcat(lptstr, str_p);
989.     strcat(lptstr, "\x0D");
990.     strcat(lptstr, "q=");
991.     strcat(lptstr, str_q);
992.     strcat(lptstr, "\x0D");
993.     WriteFile(file, lptstr, strlen(lptstr), &num_write, 0);
994.     cout<<"Result saved to ans.txt\n";
995.     Beep(7700, 2500);
996. }
997. //count=0;
998. //ceven=0;
999. mpz_set_ui(zp, 0);
1000. mpz_set_ui(zq, 0);
1001. goto enter;
1002. without_sorry:
1003. //printf("p: %.0f, q: %.0f \n", p, q);
1004. goto enter;
1005.     return 0;
1006. }

 

UbIvItS
Хоть бы код привел в порядок.

 

все, что не ясно - задавай вопросы.

 

Ну, что ж стала понятна вторая причина почему Дип показывает результаты (первую объясняет метода "Шов"): (P mod Z)*Q= P*Q mod Z
теперь нужно вырабатывать методу по подбору Z, но заметим в формуле есть явные плюсы Z может принимать не какое - то уникальное значение, а некоторое их множество, например: 101*17 имеет след. подходящие модули: 100, 99, 98, 97, 96, 20, хотя их кол - во все же ничтожно.

 

Весьма к любопытным выводам я пришел (читайте методу MOD CATCHER) http://xproject-all.narod.ru/factorize_numbers_rus_descrip_ver6.pdf

 

404 - файл не найден

 

я снес файл - в выкладках обнаружил ошибку.

 

UbIvItS
Я ввожу в твою прогу число 9998000099 = 99989*99991. И ни один из методов не даёт правильного результата. Значит, методы, которые ты используешь, не очень хороши? Может, хотя бы подскажешь, в каком направлении можно двигаться дальше (всё-таки ты явно хорошо разбираешься в теме)?

 

Не могу сказать, что я так уж сильно рублю в этой теме) - есть люди и покруче - для меня это просто хобби до тех пор, пока не решу этот вопрос или не отброшу копыта (вероятность второго исхода выше))
Сорри, за столь лиричное отступление - теперь про прогу:
если ты юзаешь дип, то возводи в степнь нумбер(жми n)
замечена одна вещь: если N^t бьется, то N^k тоже, если k>t
можно так же умножать N на другие нумберы.
самыми сильными являються дип BS и DF--, но по опыту дип их все делает.
дельта-правый на него даже не смотри - это полный сакс: для меня он имеет только истор. ценность - с него все началось.

P. S.
на второй степени колет паршивец(дип) )

 

главная беда дипа -это повторный счет - он сильно тормозит дело. как с ним эффективно бороться пока не знаю.