[分享]求矩阵特征值和特征向量的一个小程序

风花雪月

代码较长，如果不能执行，就是要建立结构体，大家试试吧，希望能用。

//////////////////////////////////////////////////////////////////////
// 实对称三对角阵的全部特征值与特征向量的计算
//
// 参数：
// 1. double dblB[] - 一维数组，长度为矩阵的阶数，传入对称三对角阵的主对角线元素；
// 返回时存放全部特征值。
// 2. double dblC[] - 一维数组，长度为矩阵的阶数，前n-1个元素传入对称三对角阵的次对角线元素
// 3. CMatrix& mtxQ - 如果传入单位矩阵，则返回实对称三对角阵的特征值向量矩阵；
// 如果传入MakeSymTri函数求得的矩阵A的豪斯荷尔德变换的乘积矩阵Q，则返回矩阵A的
// 特征值向量矩阵。其中第i列为与数组dblB中第j个特征值对应的特征向量。
// 4. int nMaxIt - 迭代次数，默认值为60
// 5. double eps - 计算精度，默认值为0.000001
//
// 返回值：BOOL型，求解是否成功
//////////////////////////////////////////////////////////////////////

1. BOOL CMatrix::SymTriEigenv(double dblB[], double dblC[], CMatrix& mtxQ, int nMaxIt /*= 60*/, double eps /*= 0.000001*/)
   
2. {
   
3. int i,j,k,m,it,u,v;
   
4. double d,f,h,g,p,r,e,s;
   
5. 
   
6. // 初值
   
7. int n = mtxQ.GetNumColumns();
   
8. dblC[n-1]=0.0;
   
9. d=0.0;
   
10. f=0.0;
    
11. 
    
12. // 迭代计算
    
13. 
    
14. for (j=0; j<=n-1; j++)
    
15. {
    
16. it=0;
    
17. h=eps*(fabs(dblB[j])+fabs(dblC[j]));
    
18. if (h>d)
    
19. d=h;
    
20. 
    
21. m=j;
    
22. while ((m<=n-1)&&(fabs(dblC[m])>d))
    
23. m=m+1;
    
24. 
    
25. if (m!=j)
    
26. {
    
27. do
    
28. {
    
29. if (it==nMaxIt)
    
30. return FALSE;
    
31. 
    
32. it=it+1;
    
33. g=dblB[j];
    
34. p=(dblB[j+1]-g)/(2.0*dblC[j]);
    
35. r=sqrt(p*p+1.0);
    
36. if (p>=0.0)
    
37. dblB[j]=dblC[j]/(p+r);
    
38. else
    
39. dblB[j]=dblC[j]/(p-r);
    
40. 
    
41. h=g-dblB[j];
    
42. for (i=j+1; i<=n-1; i++)
    
43. dblB=dblB-h;
    
44. 
    
45. f=f+h;
    
46. p=dblB[m];
    
47. e=1.0;
    
48. s=0.0;
    
49. for (i=m-1; i>=j; i--)
    
50. {
    
51. g=e*dblC;
    
52. h=e*p;
    
53. if (fabs(p)>=fabs(dblC))
    
54. {
    
55. e=dblC/p;
    
56. r=sqrt(e*e+1.0);
    
57. dblC[i+1]=s*p*r;
    
58. s=e/r;
    
59. e=1.0/r;
    
60. }
    
61. else
    
62. {
    
63. e=p/dblC;
    
64. r=sqrt(e*e+1.0);
    
65. dblC[i+1]=s*dblC*r;
    
66. s=1.0/r;
    
67. e=e/r;
    
68. }
    
69. 
    
70. p=e*dblB-s*g;
    
71. dblB[i+1]=h+s*(e*g+s*dblB);
    
72. for (k=0; k<=n-1; k++)
    
73. {
    
74. u=k*n+i+1;
    
75. v=u-1;
    
76. h=mtxQ.m_pData;
    
77. mtxQ.m_pData=s*mtxQ.m_pData[v]+e*h;
    
78. mtxQ.m_pData[v]=e*mtxQ.m_pData[v]-s*h;
    
79. }
    
80. }
    
81. 
    
82. dblC[j]=s*p;
    
83. dblB[j]=e*p;
    
84. 
    
85. } while (fabs(dblC[j])>d);
    
86. }
    
87. 
    
88. dblB[j]=dblB[j]+f;
    
89. }
    
90. 
    
91. for (i=0; i<=n-1; i++)
    
92. {
    
93. k=i;
    
94. p=dblB;
    
95. if (i+1<=n-1)
    
96. {
    
97. j=i+1;
    
98. while ((j<=n-1)&&(dblB[j]<=p))
    
99. {
    
100. k=j;
     
101. p=dblB[j];
     
102. j=j+1;
     
103. }
     
104. }
     
105. 
     
106. if (k!=i)
     
107. {
     
108. dblB[k]=dblB;
     
109. dblB=p;
     
110. for (j=0; j<=n-1; j++)
     
111. {
     
112. u=j*n+i;
     
113. v=j*n+k;
     
114. p=mtxQ.m_pData;
     
115. mtxQ.m_pData=mtxQ.m_pData[v];
     
116. mtxQ.m_pData[v]=p;
     
117. }
     
118. }
     
119. }
     
120. 
     
121. return TRUE;
     
122. }
     
123. 
     
124. //////////////////////////////////////////////////////////////////////
     
125. // 约化一般实矩阵为赫申伯格矩阵的初等相似变换法
     
126. //
     
127. // 参数：无
     
128. //
     
129. // 返回值：无
     
130. //////////////////////////////////////////////////////////////////////
     
131. void CMatrix::MakeHberg()
     
132. {
     
133. int i,j,k,u,v;
     
134. double d,t;
     
135. 
     
136. for (k=1; k<=m_nNumColumns-2; k++)
     
137. {
     
138. d=0.0;
     
139. for (j=k; j<=m_nNumColumns-1; j++)
     
140. {
     
141. u=j*m_nNumColumns+k-1;
     
142. t=m_pData;
     
143. if (fabs(t)>fabs(d))
     
144. {
     
145. d=t;
     
146. i=j;
     
147. }
     
148. }
     
149. 
     
150. if (d != 0.0)
     
151. {
     
152. if (i!=k)
     
153. {
     
154. for (j=k-1; j<=m_nNumColumns-1; j++)
     
155. {
     
156. u=i*m_nNumColumns+j;
     
157. v=k*m_nNumColumns+j;
     
158. t=m_pData;
     
159. m_pData=m_pData[v];
     
160. m_pData[v]=t;
     
161. }
     
162. 
     
163. for (j=0; j<=m_nNumColumns-1; j++)
     
164. {
     
165. u=j*m_nNumColumns+i;
     
166. v=j*m_nNumColumns+k;
     
167. t=m_pData;
     
168. m_pData=m_pData[v];
     
169. m_pData[v]=t;
     
170. }
     
171. }
     
172. 
     
173. for (i=k+1; i<=m_nNumColumns-1; i++)
     
174. {
     
175. u=i*m_nNumColumns+k-1;
     
176. t=m_pData/d;
     
177. m_pData=0.0;
     
178. for (j=k; j<=m_nNumColumns-1; j++)
     
179. {
     
180. v=i*m_nNumColumns+j;
     
181. m_pData[v]=m_pData[v]-t*m_pData[k*m_nNumColumns+j];
     
182. }
     
183. 
     
184. for (j=0; j<=m_nNumColumns-1; j++)
     
185. {
     
186. v=j*m_nNumColumns+k;
     
187. m_pData[v]=m_pData[v]+t*m_pData[j*m_nNumColumns+i];
     
188. }
     
189. }
     
190. }
     
191. }
     
192. }

复制代码

[ 本帖最后由 风花雪月 于 2006-8-24 03:31 编辑 ]

风花雪月

1. //////////////////////////////////////////////////////////////////////
   
2. // 求赫申伯格矩阵全部特征值的QR方法
   
3. //
   
4. // 参数：
   
5. // 1. double dblU[] - 一维数组，长度为矩阵的阶数，返回时存放特征值的实部
   
6. // 2. double dblV[] - 一维数组，长度为矩阵的阶数，返回时存放特征值的虚部
   
7. // 3. int nMaxIt - 迭代次数，默认值为60
   
8. // 4. double eps - 计算精度，默认值为0.000001
   
9. //
   
10. // 返回值：BOOL型，求解是否成功
    
11. //////////////////////////////////////////////////////////////////////
    
12. BOOL CMatrix::HBergEigenv(double dblU[], double dblV[], int nMaxIt /*= 60*/, double eps /*= 0.000001*/)
    
13. {
    
14. int m,it,i,j,k,l,ii,jj,kk,ll;
    
15. double b,c,w,g,xy,p,q,r,x,s,e,f,z,y;
    
16. 
    
17. int n = m_nNumColumns;
    
18. 
    
19. it=0;
    
20. m=n;
    
21. while (m!=0)
    
22. {
    
23. l=m-1;
    
24. while ((l>0)&&(fabs(m_pData[l*n+l-1]) >
    
25. eps*(fabs(m_pData[(l-1)*n+l-1])+fabs(m_pData[l*n+l]))))
    
26. l=l-1;
    
27. 
    
28. ii=(m-1)*n+m-1;
    
29. jj=(m-1)*n+m-2;
    
30. kk=(m-2)*n+m-1;
    
31. ll=(m-2)*n+m-2;
    
32. if (l==m-1)
    
33. {
    
34. dblU[m-1]=m_pData[(m-1)*n+m-1];
    
35. dblV[m-1]=0.0;
    
36. m=m-1;
    
37. it=0;
    
38. }
    
39. else if (l==m-2)
    
40. {
    
41. b=-(m_pData[ii]+m_pData[ll]);
    
42. c=m_pData[ii]*m_pData[ll]-m_pData[jj]*m_pData[kk];
    
43. w=b*b-4.0*c;
    
44. y=sqrt(fabs(w));
    
45. if (w>0.0)
    
46. {
    
47. xy=1.0;
    
48. if (b<0.0)
    
49. xy=-1.0;
    
50. dblU[m-1]=(-b-xy*y)/2.0;
    
51. dblU[m-2]=c/dblU[m-1];
    
52. dblV[m-1]=0.0; dblV[m-2]=0.0;
    
53. }
    
54. else
    
55. {
    
56. dblU[m-1]=-b/2.0;
    
57. dblU[m-2]=dblU[m-1];
    
58. dblV[m-1]=y/2.0;
    
59. dblV[m-2]=-dblV[m-1];
    
60. }
    
61. 
    
62. m=m-2;
    
63. it=0;
    
64. }
    
65. else
    
66. {
    
67. if (it>=nMaxIt)
    
68. return FALSE;
    
69. 
    
70. it=it+1;
    
71. for (j=l+2; j<=m-1; j++)
    
72. m_pData[j*n+j-2]=0.0;
    
73. for (j=l+3; j<=m-1; j++)
    
74. m_pData[j*n+j-3]=0.0;
    
75. for (k=l; k<=m-2; k++)
    
76. {
    
77. if (k!=l)
    
78. {
    
79. p=m_pData[k*n+k-1];
    
80. q=m_pData[(k+1)*n+k-1];
    
81. r=0.0;
    
82. if (k!=m-2)
    
83. r=m_pData[(k+2)*n+k-1];
    
84. }
    
85. else
    
86. {
    
87. x=m_pData[ii]+m_pData[ll];
    
88. y=m_pData[ll]*m_pData[ii]-m_pData[kk]*m_pData[jj];
    
89. ii=l*n+l;
    
90. jj=l*n+l+1;
    
91. kk=(l+1)*n+l;
    
92. ll=(l+1)*n+l+1;
    
93. p=m_pData[ii]*(m_pData[ii]-x)+m_pData[jj]*m_pData[kk]+y;
    
94. q=m_pData[kk]*(m_pData[ii]+m_pData[ll]-x);
    
95. r=m_pData[kk]*m_pData[(l+2)*n+l+1];
    
96. }
    
97. 
    
98. if ((fabs(p)+fabs(q)+fabs(r))!=0.0)
    
99. {
    
100. xy=1.0;
     
101. if (p<0.0)
     
102. xy=-1.0;
     
103. s=xy*sqrt(p*p+q*q+r*r);
     
104. if (k!=l)
     
105. m_pData[k*n+k-1]=-s;
     
106. e=-q/s;
     
107. f=-r/s;
     
108. x=-p/s;
     
109. y=-x-f*r/(p+s);
     
110. g=e*r/(p+s);
     
111. z=-x-e*q/(p+s);
     
112. for (j=k; j<=m-1; j++)
     
113. {
     
114. ii=k*n+j;
     
115. jj=(k+1)*n+j;
     
116. p=x*m_pData[ii]+e*m_pData[jj];
     
117. q=e*m_pData[ii]+y*m_pData[jj];
     
118. r=f*m_pData[ii]+g*m_pData[jj];
     
119. if (k!=m-2)
     
120. {
     
121. kk=(k+2)*n+j;
     
122. p=p+f*m_pData[kk];
     
123. q=q+g*m_pData[kk];
     
124. r=r+z*m_pData[kk];
     
125. m_pData[kk]=r;
     
126. }
     
127. 
     
128. m_pData[jj]=q; m_pData[ii]=p;
     
129. }
     
130. 
     
131. j=k+3;
     
132. if (j>=m-1)
     
133. j=m-1;
     
134. 
     
135. for (i=l; i<=j; i++)
     
136. {
     
137. ii=i*n+k;
     
138. jj=i*n+k+1;
     
139. p=x*m_pData[ii]+e*m_pData[jj];
     
140. q=e*m_pData[ii]+y*m_pData[jj];
     
141. r=f*m_pData[ii]+g*m_pData[jj];
     
142. if (k!=m-2)
     
143. {
     
144. kk=i*n+k+2;
     
145. p=p+f*m_pData[kk];
     
146. q=q+g*m_pData[kk];
     
147. r=r+z*m_pData[kk];
     
148. m_pData[kk]=r;
     
149. }
     
150. 
     
151. m_pData[jj]=q;
     
152. m_pData[ii]=p;
     
153. }
     
154. }
     
155. }
     
156. }
     
157. }
     
158. 
     
159. return TRUE;
     
160. }
     
161. 
     
162. //////////////////////////////////////////////////////////////////////
     
163. // 求实对称矩阵特征值与特征向量的雅可比法
     
164. //
     
165. // 参数：
     
166. // 1. double dblEigenValue[] - 一维数组，长度为矩阵的阶数，返回时存放特征值
     
167. // 2. CMatrix& mtxEigenVector - 返回时存放特征向量矩阵，其中第i列为与
     
168. // 数组dblEigenValue中第j个特征值对应的特征向量
     
169. // 3. int nMaxIt - 迭代次数，默认值为60
     
170. // 4. double eps - 计算精度，默认值为0.000001
     
171. //
     
172. // 返回值：BOOL型，求解是否成功
     
173. //////////////////////////////////////////////////////////////////////
     
174. BOOL CMatrix::JacobiEigenv(double dblEigenValue[], CMatrix& mtxEigenVector, int nMaxIt /*= 60*/, double eps /*= 0.000001*/)
     
175. {
     
176. int i,j,p,q,u,w,t,s,l;
     
177. double fm,cn,sn,omega,x,y,d;
     
178. 
     
179. if (! mtxEigenVector.Init(m_nNumColumns, m_nNumColumns))
     
180. return FALSE;
     
181. 
     
182. l=1;
     
183. for (i=0; i<=m_nNumColumns-1; i++)
     
184. {
     
185. mtxEigenVector.m_pData[i*m_nNumColumns+i]=1.0;
     
186. for (j=0; j<=m_nNumColumns-1; j++)
     
187. if (i!=j)
     
188. mtxEigenVector.m_pData[i*m_nNumColumns+j]=0.0;
     
189. }
     
190. 
     
191. while (TRUE)
     
192. {
     
193. fm=0.0;
     
194. for (i=1; i<=m_nNumColumns-1; i++)
     
195. {
     
196. for (j=0; j<=i-1; j++)
     
197. {
     
198. d=fabs(m_pData[i*m_nNumColumns+j]);
     
199. if ((i!=j)&&(d>fm))
     
200. {
     
201. fm=d;
     
202. p=i;
     
203. q=j;
     
204. }
     
205. }
     
206. }
     
207. 
     
208. if (fm<eps)
     
209. {
     
210. for (i=0; i<m_nNumColumns; ++i)
     
211. dblEigenValue = GetElement(i,i);
     
212. return TRUE;
     
213. }
     
214. 
     
215. if (l>nMaxIt)
     
216. return FALSE;
     
217. 
     
218. l=l+1;
     
219. u=p*m_nNumColumns+q;
     
220. w=p*m_nNumColumns+p;
     
221. t=q*m_nNumColumns+p;
     
222. s=q*m_nNumColumns+q;
     
223. x=-m_pData;
     
224. y=(m_pData[s]-m_pData[w])/2.0;
     
225. omega=x/sqrt(x*x+y*y);
     
226. 
     
227. if (y<0.0)
     
228. omega=-omega;
     
229. 
     
230. sn=1.0+sqrt(1.0-omega*omega);
     
231. sn=omega/sqrt(2.0*sn);
     
232. cn=sqrt(1.0-sn*sn);
     
233. fm=m_pData[w];
     
234. m_pData[w]=fm*cn*cn+m_pData[s]*sn*sn+m_pData*omega;
     
235. m_pData[s]=fm*sn*sn+m_pData[s]*cn*cn-m_pData*omega;
     
236. m_pData=0.0;
     
237. m_pData[t]=0.0;
     
238. for (j=0; j<=m_nNumColumns-1; j++)
     
239. {
     
240. if ((j!=p)&&(j!=q))
     
241. {
     
242. u=p*m_nNumColumns+j; w=q*m_nNumColumns+j;
     
243. fm=m_pData;
     
244. m_pData=fm*cn+m_pData[w]*sn;
     
245. m_pData[w]=-fm*sn+m_pData[w]*cn;
     
246. }
     
247. }
     
248. 
     
249. for (i=0; i<=m_nNumColumns-1; i++)
     
250. {
     
251. if ((i!=p)&&(i!=q))
     
252. {
     
253. u=i*m_nNumColumns+p;
     
254. w=i*m_nNumColumns+q;
     
255. fm=m_pData;
     
256. m_pData=fm*cn+m_pData[w]*sn;
     
257. m_pData[w]=-fm*sn+m_pData[w]*cn;
     
258. }
     
259. }
     
260. 
     
261. for (i=0; i<=m_nNumColumns-1; i++)
     
262. {
     
263. u=i*m_nNumColumns+p;
     
264. w=i*m_nNumColumns+q;
     
265. fm=mtxEigenVector.m_pData;
     
266. mtxEigenVector.m_pData=fm*cn+mtxEigenVector.m_pData[w]*sn;
     
267. mtxEigenVector.m_pData[w]=-fm*sn+mtxEigenVector.m_pData[w]*cn;
     
268. }
     
269. }
     
270. 
     
271. for (i=0; i<m_nNumColumns; ++i)
     
272. dblEigenValue = GetElement(i,i);
     
273. 
     
274. return TRUE;
     
275. }

复制代码

[ 本帖最后由 风花雪月 于 2006-11-14 19:23 编辑 ]

风花雪月

1. //////////////////////////////////////////////////////////////////////
   
2. // 求实对称矩阵特征值与特征向量的雅可比过关法
   
3. //
   
4. // 参数：
   
5. // 1. double dblEigenValue[] - 一维数组，长度为矩阵的阶数，返回时存放特征值
   
6. // 2. CMatrix& mtxEigenVector - 返回时存放特征向量矩阵，其中第i列为与
   
7. // 数组dblEigenValue中第j个特征值对应的特征向量
   
8. // 3. double eps - 计算精度，默认值为0.000001
   
9. //
   
10. // 返回值：BOOL型，求解是否成功
    
11. //////////////////////////////////////////////////////////////////////
    
12. BOOL CMatrix::JacobiEigenv2(double dblEigenValue[], CMatrix& mtxEigenVector, double eps /*= 0.000001*/)
    
13. {
    
14. int i,j,p,q,u,w,t,s;
    
15. double ff,fm,cn,sn,omega,x,y,d;
    
16. 
    
17. if (! mtxEigenVector.Init(m_nNumColumns, m_nNumColumns))
    
18. return FALSE;
    
19. 
    
20. for (i=0; i<=m_nNumColumns-1; i++)
    
21. {
    
22. mtxEigenVector.m_pData[i*m_nNumColumns+i]=1.0;
    
23. for (j=0; j<=m_nNumColumns-1; j++)
    
24. if (i!=j)
    
25. mtxEigenVector.m_pData[i*m_nNumColumns+j]=0.0;
    
26. }
    
27. 
    
28. ff=0.0;
    
29. for (i=1; i<=m_nNumColumns-1; i++)
    
30. {
    
31. for (j=0; j<=i-1; j++)
    
32. {
    
33. d=m_pData[i*m_nNumColumns+j];
    
34. ff=ff+d*d;
    
35. }
    
36. }
    
37. 
    
38. ff=sqrt(2.0*ff);
    
39. 
    
40. Loop_0:
    
41. 
    
42. ff=ff/(1.0*m_nNumColumns);
    
43. 
    
44. Loop_1:
    
45. 
    
46. for (i=1; i<=m_nNumColumns-1; i++)
    
47. {
    
48. for (j=0; j<=i-1; j++)
    
49. {
    
50. d=fabs(m_pData[i*m_nNumColumns+j]);
    
51. if (d>ff)
    
52. {
    
53. p=i;
    
54. q=j;
    
55. goto Loop_2;
    
56. }
    
57. }
    
58. }
    
59. 
    
60. if (ff<eps)
    
61. {
    
62. for (i=0; i<m_nNumColumns; ++i)
    
63. dblEigenValue = GetElement(i,i);
    
64. return TRUE;
    
65. }
    
66. 
    
67. goto Loop_0;
    
68. 
    
69. Loop_2:
    
70. 
    
71. u=p*m_nNumColumns+q;
    
72. w=p*m_nNumColumns+p;
    
73. t=q*m_nNumColumns+p;
    
74. s=q*m_nNumColumns+q;
    
75. x=-m_pData;
    
76. y=(m_pData[s]-m_pData[w])/2.0;
    
77. omega=x/sqrt(x*x+y*y);
    
78. if (y<0.0)
    
79. omega=-omega;
    
80. 
    
81. sn=1.0+sqrt(1.0-omega*omega);
    
82. sn=omega/sqrt(2.0*sn);
    
83. cn=sqrt(1.0-sn*sn);
    
84. fm=m_pData[w];
    
85. m_pData[w]=fm*cn*cn+m_pData[s]*sn*sn+m_pData*omega;
    
86. m_pData[s]=fm*sn*sn+m_pData[s]*cn*cn-m_pData*omega;
    
87. m_pData=0.0; m_pData[t]=0.0;
    
88. 
    
89. for (j=0; j<=m_nNumColumns-1; j++)
    
90. {
    
91. if ((j!=p)&&(j!=q))
    
92. {
    
93. u=p*m_nNumColumns+j;
    
94. w=q*m_nNumColumns+j;
    
95. fm=m_pData;
    
96. m_pData=fm*cn+m_pData[w]*sn;
    
97. m_pData[w]=-fm*sn+m_pData[w]*cn;
    
98. }
    
99. }
    
100. 
     
101. for (i=0; i<=m_nNumColumns-1; i++)
     
102. {
     
103. if ((i!=p)&&(i!=q))
     
104. {
     
105. u=i*m_nNumColumns+p;
     
106. w=i*m_nNumColumns+q;
     
107. fm=m_pData;
     
108. m_pData=fm*cn+m_pData[w]*sn;
     
109. m_pData[w]=-fm*sn+m_pData[w]*cn;
     
110. }
     
111. }
     
112. 
     
113. for (i=0; i<=m_nNumColumns-1; i++)
     
114. {
     
115. u=i*m_nNumColumns+p;
     
116. w=i*m_nNumColumns+q;
     
117. fm=mtxEigenVector.m_pData;
     
118. mtxEigenVector.m_pData=fm*cn+mtxEigenVector.m_pData[w]*sn;
     
119. mtxEigenVector.m_pData[w]=-fm*sn+mtxEigenVector.m_pData[w]*cn;
     
120. }
     
121. 
     
122. goto Loop_1;
     
123. }

复制代码

[ 本帖最后由 风花雪月 于 2006-11-14 19:23 编辑 ]

forwardhah

"赫申伯格矩阵全部特征值的QR方法"

没有求对应的特征向量啊

有没有求特征向量的代码？

[ 本帖最后由 风花雪月 于 2006-11-14 19:25 编辑 ]

aliao

下面的几个函数没有定义或说明过它的作用：<BR>fabs()、GetElement()<BR><BR>不管怎么样还是要谢谢风花雪月……

baiyang

谢谢风花雪月了<BR>

norman

fabs()是得到浮点数的绝对值
是c/c++ 带的库函数

[ 本帖最后由 风花雪月 于 2006-8-24 03:30 编辑 ]

markailee1

GetElement() 是MFC的类COleSafeArray 的成员，
void GetElement( long* rgIndices, void* pvData );

[ 本帖最后由 风花雪月 于 2006-11-14 19:25 编辑 ]

carcanet

谢谢风花雪月

maintell

<P>好啊,测试下代码</P>

幻觉

今晚试试吧

xinyuxf

自己编好麻烦啊，还是用matlab方便些，呵呵
好东西，赞

renyusen

我在matlab中用的jacobi算法，还是那个方便，不过要学学用这些语言来编了，佩服佩服

hbyyj2008

谢谢楼主

风花雪月

原帖由 forwardhah 于 2005-11-13 15:04 发表
"赫申伯格矩阵全部特征值的QR方法"

没有求对应的特征向量啊

有没有求特征向量的代码？

特征向量还是比较容易求得，自己弄一下吧