模乘的演算法
❶ 兩個向量的模相乘
向量a*向量b=|向量a|×|向量b|×cosa。（a為向量a和向量襪茄b的夾角），腔備所以|a|×|b|=（向量a*向量b）÷cosa=（x1x2+y1y2）÷cosa。若有疑問請追問伍好毀，希望對你有所幫助！
❷ 向量a的模乘以b的模等於什麼
向量的液橘粗模等於各個鬧鎮分量的平方和的二次根，所以，a的模是2，b的模是3，他們的乘積等於6.
如果你是伍簡要算向量的數量積（內積）的話，應該是對應分量乘積再求和，也就是說向量a和b的內積等於2*1+0*（-2）+0*（-2）=2.
❸ 關於模乘的演算法
RSA演算法中用到的大數運算
C. 大數的運算
1. 大數的運算原理
RSA演算法依賴於大數的運算，目前主流RSA演算法都建立在512位到1024位的大數運算之
上，所以我們首先需要掌握大數（比如1024位）的運算原理。
大多數的編譯器只能支持到32位（或64位）的整數運算，即我們在運算中所使用的
整數必須小於等於32位，即0xFFFFFFFF，這遠遠達不到RSA的需要，於是需要專門建
立大數運算庫，來解決這一問題。
最簡單的辦法是將大數當作字元串進行處理，也就是將大數用10進制字元數組進行
表示，然後模擬人們手工進行「豎式計算」的過程編寫其加減乘除函數。但是這樣
做效率很低。當然其優點是演算法符合人們的日常習慣，易於理解。
另一種思路是將大數當作一個二進制流進行處理，使用各種移位和邏輯操作來進行
加減乘除運算，但是這樣做代碼設計非常復雜，可讀性很低，難以理解也難以調試
。
這里我們採用了一種介於兩者之間虛臘的思路：將大數看作一個N進制數組，對於目前的
32位系統而言，N可以取2的32次方，即0x100000000，假如將一個1024位的大數轉化
成0x10000000進制，它就變成了32位，而每一位的取值范圍是0－0xFFFFFFFF。我們
正好可以用一個無符號長整數來表罩侍示這一數值。所以1024位的大數就是一個有32個
元素的unsigned long數組。而且0x100000000進制的數組排列與2進制流對於計算機
來說，實際上是一回事，但是我們完全可以針對unsigned long數組進行「豎式計算
」，而循環規模被降低到物譽吵了32次之內，並且演算法很容易理解。
但考慮到乘法和除法，都要進行擴展才能進行快速的計算（如果把除法變減法而不
擴展，速度將慢的無法忍受）。所以我們將N取2的16次方的，即0xFFFF。每一位用
unsigned short來表示，當進行乘除運算時，將short擴展成long，這是編譯器所支
持的，所以運算起來，比較快。
❹ 如何進行冪模運算
模冪乘運算採用平方乘演算法，將模冪乘運算轉化為模乘和模平方運算實現．
平方-乘演算法：一般地，求S=ABmodN，其中A<N，B<N；將指數B表示為二進制，即
觀察演算法，由於指數B化為二進制後的長度不確定，多數情況下高位會存在很多個0．如果完全按照該演算法實現，指數B從最高位起開始運算，在第一個1出現以前，雖進行了多次運算，但D的值一直為1；當B出現第一個1後才進入有效的模乘運算．在具體實現時，設計專門的電路從高到低掃描指數B的每一位，當在找到第一個1之前，不做任何運算，找到第一個1時，使D=A，以後根據每次掃描的6[i]值，調用模乘實現運算．
經過對多種公鑰加解密演算法的分析——如RSA演算法，通常公鑰的有效位較短，而私鑰有效位較長．加密中的模冪乘運算，指數有效位很少，所以上面的改進可大大減少模乘次數，加快加密過程．以目前常用的私鑰和模數1 024 bit，公鑰128bit情況為例，採用上述改進可減少896次不必要的模乘．解密過程使用中國余數定理(CRT)，可有效降低解密指數的長度，整個演算法的執行效率得到進一步提高．
2．2 模乘及模加的實現方法
模乘採用改進的Blakley加法型演算法，原理與平方-乘演算法類似，核心是將模乘轉化為模加實現．如通常S=(A×B)modN，A<N，B<N可以按如下方式考慮．
將B表示成二進制：
由上式可知，可以像平方一乘演算法一樣，將模乘轉化為模加實現．
一般模加運算表示為S=(A+B)modN，觀察以上模乘及模冪乘演算法原理描述，可知在其調用的模加運算中，因為A<N且B<N，則(A+B)<2N，所以，
因此考慮在運算中同時計算(A+B)和(A+B-N)兩個結果，運算完成後通過判斷加法器與減法器的進位輸出(CO)與借位輸出(BO)．決定哪個為本次模加的正確結果．同上，A，B，N均為l位的二進制數，若CO=1，則說明(A+B)為l+1位二進制數，必大於l位的N；若CO=0，則(A+B)和N同為l位，當BO=1時(A+B)<N，當BO=0時N≤(A+B)．
從而可以在一次運算中完成加法和求模過程，使模加的運算速度提高1倍．
❺ 向量模長的乘積公式
向量的模相乘公式是a·b=|a||b|cosθ。
向量AB的長度叫做枝絕扮向量的模，記作｜AB|或｜a|。向宏則量的模的運算沒有專門的法則，一般都是通過餘弦定理計算兩個向量的和、差的模。
多個向量的合成用正交分解法，如果要求模一般需要先算出合成後的向量。模是絕對值在二維和三維空間的推廣，可以認為就是向量的長度。推廣到高維空間中稱為范數。
公式方法：
兩個向量的數量積（內積、點積）是一個數量（沒有方向），記作a·b。向量的數量猛灶積的坐標表示：a·b=x·x'+y·y'。
兩個向量a和b的向量積（外積、叉積）是一個向量，記作a×b這里「×」並不是乘號，只是一種表示方法，與「·」不同，也可記做「∧」。
若a、b不共線，則a×b的模是：∣a×b∣=|a|·|b|·sin〈a，b〉；a×b的方向是：垂直於a和b，且a、b和a×b按這個次序構成右手系。若a、b垂直，則∣a×b∣=|a|*|b。
❻ 用C或者C++語言實現這些多精度模乘演算法。包括：32bit*32bit，64bit*64bit，128bit*128bit，256bit*256bit
把我的高精度模版 貼一下， 完全可以實現 256bit
。。。。。。。。。。。殲早。。。。氏盯雀。。。。。。。。。。。。。。
#include<iostream>
#include<string>
#include<iomanip>
#include<algorithm>
using namespace std;
class BigNum;
istream& operator>>(istream&, BigNum&);
ostream& operator<<(ostream&, BigNum&);
#define MAXN 9999
#define MAXSIZE 20000 //這是大數的位數，一個數組元素存儲四位，那麼一共就是20000*4 位數。
#define DLEN 4
class BigNum
{
public:
int a[MAXSIZE]; //數組模擬大數，一個數組元素存儲四位數。
int len;
public:
BigNum(){len = 1;memset(a,0,sizeof(a));}
BigNum(const int);
BigNum(const char*);
BigNum(const BigNum &);
BigNum &operator=(const BigNum &);
friend istream& operator>>(istream&, BigNum&);
friend ostream& operator<<(ostream&, BigNum&);
BigNum operator*(const BigNum &) const;
};
//輸入重載
istream& operator>>(istream & in, BigNum & b)
{
char ch[MAXSIZE*4];
int i = -1;
memset(b.a,0,sizeof(b.a));
in>>ch;
int l=strlen(ch);
int count=0,sum=0;
for(i=l-1;i>=0;)
{
sum = 0;
int t=1;
for(int j=0;j<4&&i>=0;j++,i--,t*=10)
{
sum+=(ch[i]-'0')*t;
}
b.a[count]=sum;
count++;
}
b.len =count++;
return in;
}
//輸出重載則粗。
ostream& operator<<(ostream& out, BigNum& b)
{
int i;
cout << b.a[b.len - 1];
for(i = b.len - 2 ; i >= 0 ; i--)
{
cout.width(DLEN);
cout.fill('0');
cout << b.a[i];
}
return out;
}
//下面是構造函數。
BigNum::BigNum(const int b)
{
int c,d = b;
len = 0;
memset(a,0,sizeof(a));
while(d > MAXN)
{
c = d - (d / (MAXN + 1)) * (MAXN + 1);
d = d / (MAXN + 1); a[len++] = c;
}
a[len++] = d;
}
BigNum::BigNum(const char*s)
{
int t,k,index,l;
memset(a,0,sizeof(a));
l=strlen(s);
len=l/DLEN;
if(l%DLEN)len++;
index=0;
for(int i=l-1;i>=0;i-=DLEN)
{
t=0;k=i-DLEN+1;
if(k<0)k=0;
for(int j=k;j<=i;j++)
t=t*10+s[j]-'0';
a[index++]=t;
}
}
BigNum::BigNum(const BigNum & T) : len(T.len)
{
int i;
memset(a,0,sizeof(a));
for(i = 0 ; i < len ; i++) a[i] = T.a[i];
}
////////////////////////////////////////////////
//賦值重載。
BigNum & BigNum::operator=(const BigNum & n)
{
len = n.len;
memset(a,0,sizeof(a));
for(int i = 0 ; i < len ; i++)
a[i] = n.a[i];
return *this;
}
//乘法重載。
BigNum BigNum::operator*(const BigNum & T) const
{
BigNum ret;
int i,j,up;
int temp,temp1;
for(i = 0 ; i < len ; i++)
{
up = 0;
for(j = 0 ; j < T.len ; j++)
{
temp = a[i] * T.a[j] + ret.a[i + j] + up;
if(temp > MAXN)
{
temp1 = temp - temp / (MAXN + 1) * (MAXN + 1);
up = temp / (MAXN + 1);
ret.a[i + j] = temp1;
}
else
{
up = 0;
ret.a[i + j] = temp;
}
}
if(up != 0)
ret.a[i + j] = up;
}
ret.len = i + j;
while(ret.a[ret.len - 1] == 0 && ret.len > 1) ret.len--;
return ret;
}
/*****************************************/
int main()
{
BigNum a,b,c;
cin>>a>>b; //輸入大數。
c=a*b; //計算a*b
cout<<c<<endl; //輸出c
return 0;
}
❼ 向量被拆成幾個向量後模相乘怎麼算
演算法如下：
向量a=(x1,y1),向量b=(x2,y2)；a·b=x1x2+y1y2=|a||b|cosθ(θ是a,b夾角)；
向量之間不叫乘積,而叫數量積。如a·b叫做a與b的數量積或a點乘b；
向量積，數學中又稱外積、叉積，物理中稱矢積、叉乘，是歷備一種在向量空間中向量的二元運算。慧喚
與點積不同，它肢碧毀的運算結果是一個向量而不是一個標量。
❽ RSA里的mod計算問題
RSA軟體演算法以及硬體實現都是利用蒙哥馬利模乘實現你的要求的
由於RSA
的核心演算法是模冪運算，模冪運算又相當於模乘運算的循環，要提高
RSA
演算法的效率，首要問題在於提高模乘運算的效率。不難發現，模乘過程中復雜
度最高的環節是求模運算，因為一次除法實際上包含了多次加法、減法和乘法，如
果在演算法中能夠盡量減少除法甚至避免除法，則演算法的效率會大大提高。
設A=Sum[i=0
to
k](A*2**i)，0<=A<=1，則：
C=
A*B
=
Sum[i=0
to
k](A*B*2**i)
可用循環處理為：
C=0
FOR
i
FROM
k
TO
0
C=C*2
C=C+A*B
RETURN
C
若令
C'=
A*B*2**(-k)，則：
C'=
Sum[i=0
to
k](A*B*2**(i-k))
用循環處理即：
C'=0
FOR
i
FROM
0
TO
k
C'=C'+A*B
C'=C'/2
RETURN
C'
通過這一演算法求A*B*2**(-k)是不精確的，因為在循環中每次除以2都可能有餘
數被舍棄了，但是可以通過這一演算法求A*B*2**(-k)
%N的精確值，方法是在對C'除
2之前，讓C'加上C'[0]*N。由於在RSA中N是兩個素數的積，總是奇數，所以當C'是
奇數時，C'[0]=1，C'+C'[0]*N
就是偶數，而當C'為偶數時C'[0]=0，C'+C'[0]*N
還是偶數，這樣C'/2
就不會有餘數被舍棄。又因為C'+N
%N
=
C'
%N，所以在計算
過程中加若干次N，並不會影響結果的正確性。可以將演算法整理如下：
C'=0
FOR
i
FROM
0
TO
k
C'=C'+A*B
C'=C'+C'[0]*N
C'=C'/2
IF
C'>=N
C'=C'-N
RETURN
C'
由於在RSA中A、B總是小於N，又0<=A,C'[0]<=1，所以：
C'
=
(C'+A*B+C'[0]*N)/2
C'
<
(C'+2N)/2
2C'
<
C'+2N
C'
<
2N
既然C'總是小於2N，所以求C'
%N
就可以很簡單地在結束循環後用一次減法來
完成，即在求A*B*2**(-k)
%N的過程中不用反復求模，達到了我們避免做除法的目
的。當然，這一演算法求得的是A*B*2**(-k)
%N，而不是我們最初需要的A*B
%N。但
是利用A*B*2**(-k)我們同樣可以求得A**E
%N。
設R=2**k
%N，R'=2**(-k)
%N，E=Sum[i=0
to
n](E*2**i)：
A'=A*R
%N
X=A'
FOR
i
FROM
n
TO
0
X=X*X*R'
%N
IF
E=1
X=X*A'*R'
%N
X=X*1*R'
%N
RETURN
X
最初：
X
=
A*R
%N，
開始循環時：
X
=
X*X*R'
%N
=
A*R*A*R*R'
%N
=
A**2*R
%N
反復循環之後：
X
=
A**E*R
%N
最後：
X
=
X*1*R'
%N
=
A**E*R*R'
%N
=
A**E
%N
如此，我們最終實現了不含除法的模冪演算法，這就是著名的蒙哥馬利演算法，而
X*Y*R'
%N
則被稱為「蒙哥馬利模乘」。以上討論的是蒙哥馬利模乘最簡單，最容
易理解的二進制形式。蒙哥馬利演算法的核心思想在於將求A*B
%N轉化為不需要反復
取模的A*B*R'
%N，但是利用二進制演算法求1024位的A*B*R'
%N，需要循環1024次之
多，我么必然希望找到更有效的計算A*B*R'
%N的演算法。
考慮將A表示為任意的r進制：
A
=
Sum[i=0
to
k](A*r**i)
0<=A<=r
我們需要得到的蒙哥馬利乘積為：
C'=
A*B*R'
%N
R'=r**(-k)
則以下演算法只能得到C'的近似值
C'=0
FOR
i
FROM
0
TO
k
C'=C'+A*B
C'=C'/r
IF
C'>=N
C'=C'-N
RETURN
C'
因為在循環中每次C'=C'/r
時，都可能有餘數被舍棄。假如我們能夠找到一個
系數
q，使得(C'
+
A*B
+
q*N)
%r
=0，並將演算法修改為：
C'=0
FOR
i
FROM
0
TO
k
C'=C'+A*B+q*N
C'=C'/r
IF
C'>=N
C'=C'-N
RETURN
C'
則C'的最終返回值就是A*B*R'
%N的精確值，所以關鍵在於求q。由於：
(C'
+
A*B
+
q*N)
%r
=0
==>
(C'
%r
+
A*B
%r
+
q*N
%r)
%r
=0
==>
(C'[0]
+
A*B[0]
+
q*N[0])
%r
=0
若令N[0]*N[0]'
%r
=1，q=(C'[0]+A*B[0])*(r-N[0]')
%r，則：
(C'[0]
+
A*B[0]
+
q*N[0])
%r
=
(C'[0]+A*B[0]
-
(C'[0]+A*B[0])*N[0]'*N[0])
%r)
%r
=
0
於是我們可以得出r為任何值的蒙哥馬利演算法：
m=r-N[0]'
C'=0
FOR
i
FROM
0
TO
k
q=(C'[0]+A*B[0])*m
%r
C'=(C'+A*B+q*N)/r
IF
C'>=N
C'=C'-N
RETURN
C'
如果令
r=0x100000000，則
%r
和
/r
運算都會變得非常容易，在1024位的運
算中，循環次數k
不大於32，整個運算過程中最大的中間變數C'=(C'+A*B+q*N)
<
2*r*N
<
1057位，演算法效率就相當高了。唯一的額外負擔是需要計算
N[0]'，使
N[0]*N[0]'
%r
=1，而這一問題前面已經用歐幾里德演算法解決過了，而且在模冪運
算轉化成反復模乘運算時，N是固定值，所以N[0]'只需要計算一次，負擔並不大。
❾ 密碼學中模加 模乘是如何運算的
都高清是求余.
模核乎加是加後求余，改念悉模乘是乘後求余。
3*8 mod 5=24mod 5=4，3+8 mod 5=11mod 5=1
❿ 兩個模相乘怎麼算
先算 |3a+4b|^2=9a^2+24ab+16b^2 從而算出|3a+4b| 的賀改游值,同理再算出|2a+b|的值禪銷,再兩殲清者相乘即可