M521=6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151（共157位）是第13个梅森素数。M607=531137992816767098689588206552468627329593117727031923199444138200403559860852242739162502265229285668889329486246501015346579337652707239409519978766587351943831270835393219031728127（共有183位）是第14个梅森素数

快速乘法除法程序不仅可以用于快速分解大整数，还可以用于判断梅森素数，分解梅森合数，梅森素数的判断用到卢卡斯-莱模法，上面的判断就是用此法，由于我的程序速度慢效率低，就这么小的数程序运行时间长，无法忍受，再大的程序就算不出来死机了一样。这样的程序很有价值我感觉，希望老师指点！

朋友的注释共有17张图片，我注释了4张，发了末尾3张，还有10张没有弄懂看不清楚没有发，不懂原理，通过末尾3张注释看大致是：把乘数被乘数由多项式系数表示法变为点值表示，通过快速fft，再相乘，结果变为系数表示法，用快速逆fft变换。不懂vc语句，有懂的感兴趣的老师朋友，请给与指导，谢谢！

2^101-1=2535301200456458802993406410751=7432339208719*341117531003194129,
这么大的梅森数，如下网站可以分解：WolframAlpha
最大能分解多少不知道，我也没有登录，只是在网上见到了图片，图片中的例子就是前面的这个数。我的程序还没有达到这样的速度和效率，正在研究完善这样的理论和方法。
关于RSA密码的破解，据网上说已经能分解700多位的整数，所以1024或2048位的密码才是安全的。
我的分解整数的原理是特殊数域法，1024或2048位的整数理论上是应该能分解的，但由于程序速度慢效率低，根本达不到要求，只能分解几十位的且时间长，慢到无法忍受。
前面这个网站的程序就可以分解大整数，不知道能分解到多少位的？
欢迎感兴趣的沟通，欢迎指导！欢迎发表快速乘法除法程序，最好是VB版的。
咱不是黑客，不当黑客，只是为了研究整数的规律。黑客用的编程工具据说大多是汇编语言和c语言，没有用vb语言。即使能分解这么大的整数也不可能破解密码，没有黑客程序去哪里得到密码？仅是说明一下可能性，量子计算机的研制速度在提高，RSA密码体制必然面临淘汰，需要改进或重新建立新的密码体制。（秀尔算法据说可以破解RSA密码，咱不懂原理，据说其中的一个步骤必须用量子计算机，还要结合传统计算机才能破解密码）

下面是计算和判断梅森数的程序，仅发主程序供大家参考，希望得到快速乘法除法程序以提高这个程序的速度：（判断法采用卢卡斯-莱莫测试法）
 Private Sub Command1_Click()
Dim a
a = Val(Text1)
B = 1
Do While C <= a - 1
B = MbC(Trim(B), 2)
C = C + 1
Loop
Text2 = MPC(Trim(B), 1)
End Sub

Private Sub Command2_Click()
Text1 = ""
Text2 = ""
Text3 = ""

End Sub
 

Private Sub Command3_Click()
Dim a
B = Trim(Text1)
B1 = 1
Do While C <= B - 1
B1 = MbC(Trim(B1), 2)
C = C + 1
Loop
a = MPC(Trim(B1), 1)

If Len(a) <= 11 Then
Text3 = fenjieyinzi(Trim(a))
Else
Text3 = fenjieyinzi1(Trim(a), Val(B))
End If
End Sub

Private Function fenjieyinzi1(sa As String, sb As String) As String
Dim X, B
X = Trim(sa)

 B = Val(sb)
 s = 4
 B1 = 0
Do While B1 <= B
If InStr(MCC1(Trim(s), Trim(X)), "/") = 0 Then
a = True
Else
a = a
End If
B1 = B1 + 1
s1 = zhengchuqyushu(MCC1(Trim(s), Trim(X)))
s2 = s2 & s1 & "(" & B1 & ")" & vbCrLf
s = MPC(MbC(Trim(s1), Trim(s1)), 2)
Loop
If a = True Then
fenjieyinzi1 = "这是素数" & s2
Else
fenjieyinzi1 = "2*2" & s2
End If

End Function

199楼的vc程序谁能直接翻译成vb程序？有朋友说不必先弄懂原理，可以直接翻译成basic程序的，只要运行没有错误就行。

如下为网上搜索到的快速乘法的c语言程序，请老师看看能不能运行？能不能翻译成vb程序？
迭代型：(共119行，乱了，再整理一下）
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <math.h>
#include <conio.h>
#define N 150010const double pi = 3.141592653;
char s1[N>>1], s2[N>>1];
double rea[N], ina[N], reb[N], inb[N];
int ans[N>>1];
 void Swap(double *x, double *y)
{
    double t = *x;
    *x = *y;
    *y = t;
}
 int Rev(int x, int len)
{
    int ans = 0;
    int i;
   for(i = 0;
 i < len; i++)
{
       ans <<= 1;
        ans |= (x & 1);
        x >>= 1;
    }
    return ans;
}
 void FFT(double *reA, double *inA, int n, bool flag)
{
   int s;
    double lgn = log((double)n) / log((double)2);
    int i;
    for(i = 0; i < n; i++)
{  
      int j = Rev(i, lgn);
        if(j > i)
{
            Swap(&reA[i], &reA[j]);
            Swap(&inA[i], &inA[j]);
        }
    }
   for(s = 1; s <= lgn; s++)
{   
     int m = (1<<s);
        double reWm = cos(2*pi/m), inWm = sin(2*pi/m);
        if(flag) inWm = -inWm;
        int k;
        for(k = 0; k < n; k += m)
{  
          double reW = 1.0, inW = 0.0;
            int j;
           for(j = 0; j < m / 2; j++)
{  
              int tag = k+j+m/2;
                double reT = reW * reA[tag] - inW * inA[tag];
                double inT = reW * inA[tag] + inW * reA[tag];
               double reU = reA[k+j], inU = inA[k+j];
                reA[k+j] = reU + reT;
                inA[k+j] = inU + inT;
                reA[tag] = reU - reT;
               inA[tag] = inU - inT;
               double rew_t = reW * reWm - inW * inWm;
                 double inw_t = reW * inWm + inW * reWm;
                reW = rew_t;
               inW = inw_t;
           }
        }
    }
    if(flag)
{
        for(i = 0;
 i < n; i++)
{
            reA[i] /= n;
            inA[i] /= n;
        }
   }
}
 int main()
{
#if 0
   freopen("in.txt","r",stdin);
#endif
   while(~scanf("%s%s", s1, s2))
{
       memset(ans, 0 , sizeof(ans));
        memset(rea, 0 , sizeof(rea));
        memset(ina, 0 , sizeof(ina));
        memset(reb, 0 , sizeof(reb));
        memset(inb, 0 , sizeof(inb));
        int i, lent, len = 1, len1, len2;
        len1 = strlen(s1);
        len2 = strlen(s2);
        lent = (len1 > len2 ? len1 : len2);
        while(len < lent) len <<= 1;
        len <<= 1;
        for(i = 0;
 i < len; i++)
{
           if(i < len1) rea[i] = (double)s1[len1-i-1] - '0';
            if(i < len2) reb[i] = (double)s2[len2-i-1] - '0';
            ina[i] = inb[i] = 0.0;
        }
        FFT(rea, ina, len, 0);
        FFT(reb, inb, len, 0);
        for(i = 0; i < len; i++)
{
           double rec = rea[i] * reb[i] - ina[i] * inb[i];
            double inc = rea[i] * inb[i] + ina[i] * reb[i];
            rea[i] = rec; ina[i] = inc;
        }
        FFT(rea, ina, len, 1);
        for(i = 0; i < len; i++)
           ans[i] = (int)(rea[i] + 0.4);
        for(i = 0; i < len; i++)
{
           ans[i+1] += ans[i] / 10;
            ans[i] %= 10;
        }
        int len_ans = len1 + len2 + 2;
        while(ans[len_ans] == 0 && len_ans > 0)
 len_ans--;
        for(i = len_ans; i >= 0; i--)
            printf("%d", ans[i]);
       printf("\n");
    }
    return 0;
}
————————————————
迭代型比递归型稍快一点。
发帖时间 昨天 09:18
        

没人研究这个了？结贴，给你加分！

朋友说前面的c语言程序缺少图中下面画红线的库，谁知道？怎么补？哪里找？

我自己编程的利用快速傅里叶变换的大整数的乘法程序结果（似乎也不快，没有优化，结果还不可靠，有时候中间不确定位置会出现错误数字）：
111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111*111111111=12345678999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999987654321有221位,用时1.347656秒.（这个结果应该是对的）

再继续研究一下吧！

这个是用我的模仿手工乘法的程序计算结果：（比快速傅里叶变换的还快？）
111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111*111111111=12345678999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999987654321有221位,用时0.0078125秒.