今天给各位分享c语言矩阵计算器的知识，其中也会对c++矩阵运算函数进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
1、计算器实验C语言2、用c语言怎么编写输入一个矩阵求其逆矩阵的程序？3、c语言编程。两个5*5矩阵相乘4、如何用C语言编写一个科学计算器5、用c语言编写一个计算器6、一个有关向量与矩阵的实用计算器程序
计算器实验C语言
#include stdio.h
int number,number2,result;
int main(void)
{
puts(“欢迎使用二位数计算程序,按下回车键确定!”);
puts(“\n请分别输入二个任意整数值!”);
scanf(“%d %d”,number,number2);
result=number+number2;
printf(“(加法计算)计算结果=%d\n”,result);
result=number*number2;
printf(“(乘法计算)计算结果=%d\n”,result);
result=number/number2;
printf(“(除法计算)计算结果=%d\n”,result);
system(“echo.pause”);
return 0;
}
用c语言怎么编写输入一个矩阵求其逆矩阵的程序？
这是我编的一个简易矩阵计算器，C++语言，非常容易理解的，你可以参考求行列式和逆部分
#include iostream
#include iomanip
#include conio.h
#include “windows.h”
#include string
using namespace std;
void gotoxy(int x,int y) // 列x: 0~79 行y: 0~24
{ HANDLE hConsole=GetStdHandle(STD_OUTPUT_HANDLE);
COORD coordScreen={x,y};
SetConsoleCursorPosition(hConsole,coordScreen);
return;
}
void setcolor(unsigned short ForeColor,unsigned short BackColor)
// 0–黑 1–暗蓝 2–暗绿 3–暗青 4–暗红 5–暗紫 6–蟹黄 7–暗白
// 8–灰 9–亮蓝 10-亮绿 11-亮青 12-亮红 13-亮紫 14-黄 15-亮白
{ HANDLE hCon = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(hCon,(ForeColor % 16)|(BackColor % 16 * 16));
};
int main()
{
void plu();
void sub();
void amo();
void mul();
void ran();
void ord();
char sel=’1′;
while(sel != ‘0’)
{ int i;
system(“cls”); // 清屏
setcolor(15,0); // 下面显示黑底亮青字
gotoxy(8,1); cout”┌───────────────────────────┐”;
for(i=2;i20;i++)
{gotoxy(8,i);cout”│”;gotoxy(64,i);cout”│”;}
setcolor(15,6); // 下面显示红底白字
gotoxy(10,3); cout” “;
gotoxy(10,4); cout” 简 易 矩 阵 计 算 器 “;
gotoxy(10,5); cout” “;
setcolor(15,0); // 下面显示黑底亮青字
gotoxy(10,7); cout” 1 —- 矩阵加法 2 —- 矩阵减法 “;
gotoxy(10,9); cout” 3 —- 矩阵数乘 4 —- 矩阵乘法 “;
gotoxy(10,11); cout” 5 —- 矩阵行列式 6 —- 矩阵的逆 “;
gotoxy(10,13); cout” 0 —- 退出 “;
gotoxy(10,15); cout” 请选择(0–6):”;
gotoxy(8,20); cout”└───────────────────────────┘”;
do
{ gotoxy(28,15); sel=getche( );}
while ( sel!=’1′ sel!=’2′ sel!=’3′ sel!=’4′ sel!=’5′ sel!=’6′ sel!=’0′);
switch(sel)
{
case ‘1’:plu(); break;
case ‘2’:sub(); break;
case ‘3’:amo(); break;
case ‘4’:mul(); break;
case ‘5’:ran(); break;
case ‘6’:ord(); break;
case ‘0’: break;
}
}
system(“cls”);
gotoxy(25,10);
cout”谢 谢 使 用 系 统 ！”endl;
return 0;
}
void plu()//加法
{ char l;
system(“cls”); // 清屏
setcolor(14,0); // 下面用黑底黄字
int a,b,i,j;
gotoxy(0,0);cout” 矩阵加法 “;
gotoxy(0,2);cout”请输入矩阵的行数：”;
cina;
coutendl;
cout”请输入矩阵的列数：”;
cinb;
coutendl;
double m[10][10],n[10][10];
cout”请输入第一个矩阵：”endl;
for(i=0;ia;i++)
for(j=0;jb;j++)
{gotoxy(6*j+20,2*i+6); cinm[i][j];}
coutendlendl”请输入第二个矩阵：”endl;
for(i=0;ia;i++)
for(j=0;jb;j++)
{gotoxy(6*j+20,2*a+2*i+7);cinn[i][j];}
coutendl””endl”矩阵加法结果为：”;
for(i=0;ia;i++)
for(j=0;jb;j++)
{gotoxy(6*j+20,4*a+2*i+8);coutm[i][j]+n[i][j];}
gotoxy(0,6*a+9);
cout”按任意键退出:”;
l=getche();
}
void sub()//减法
{ char l;
system(“cls”); // 清屏
setcolor(14,0); // 下面用黑底黄字
int a,b,i,j;
gotoxy(0,0);cout”矩阵减法”;
gotoxy(0,2);cout”请输入矩阵的行数：”;
cina;
coutendl;
cout”请输入矩阵的列数：”;
cinb;
coutendl;
double m[10][10],n[10][10];
cout”请输入第一个矩阵：”endl;
for(i=0;ia;i++)
for(j=0;jb;j++)
{gotoxy(6*j+20,2*i+6); cinm[i][j];}
coutendlendl”请输入第二个矩阵：”endl;
for(i=0;ia;i++)
for(j=0;jb;j++)
{gotoxy(6*j+20,2*a+2*i+7);cinn[i][j];}
coutendl””endl”矩阵减法结果为：”;
for(i=0;ia;i++)
for(j=0;jb;j++)
{gotoxy(6*j+20,4*a+2*i+8);coutm[i][j]-n[i][j];}
gotoxy(0,6*a+9);
cout”按任意键退出:”;
l=getche();
}
void amo()//数乘
{ char h;
system(“cls”); // 清屏
setcolor(14,0); // 下面用黑底黄字
int a,b,i,j;
gotoxy(0,0);cout”矩阵数乘”;
gotoxy(0,2);cout”请输入矩阵的行数：”;
cina;
coutendl;
cout”请输入矩阵的列数：”;
cinb;
coutendl;
double m[10][10],c;
cout”请输入矩阵：”endl;
for(i=0;ia;i++)
for(j=0;jb;j++)
{gotoxy(6*j+20,2*i+6);cinm[i][j];}
coutendl”请输入与矩阵相乘的实数：”;
cinc;
coutendlendl”矩阵数乘结果为：”;
for(i=0;ia;i++)
for(j=0;jb;j++)
{gotoxy(8*j+20,2*a+2*i+9);coutm[i][j]*c;}
gotoxy(0,4*a+12);
cout”按任意键退出：”;h=getche();
}
void mul()//乘法
{
char k;
system(“cls”); // 清屏
setcolor(14,0); // 下面用黑底黄字
int a,b,c,i,j,q;
gotoxy(0,0);cout”矩阵乘法”;
gotoxy(0,2);cout”请输入第一个矩阵的行数：”;
cina;
coutendl”请输入第一个矩阵的列数：”;
cinb;
coutendl”则第二个矩阵的行数也为:”b;
coutendlendl”请输入第二个矩阵的列数：”;
cinc;
coutendl;
double m[10][10],n[10][10],p[10][10]={0};
cout”请输入第一个矩阵：”endl;
for(i=0;ia;i++)
for(j=0;jb;j++)
{gotoxy(6*j+18,2*i+10); cinm[i][j];}
coutendlendl”请输入第二个矩阵：”;
for(i=0;ib;i++)
for(j=0;jc;j++)
{gotoxy(6*j+18,2*a+2*i+11);cinn[i][j];}
coutendl””endl”矩阵相乘结果为： “;
for(i=0;ia;i++)
for(j=0;jc;j++)
for(q=0;qb;q++) p[i][j]=p[i][j]+m[i][q]*n[q][j];
for(i=0;ia;i++)
for(j=0;jc;j++)
{gotoxy(10*j+18,2*a+2*b+2*i+12);coutp[i][j];}
gotoxy(16,2*a+2*b+2*i+15);
cout”按任意键退出：”;k=getche();
}
//===================================================行列式
float Fun(int n1,float a1[10][10]);
void ran()
{
system(“cls”); // 清屏
setcolor(15,0); // 下面用黑底黄字
char k;
int n,i,j;
cout”矩阵行列式”endlendl”请输入矩阵阶数: “;
cinn;
coutendl”请输入矩阵:”endl;
float a[10][10];
for(i=0;in;i++)
for(j=0;jn;j++)
{gotoxy(6*j+12,2*i+4);cina[i][j];}
coutendl”行列式为: “Fun(n,a)endlendl;
cout”按任意键退出：”;
k=getche();
}
float Fun(int n1,float a1[10][10])//求行列式的递归函数
{
int i_1,j_1,c;//c为数组b的行
float b[10][10];
int p=0,q=0;
float sum=0;
if(n1==1) return a1[0][0];
for(i_1=0;i_1n1;i_1++)
{
for(c=0;cn1-1;c++)
{if(ci_1) p=0;
else p=1;
for(j_1=0;j_1n1-1;j_1++)
{b[c][j_1]=a1[c+p][j_1+1];}
}
if(i_1%2==0)
q=1;
else q=(-1);
sum=sum+a1[i_1][0]*q*Fun(n1-1,b);
}return sum;
}
//================================================================
void ord()
{
char g;
system(“cls”); // 清屏
setcolor(15,0); // 下面用黑底黄字
int i,j,n;
gotoxy(0,0);cout”矩阵的逆”;
gotoxy(0,2);cout”请输入矩阵的阶数：”;
cinn;
coutendl;
cout”请输入矩阵：”;
float l[10][10],m[10][10],p;
for(i=0;in;i++)
for(j=0;jn;j++)
{gotoxy(4*j+12,2*i+4); cinl[i][j];}
if(Fun(n,l)==0) coutendl”该矩阵无逆！！！”endl;
else
{p=Fun(n,l);
coutendl”矩阵的逆为： “;
for(i=0;in;i++)
for(j=0;jn;j++)
{{float f[10][10];
int r,w,e,d;//e为数组f的行数
for(int j_1=0,e=0;j_1n-1,en-1;j_1++,e++)
for(int i_1=0,d=0;i_1n-1,dn-1;i_1++,d++)
{if(ei) r=0;else r=1;
if(dj) w=0;else w=1;
f[i_1][j_1]=l[i_1+w][j_1+r];};
if((i+j)%2==0) m[i][j]=Fun(n-1,f)/p;
else m[i][j]=-Fun(n-1,f)/p;
};
gotoxy(9*j+12,2*n+2*i+4);coutm[i][j];};};
coutendlendl”按任意键退出：”;g=getche();
}
c语言编程。两个5*5矩阵相乘
#include “stdio.h”
const int MAX=5;
void multi(int a[MAX][MAX],int b[MAX][MAX],int c[MAX][MAX])
{
int i,j,k;
for(i=0;iMAX;i++)for(j=0;jMAX;j++)c[i][j]=0;//初值化
for(i=0;iMAX;i++)//按照书上的公式，乘起来，结果放在C数组里
{
for(j=0;jMAX;j++)
{
for(k=0;kMAX;k++)
{
c[i][j]+=a[i][k]*b[k][j];
}
}
}
}
void out(int x[MAX][MAX],int n)//输入矩阵
{
int i,j;
for(i=0;in;i++)
{
for(j=0;jn;j++)
printf(“%d “,x[i][j]);
puts(“”);
}
}
void read(int x[MAX][MAX],int n)
{
int i,j;
for(i=0;in;i++)for(j=0;jn;j++)scanf(“%d”,x[i][j]);
}
int main()
{
int a[MAX][MAX],b[MAX][MAX],c[MAX][MAX];
read(a,MAX);//读入矩阵
read(b,MAX);
out(c,MAX);
return 0;
}
如何用C语言编写一个科学计算器
用栈 就可以办到了。。。这个很详细的， lz 随便输入一个表达式，中间的计算过程全部输出了，lz试两个 就知道怎么回事了。 #include stdio.h
#include stdlib.h
#include string.h
#define MAXSIZE 4000;
typedef struct
{
char data[10];
int top;//头地址
int base;//基地址
int length;//长度
}Stack;
void init(Stack *st)//初始化栈
{
st-base=0;
st-top=0;
st-length=0;
}
int isEmpty(Stack *st)
{
int n=0,top,base;
top =st-top;
base =st-base;
if(top==base)
{
return 1;
}
return n;
}
int isFull(Stack *st)
{
int n=0,top,base;
top =st-top;
if(top=4000)
{
return 1;
}
return n;
}
char getTop(Stack *st)// 返回top值，不改变栈的结构
{
char n;
if(isEmpty(st))
{
printf(“栈为空\n”);
return 0;
}
int positon= st-top-1;
n= st-data[positon];//取出数据;
return n;
}
char pop(Stack *st)// 出栈，返回
{
char n;
if(isEmpty(st))
{
printf(“栈为空\n”);
return 0;
}
int positon= st-top-1;
n= st-data[positon];//取出数据;
st-top–;
st-length–;
st-data[positon]=’\0′;//消除数据
return n;
}
void push(char n,Stack *st)//入栈
{
int positon ;
if(isFull(st))
{
printf(“栈满\n”);
}
else
{
positon= st-top;//获取位置
st-data[positon]=n;//存入数据
st-top++;//改变位置
}
}
void show(Stack *m1)//输出栈中的数据
{
int top,base;
top=m1-top;
base=m1-base;
while(topbase)
{
printf(“%c,”,m1-data[–top]);
}
printf(“\n”);
}
int isOperate(char temp)//是否是操作符
{
if(temp==’+’||temp==’-‘||temp==’*’||temp==’/’||temp=='(‘||temp==’)’||temp==’#’)
{
return 1;
}
return 0;
}
int isValue(char temp)//是否是数值
{
if(temp=’0’temp=’9′)//
{
return 1;
}
else
{
return 0;
}
}
int isAvail(char temp)//是否有效字符
{
if(isOperate(temp)||isValue(temp))//如果temp既不是操作符和数值的话，则它是非法的
{
return 1;
}
return 0;
}
int detect(char temp)//搜索矩阵位置
{
int i=0;
char oper[7]={‘+’,’-‘,’*’,’/’,'(‘,’)’,’#’};
for(i=0;i7;i++)
{
if(temp==oper[i])
{
return i;
}
}
}
char Priority(char temp,char optr)//判断优先级
{
/**//*
+ – * / ( ) #
1 2 3 4 5 6 7
+ 1
– 2
* 3
/ 4
( 5 = 0
) 6 = 0
# 7 0 =
*/
int row ,col;
char priority[7][7]={/**//* + – * / ( ) # */
{”,”,”,”,”,”,”},
{”,”,”,”,”,”,”},
{”,”,”,”,”,”,”},
{”,”,”,”,”,”,”},
{”,”,”,”,”,’=’,”},
{”,”,”,”,’=’,’0′,”},
{”,”,”,”,”,”,’=’},
};
row = detect(temp);//找出对应的矩阵下标;
col = detect(optr);
// printf(“%d,%d”,row,col);
//优先级存储在一个7×7的矩阵中，对应关系上图；
return priority[row][col];
}
char evaluate(int a,int b,char oper)
{
switch(oper)
{
case ‘+’: return a+b+’0′;
case ‘-‘: return a-b+’0’;
case ‘*’: return a*b+’0′;
case ‘/’: return a/b+’0′;
default : return 0+’0′;
}
}
int calculateExpress(char *express)//计算表达式
{
int result=0;
int a,b;
// char oper,result;
Stack OPTR,OPND;//OPTR存储操作符，OPND操作数值
init(OPTR);
init(OPND);
push(‘#’,OPTR);//默认第一个位’#’
////////////////////-算法-////////////////////////////
while(*express!=’\0′)
{
char temp;
temp= *(express);
printf(“———————————\n”);
printf(“当前的符号为%c\n”,temp);
if(isAvail(temp))//是否是有效字符
{
if(isOperate(temp) )//输入的是操作符
{
char oper,result;
char optr = getTop(OPTR);//栈中top位的操作符
printf(“栈顶操作符位：%c\n”,optr);
char prior = Priority(temp,optr);//判断优先级
switch(prior)
{
case ”:
push(temp,OPTR);
printf(“将符号位%c入栈\n”,temp);
express++;
break;
case ”:
//int a,b;
//char oper,result;
a=pop(OPND)-‘0’;//存在栈中的都是char字符
b=pop(OPND)-‘0’;
oper=pop(OPTR);
result=evaluate(b,a,oper);//出栈一个操作符，计算结果
//printf(“%d”,result-‘0’);
push(result,OPND);//结果入OPND
printf(“%d%c%d结果为:%d\n”,b,oper,a,result-‘0’);
break;
case ‘=’:
//消除括号
pop(OPTR);
printf(“消除括号\n”);
express++;
break;
}
}
if(isValue(temp))//输入的是数值
{
push(temp,OPND);//将数值位入栈;
express++;
printf(“将数值%c压入栈\n”,temp);
//show(OPND);
}
}
else //表达式中有非法字符
{
printf(“表达式中有非法字符\n”);
exit(-1);//退出程序
}
}
// show(OPND);
// show(OPTR);
return getTop(OPND)-‘0’;
}
void inputExpress(char *express)//输入表达式
{
int length=0;
printf(“请输入一个表达式:”);
scanf(“%s”,express);
int len =strlen(express);
express[len]=’#’;//表达式最后一位默认为’#’;
express[len+1]=’\0′;
}
void output(char *express,int result)//输出表达式
{
int i=0;
printf(“—————————————-\n表达式:”);
while(express[i]!=’#’)
{
printf(“%c”,express[i]);
i++;
}
printf(“=%d\n”,result);
}
int main()
{
char express[100];//表达式
int result =0;
inputExpress(express);//输入表达式
result = calculateExpress(express);//计算表达式；
output(express,result); //输出表达式
//、、、、、、、、、、、、、测试优先级。
/**//*
char m=’7′ ;
m=Priority(‘+’,’*’);
printf(“优先级为%c”,m);
int m=evaluate(5,6,’m’);
printf(“%d”,m);
*/
return 0;
}
用c语言编写一个计算器
先简单给你写了一下，你先看看行不行，太晚了，我得睡啦，要是不明白，明天追问就行：
#include stdio.h
int main()
{
int a,b;
char c;
while(
//这里是逗号表达式，如果看起来别扭可以改到while循环外
printf(“请输入1个式子(输入q退出)：\n”),
scanf(“%d%c%d”,a,c,b)==3
)
{
//先给你写了加减乘除，当然这里也可以采用switch
if(c==’+’) printf(“%d\n”,a+b);//加
else if(c==’-‘) printf(“%d\n”,a-b);//减
else if(c==’*’) printf(“%d\n”,a*b);//乘
else if(c==’/’) printf(“%d\n”,a/b);//除
}
return 0;
}
一个有关向量与矩阵的实用计算器程序
//数值计算程序-特征值和特征向量
//////////////////////////////////////////////////////////////
//约化对称矩阵为三对角对称矩阵
//利用Householder变换将n阶实对称矩阵约化为对称三对角矩阵
//a-长度为n*n的数组，存放n阶实对称矩阵
//n-矩阵的阶数
//q-长度为n*n的数组，返回时存放Householder变换矩阵
//b-长度为n的数组，返回时存放三对角阵的主对角线元素
//c-长度为n的数组，返回时前n-1个元素存放次对角线元素
void eastrq(double a[],int n,double q[],double b[],double c[]);
//////////////////////////////////////////////////////////////
//求实对称三对角对称矩阵的全部特征值及特征向量
//利用变型QR方法计算实对称三对角矩阵全部特征值及特征向量
//n-矩阵的阶数
//b-长度为n的数组，返回时存放三对角阵的主对角线元素
//c-长度为n的数组，返回时前n-1个元素存放次对角线元素
//q-长度为n*n的数组，若存放单位矩阵，则返回实对称三对角矩阵的特征向量组
// 若存放Householder变换矩阵，则返回实对称矩阵A的特征向量组
//a-长度为n*n的数组，存放n阶实对称矩阵
int ebstq(int n,double b[],double c[],double q[],double eps,int l);
//////////////////////////////////////////////////////////////
//约化实矩阵为赫申伯格(Hessen berg)矩阵
//利用初等相似变换将n阶实矩阵约化为上H矩阵
//a-长度为n*n的数组，存放n阶实矩阵,返回时存放上H矩阵
//n-矩阵的阶数
void echbg(double a[],int n);
//////////////////////////////////////////////////////////////
//求赫申伯格(Hessen berg)矩阵的全部特征值
//返回值小于0表示超过迭代jt次仍未达到精度要求
//返回值大于0表示正常返回
//利用带原点位移的双重步QR方法求上H矩阵的全部特征值
//a-长度为n*n的数组，存放上H矩阵
//n-矩阵的阶数
//u-长度为n的数组，返回n个特征值的实部
//v-长度为n的数组，返回n个特征值的虚部
//eps-控制精度要求
//jt-整型变量，控制最大迭代次数
int edqr(double a[],int n,double u[],double v[],double eps,int jt);
//////////////////////////////////////////////////////////////
//求实对称矩阵的特征值及特征向量的雅格比法
//利用雅格比(Jacobi)方法求实对称矩阵的全部特征值及特征向量
//返回值小于0表示超过迭代jt次仍未达到精度要求
//返回值大于0表示正常返回
//a-长度为n*n的数组，存放实对称矩阵，返回时对角线存放n个特征值
//n-矩阵的阶数
//u-长度为n*n的数组，返回特征向量(按列存储)
//eps-控制精度要求
//jt-整型变量，控制最大迭代次数
int eejcb(double a[],int n,double v[],double eps,int jt);
//////////////////////////////////////////////////////////////
选自徐世良数值计算程序集(C)
每个程序都加上了适当地注释，陆陆续续干了几个月才整理出来的啊。
今天都给贴出来了
#include “stdio.h”
#include “math.h”
//约化对称矩阵为三对角对称矩阵
//利用Householder变换将n阶实对称矩阵约化为对称三对角矩阵
//a-长度为n*n的数组，存放n阶实对称矩阵
//n-矩阵的阶数
//q-长度为n*n的数组，返回时存放Householder变换矩阵
//b-长度为n的数组，返回时存放三对角阵的主对角线元素
//c-长度为n的数组，返回时前n-1个元素存放次对角线元素
void eastrq(double a[],int n,double q[],double b[],double c[])
{
int i,j,k,u,v;
double h,f,g,h2;
for (i=0; i=n-1; i++)
{
for (j=0; j=n-1; j++)
{
u=i*n+j; q[u]=a[u];
}
}
for (i=n-1; i=1; i–)
{
h=0.0;
if (i1)
{
for (k=0; k=i-1; k++)
{
u=i*n+k;
h=h+q[u]*q[u];
}
}
if (h+1.0==1.0)
{
c[i-1]=0.0;
if (i==1)
{
c[i-1]=q[i*n+i-1];
}
b[i]=0.0;
}
else
{
c[i-1]=sqrt(h);
u=i*n+i-1;
if (q[u]0.0)
{
c[i-1]=-c[i-1];
}
h=h-q[u]*c[i-1];
q[u]=q[u]-c[i-1];
f=0.0;
for (j=0; j=i-1; j++)
{
q[j*n+i]=q[i*n+j]/h;
g=0.0;
for (k=0; k=j; k++)
{
g=g+q[j*n+k]*q[i*n+k];
}
if (j+1=i-1)
{
for (k=j+1; k=i-1; k++)
{
g=g+q[k*n+j]*q[i*n+k];
}
}
c[j-1]=g/h;
f=f+g*q[j*n+i];
}
h2=f/(h+h);
for (j=0; j=i-1; j++)
{
f=q[i*n+j];
g=c[j-1]-h2*f;
c[j-1]=g;
for (k=0; k=j; k++)
{
u=j*n+k;
q[u]=q[u]-f*c[k-1]-g*q[i*n+k];
}
}
b[i]=h;
}
}
b[0]=0.0;
for (i=0; i=n-1; i++)
{
if ((b[i]!=0.0)(i-1=0))
{
for (j=0; j=i-1; j++)
{
g=0.0;
for (k=0; k=i-1; k++)
{
g=g+q[i*n+k]*q[k*n+j];
}
for (k=0; k=i-1; k++)
{
u=k*n+j;
q[u]=q[u]-g*q[k*n+i];
}
}
}
u=i*n+i;
b[i]=q[u];
q[u]=1.0;
if (i-1=0)
{
for (j=0; j=i-1; j++)
{
q[i*n+j]=0.0;
q[j*n+i]=0.0;
}
}
}
return;
//求实对称三对角对称矩阵的全部特征值及特征向量
//利用变型QR方法计算实对称三对角矩阵全部特征值及特征向量
//n-矩阵的阶数
//b-长度为n的数组，返回时存放三对角阵的主对角线元素
//c-长度为n的数组，返回时前n-1个元素存放次对角线元素
//q-长度为n*n的数组，若存放单位矩阵，则返回实对称三对角矩阵的特征向量组
// 若存放Householder变换矩阵，则返回实对称矩阵A的特征向量组
//a-长度为n*n的数组，存放n阶实对称矩阵
int ebstq(int n,double b[],double c[],double q[],double eps,int l)
{
int i,j,k,m,it,u,v;
double d,f,h,g,p,r,e,s;
c[n-1]=0.0;
d=0.0;
f=0.0;
for (j=0; j=n-1; j++)
{
it=0;
h=eps*(fabs(b[j])+fabs(c[j]));
if (hd)
{
d=h;
}
m=j;
while ((m=n-1)(fabs(c[m])d))
{
m=m+1;
}
if (m!=j)
{
do
{
if (it==l)
{
printf(“fail\n”);
return(-1);
}
it=it+1;
g=b[j];
p=(b[j+1]-g)/(2.0*c[j]);
r=sqrt(p*p+1.0);
if (p=0.0)
{
b[j]=c[j]/(p+r);
}
else
{
b[j]=c[j]/(p-r);
}
h=g-b[j];
for (i=j+1; i=n-1; i++)
{
b[i]=b[i]-h;
}
f=f+h;
p=b[m];
e=1.0;
s=0.0;
for (i=m-1; i=j; i–)
{
g=e*c[i];
h=e*p;
if (fabs(p)=fabs(c[i]))
{
e=c[i]/p;
r=sqrt(e*e+1.0);
c[i+1]=s*p*r;
s=e/r;
e=1.0/r;
}
else
{
e=p/c[i];
r=sqrt(e*e+1.0);
c[i+1]=s*c[i]*r;
s=1.0/r;
e=e/r;
}
p=e*b[i]-s*g;
b[i+1]=h+s*(e*g+s*b[i]);
for (k=0; k=n-1; k++)
{
u=k*n+i+1;
v=u-1;
h=q[u];
q[u]=s*q[v]+e*h;
q[v]=e*q[v]-s*h;
}
}
c[j]=s*p;
b[j]=e*p;
}
while (fabs(c[j])d);
}
b[j]=b[j]+f;
}
for (i=0; i=n-1; i++)
{
k=i; p=b[i];
if (i+1=n-1)
{
j=i+1;
while ((j=n-1)(b[j]=p))
{
k=j;
p=b[j];
j=j+1;
}
}
if (k!=i)
{
b[k]=b[i];
b[i]=p;
for (j=0; j=n-1; j++)
{
u=j*n+i;
v=j*n+k;
p=q[u];
q[u]=q[v];
q[v]=p;
}
}
}
return(1);
}
//约化实矩阵为赫申伯格(Hessen berg)矩阵
//利用初等相似变换将n阶实矩阵约化为上H矩阵
//a-长度为n*n的数组，存放n阶实矩阵,返回时存放上H矩阵
//n-矩阵的阶数
void echbg(double a[],int n)
{ int i,j,k,u,v;
double d,t;
for (k=1; k=n-2; k++)
{
d=0.0;
for (j=k; j=n-1; j++)
{
u=j*n+k-1;
t=a[u];
if (fabs(t)fabs(d))
{
d=t;
i=j;
}
}
if (fabs(d)+1.0!=1.0)
{
if (i!=k)
{
for (j=k-1; j=n-1; j++)
{
u=i*n+j;
v=k*n+j;
t=a[u];
a[u]=a[v];
a[v]=t;
}
for (j=0; j=n-1; j++)
{
u=j*n+i;
v=j*n+k;
t=a[u];
a[u]=a[v];
a[v]=t;
}
}
for (i=k+1; i=n-1; i++)
{
u=i*n+k-1;
t=a[u]/d;
a[u]=0.0;
for (j=k; j=n-1; j++)
{
v=i*n+j;
a[v]=a[v]-t*a[k*n+j];
}
for (j=0; j=n-1; j++)
{
v=j*n+k;
a[v]=a[v]+t*a[j*n+i];
}
}
}
}
return;
}
//求赫申伯格(Hessen berg)矩阵的全部特征值
//利用带原点位移的双重步QR方法求上H矩阵的全部特征值
//返回值小于0表示超过迭代jt次仍未达到精度要求
//返回值大于0表示正常返回
//a-长度为n*n的数组，存放上H矩阵
//n-矩阵的阶数
//u-长度为n的数组，返回n个特征值的实部
//v-长度为n的数组，返回n个特征值的虚部
//eps-控制精度要求
//jt-整型变量，控制最大迭代次数
int edqr(double a[],int n,double u[],double v[],double eps,int jt)
{
int m,it,i,j,k,l,ii,jj,kk,ll;
double b,c,w,g,xy,p,q,r,x,s,e,f,z,y;
it=0;
m=n;
while (m!=0)
{
l=m-1;
while ((l0)(fabs(a[l*n+l-1])eps*(fabs(a[(l-1)*n+l-1])+fabs(a[l*n+l]))))
{
l=l-1;
}
ii=(m-1)*n+m-1;
jj=(m-1)*n+m-2;
kk=(m-2)*n+m-1;
ll=(m-2)*n+m-2;
if (l==m-1)
{
u[m-1]=a[(m-1)*n+m-1];
v[m-1]=0.0;
m=m-1; it=0;
}
else if (l==m-2)
{
b=-(a[ii]+a[ll]);
c=a[ii]*a[ll]-a[jj]*a[kk];
w=b*b-4.0*c;
y=sqrt(fabs(w));
if (w0.0)
{
xy=1.0;
if (b0.0)
{
xy=-1.0;
}
u[m-1]=(-b-xy*y)/2.0;
u[m-2]=c/u[m-1];
v[m-1]=0.0; v[m-2]=0.0;
}
else
{
u[m-1]=-b/2.0;
u[m-2]=u[m-1];
v[m-1]=y/2.0;
v[m-2]=-v[m-1];
}
m=m-2;
it=0;
}
else
{
if (it=jt)
{
printf(“fail\n”);
return(-1);
}
it=it+1;
for (j=l+2; j=m-1; j++)
{
a[j*n+j-2]=0.0;
}
for (j=l+3; j=m-1; j++)
{
a[j*n+j-3]=0.0;
}
for (k=l; k=m-2; k++)
{
if (k!=l)
{
p=a[k*n+k-1];
q=a[(k+1)*n+k-1];
r=0.0;
if (k!=m-2)
{
r=a[(k+2)*n+k-1];
}
}
else
{
x=a[ii]+a[ll];
y=a[ll]*a[ii]-a[kk]*a[jj];
ii=l*n+l;
jj=l*n+l+1;
kk=(l+1)*n+l;
ll=(l+1)*n+l+1;
p=a[ii]*(a[ii]-x)+a[jj]*a[kk]+y;
q=a[kk]*(a[ii]+a[ll]-x);
r=a[kk]*a[(l+2)*n+l+1];
}
if ((fabs(p)+fabs(q)+fabs(r))!=0.0)
{
xy=1.0;
if (p0.0)
{
xy=-1.0;
}
s=xy*sqrt(p*p+q*q+r*r);
if (k!=l)
{
a[k*n+k-1]=-s;
}
e=-q/s;
f=-r/s;
x=-p/s;
y=-x-f*r/(p+s);
g=e*r/(p+s);
z=-x-e*q/(p+s);
for (j=k; j=m-1; j++)
{
ii=k*n+j;
jj=(k+1)*n+j;
p=x*a[ii]+e*a[jj];
q=e*a[ii]+y*a[jj];
r=f*a[ii]+g*a[jj];
if (k!=m-2)
{
kk=(k+2)*n+j;
p=p+f*a[kk];
q=q+g*a[kk];
r=r+z*a[kk];
a[kk]=r;
}
a[jj]=q;
a[ii]=p;
}
j=k+3;
if (j=m-1)
{
j=m-1;
}
for (i=l; i=j; i++)
{
ii=i*n+k;
jj=i*n+k+1;
p=x*a[ii]+e*a[jj];
q=e*a[ii]+y*a[jj];
r=f*a[ii]+g*a[jj];
if (k!=m-2)
{
kk=i*n+k+2;
p=p+f*a[kk];
q=q+g*a[kk];
r=r+z*a[kk];
a[kk]=r;
}
a[jj]=q;
a[ii]=p;
}
}
}
}
}
return(1);
}
//求实对称矩阵的特征值及特征向量的雅格比法
//利用雅格比(Jacobi)方法求实对称矩阵的全部特征值及特征向量
//返回值小于0表示超过迭代jt次仍未达到精度要求
//返回值大于0表示正常返回
//a-长度为n*n的数组，存放实对称矩阵，返回时对角线存放n个特征值
//n-矩阵的阶数
//u-长度为n*n的数组，返回特征向量(按列存储)
//eps-控制精度要求
//jt-整型变量，控制最大迭代次数
int eejcb(double a[],int n,double v[],double eps,int jt)
{
int i,j,p,q,u,w,t,s,l;
double fm,cn,sn,omega,x,y,d;
l=1;
for (i=0; i=n-1; i++)
{
v[i*n+i]=1.0;
for (j=0; j=n-1; j++)
{
if (i!=j)
{
v[i*n+j]=0.0;
}
}
}
while (1==1)
{
fm=0.0;
for (i=0; i=n-1; i++)
{
for (j=0; j=n-1; j++)
{
d=fabs(a[i*n+j]);
if ((i!=j)(dfm))
{
fm=d;
p=i;
q=j;
}
}
}
if (fmeps)
{
return(1);
}
if (ljt)
{
return(-1);
}
l=l+1;
u=p*n+q;
w=p*n+p;
t=q*n+p;
s=q*n+q;
x=-a[u];
y=(a[s]-a[w])/2.0;
omega=x/sqrt(x*x+y*y);
if (y0.0)
{
omega=-omega;
}
sn=1.0+sqrt(1.0-omega*omega);
sn=omega/sqrt(2.0*sn);
cn=sqrt(1.0-sn*sn);
fm=a[w];
a[w]=fm*cn*cn+a[s]*sn*sn+a[u]*omega;
a[s]=fm*sn*sn+a[s]*cn*cn-a[u]*omega;
a[u]=0.0;
a[t]=0.0;
for (j=0; j=n-1; j++)
{
if ((j!=p)(j!=q))
{
u=p*n+j;
w=q*n+j;
fm=a[u];
a[u]=fm*cn+a[w]*sn;
a[w]=-fm*sn+a[w]*cn;
}
}
for (i=0; i=n-1; i++)
{
if ((i!=p)(i!=q))
{
u=i*n+p;
w=i*n+q;
fm=a[u];
a[u]=fm*cn+a[w]*sn;
a[w]=-fm*sn+a[w]*cn;
}
}
for (i=0; i=n-1; i++)
{
u=i*n+p;
w=i*n+q;
fm=v[u];
v[u]=fm*cn+v[w]*sn;
v[w]=-fm*sn+v[w]*cn;
}
}
return(1);
}
c语言矩阵计算器的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于c++矩阵运算函数、c语言矩阵计算器的信息别忘了在本站进行查找喔。
微信扫一扫 
支付宝扫一扫 
