중화사전망 - 자전 검색 - 사전 매트릭스 건물 코드
사전 매트릭스 건물 코드
# include & ltiostream & gt
# include & ltcstdlib & gt
# include & ltcstdio & gt
# include & ltcmath & gt
# include & ltcstring & gt
네임스페이스 STD 사용
범주 행렬식
{
공용:
행렬식 ()
{
Int I, j;
사이드 길이 = 2;
Array = new double * [side lenth];
For(I = 0；; 나< 측면 길이; I++)
{
Array [I] = new double [side lenth];
}
For(I = 0；; 나< 측면 길이; I++)
{
For(j = 0；; J< 측면 길이; J++)
{
Array [I] [j] = 0;
}
}
}
행렬식 (정수 배)
{
Int I, j;
이-> 사이드 길이 = 사이드 길이
Array = new double * [side lenth];
For(I = 0；; 나< 측면 길이; I++)
{
Array [I] = new double [side lenth];
}
For(I = 0；; 나< 측면 길이; I++)
{
For(j = 0；; J< 측면 길이; J++)
{
Array [I] [j] = 0;
}
}
}
~ 행렬식 ()
{
For(int I = 0；; 나< 측면 길이; I++)
{
[I]； 배열 삭제 [I];
}
[] 배열 삭제
}
Voidsetdeterminant ();
Doublecalculate ();
Double 등호 ();
이중 * * 배열;
Intgetsidelenth ();
Double calCofactor(int m, int n) ： //m 은 수평 스케일이고 n 은 수직 스케일입니다.
Voidshow (); //테스트용
보호 대상:
Int sideLenth
개인:
Doublecaltwo ();
유효하지 않은 복사 (결정 요인 및 amp forcal);
Void exchangeCorOrRow (결정 요인 & ampforCal, int m, int n, bool colorrow);
}
Int 결정 요인:: getsideLenth ()
{
측면 길이를 반환합니다.
}
Void 결정 요인:: setdeterminant ()
{
For(int j = 0；; J< 측면 길이; J++)
{
For(int I = 0；; 나< 측면 길이; I++)
{
CIN>；; & gt array [I] [j];
}
}
}
이중 결정 요인:: calculate ()
{
If (모서리 길이 ==2)
{
Caltwo ();
}
이중 결과 = 0.0;
For(int I = 0；; 나< 측면 길이; I++)
{
Result+=calCofactor(i, 0) * array [I] [0];
}
결과를 반환합니다.
}
이중 결정 요인:: calCofactor(int m, int n)
{
Int yi=0, yj = 0；;
Int I；;
결정 요인 yzs (side lenth-1);
For(I = 0；; 나< 측면 길이; I++)
{
만약! =m)
{
For(int j = 0；; J< 측면 길이; J++)
{
만약 (j! =n)
Yzs.array [yi] [y j++] = array [I] [j];
}
Y I++;
Yj = 0；;
}
}
Doubletmp = yzs.calculate ();
If((m+n)%2== 1)
Tmp =-tmp;
Tmp 로 돌아가기
}
이중 결정 요인:: caltwo ()
{
만약 (sideLenth! =2)
{
Cout & lt& lt "오류!" & lt& ltendl
0.0 을 반환합니다
}
기타
{
배열 [0][0]* 배열 [1][ 1]- 배열 [0][ 1]* 배열 [/
}
}
이중 결정 요인:: equal ()
{
If(sideLenth & lt；; 4) 을 참조하십시오
{
Calculate ();
}
결정 요인 forCal (가장자리 길이);
복사 (for cal);
Bool b = true
For(int I = 0；; 나 & ltsidelenth-1; I++)//i 는 삼각측정이 필요한 열입니다.
{
If(forCal.array[i][i]==0)
{
For (int k = I+1; K< 측면 길이; K++)
{
If(forCal.array[k][i]! =0)
{
Exchange corrow(for cal, I, k, true);
B=! B;
깨뜨리다
}
}
If(k = = 모서리 길이)
0 을 반환합니다
}
For (int j = I+1; J< 측면 길이; J++)//j 는 삼각 측량이 필요한 선입니다.
{
If(forCal.array[i][j]! =0)
{
Doubletimes = forcal.array [I] [j]/forcal.array [I] [I];
For(int k = I；; K< 측면 길이; K++)
{
For cal.array [k] [j]-= (for cal.array [k] [I] * times);
}
}
}
}
이중 결과 =1;
For(I = 0；; 나< 측면 길이; I++)
{
Result * = forcal.array [I] [I];
}
만약 (! B) 결과 =-결과
결과를 반환합니다.
}
Void 결정 요인:: 복사 (결정 요인 & ampforCal)
{
Int I, j;
If(forCal.sideLenth! = 측면 길이)
{
Cout & lt& lt "크기가 다르므로 복사할 수 없습니다."
반환;
}
For(I = 0；; 나< 측면 길이; I++)
{
For(j = 0；; J< 측면 길이; J++)
{
Forcal.array [I] [j] = array [I] [j];
}
}
}
Void 결정 요인:: exchangeCorOrRow (결정 요인 & ampforCal, int m, int n, bool colorrow)
{
이중 온도
(m> = sidelenth | | n> = sidelenth | | m<0 | | n<0)
{
Cout & lt& lt "매개 변수 오류"
반환;
}
If(colorrow)//true 는 교환 열입니다.
{
For(int I = 0；; 나< 측면 길이; I++)
{
Temp = forcal.array [I] [m];
For cal.array [I] [m] = for cal.array [I] [n];
Forcal.array [I] [n] = temp;
}
}
그렇지 않으면 //false 는 스왑 라인입니다.
{
For(int I = 0；; 나< 측면 길이; I++)
{
Temp = forcal.array [m] [I];
For cal.array [m] [I] = for cal.array [n] [I];
Forcal.array [n] [I] = temp;
}
}
}
Void 결정 요인:: show ()
{
For(int I = 0；; 나< 측면 길이; I++)
{
For(int j = 0；; J< 측면 길이; J++)
{
Printf("%-6.2lf ",array [j] [I]);
}
Printf ("\ n");
}
}
분류: 행렬
{
개인:
Int 라인; //선 레이블의 최대값
최대 int col// 열 레이블
Void copyToDeterminant (결정 요인& 목적지);
Void equalConvers(int RS, int rd, int cs, doublefactor);
Void divider row(int r, int cs, doublefactor);
Void exchangerow(int RS, intrd);
공용:
이중 * * 배열;
Matrix(){ row = 0；; Col = 0；; }
Voidsetarray (); //2d 배열 초기화
매트릭스 (introw, intcol);
~ matrix ();
Voidsetmatrix (); //행렬에 값 지정
Voidshow ();
Voidinverse ();
허공운 ();
친구가 유효하지 않은 곱셈 (행렬& 결과, 상수 행렬 및 Faciend, 상수 행렬 및 amp 승수);
Int stairlize(int start, intend);
Intgetrow () {return row; }
Intgetcol () {returncol; }
}
Void matrix::setArray ()
{
Int I, j;
Array = newdouble * [row];
For(I = 0；; 나< 행; I++)
{
Array [I] = new double [col];
}
For(I = 0；; 나 & ltcoli++)
{
For(j = 0；; J< 행; J++)
{
Array [j] [I] = 0;
}
}
}
Matrix::matrix(int row, int col)
{
이-> Row = row
이-> Col = col
Setarray ();
}
행렬:: ~ 행렬 ()
{
Int I；;
For(I = 0；; 나< 행; I++)
{
[I]； 배열 삭제 [I];
}
[] 배열 삭제
Array = NULL
}
Void matrix::setmatrix ()
{
If(row==0||col==0)
{
"매트릭스가 초기화되지 않았습니다. \ n";
}
Int I, j;
For(I = 0；; 나 & ltcoli++)
{
For(j = 0；; J< 행; J++)
{
Scanf("%lf ",& amparray [j] [I]);
}
}
}
Void matrix::show ()
{
Int I, j;
For(I = 0；; 나 & ltcoli++)
{
For(j = 0；; J< 행; J++)
{
Printf("%.2lf ",array [j] [I]);
}
Printf ("\ n");
}
}
보이드 승수 (행렬& 결과, 상수 행렬 및 Faciend, 상수 행렬& 승수)
{
If(faciend.row! =multiplicator.col)
왼쪽 행렬의 열 수는 오른쪽 행렬의 행 수와 같아야 합니다. \ n”；
Result.row = multiplica tor.row;
Result.col = faciend.col;
Result.setarray ();
Int times = faciend.row
Int m, n, I;
For(n = 0；; N< 결과. row；; N++)
{
For(m = 0；; M< 결과. col；; M++)
{
이중 결과 수 = 0.0;
For(I = 0；; 나< 시대; I++)
{
Resultnumber+= faciend.array [I] [m] * multiplier.array [n] [I];
}
Result. array[n][m]= 결과 번호;
}
}
}
Void 행렬:: copyToDeterminant (결정 요인& 목적지)
{
만약! = 열)
Throw "행렬의 행과 열 수가 같은 경우에만 행렬식에 복사할 수 있습니다. \ n”；
만약! =destination.getsideLenth ())
"결정 요인 크기가 행렬과 일치하지 않습니다. \ n";
Int I, j;
For(I = 0；; 나< 행; I++)
{
For(j = 0；; J & ltcolj++)
{
Destination.array [I] [j] = array [I] [j];
}
}
}
Void 행렬:: 운송 ()
{
만약! = 열)
"행렬의 행과 열 수가 같은 경우에만 반전 가능 \ n" 을 던집니다.
결정 요인 tmp determinant (row);
Copy to determinant (tmp determinant);
Doublevalue = tmpdeterminant.equal ();
다음 경우 (값 ==0)
{
Printf ("행렬식의 값은 %lf 이므로 행렬은 되돌릴 수 없습니다. \n", value);
반환;
}
Int I, j;
For(I = 0；; 나< 행; I++)
{
For(j = 0；; J & ltcolj++)
{
Array [j] [I] = tmpdeterminant.calcofactor (I, j)/value;
}
}
}
Void 행렬:: inverse ()
{
Int I, j;
For(I = 0；; 나 & ltcol-1; I++)// 세로좌표
{
For (j = I+1; 나< 행; I++)// 배너
{
Doubletmp = array [j] [I];
Array [j] [I] = array [I] [j];
Array [I] [j] = tmp;
}
}
}
Voidmatrix:: equal convers (int RS, int rd, int cs, double factor)//RS 는 시작 행 태그 ds, 대상 행 cs 및 시작 열입니다.
{
For(int I = cs；; 나< 행; I++)
{
Array[I][rd]-= array[I][RS]* 계수;
//printf(" array[% d][% d]=%. 2 lf ",I, rd, array [I] [rd]);
}
///printf(" \ n ")；);
}
Void matrix::exchangerow(int RS, int rd)
{
For(int I = 0；; 나< 행; I++)
{
이중 tmp
Tmp = 배열 [I] [RS];
배열 [I][RS]= 배열 [I] [rd];
Array [I] [rd] = tmp;
}
}
Void matrix::divideRow(int r, int cs, double factor)
{
For(int I = cs；; 나< 행; I++)
{
Array [I] [r]/= factor;
}
}
Int matrix::stairlize(int start, int end)
{
Int I, j;
이중 요소
Int R = 0；;
If (시작 < 0 | | end>= row | | start & gt 끝)
{
Cout & lt& lt "잘못된 수신 매개 변수"
0 을 반환합니다
}
For(I = start；; 나<= 끝; I++)// 는 배너입니다.
{
If(array[R][i]==0)
{
Int k；;
For (k = r+1; K & ltcolk++)
{
If (배열 [i][k])
{
Exchangerow(i, k) ：
깨뜨리다
}
}
If(k==col)
{
계속;
}
}
For(j = 0；; J & ltcolj++)
{
If (array [I] [j] & & ampj! =R)
{
계수 = 배열 [I] [j]/배열 [I] [r];
EqualConvers(R, j, I, factor) ：
}
}
R++；+;
}
For(I = 0；; 나<= R；; I++)
{
For(j = I；; J< 행; J++)
{
If(array[j][i])
{
DivideRow(i, j, array [j] [I]);
깨뜨리다
}
}
}
Return R；;
}
Void main ()
{
Cout & lt& lt "수행할 작업을 선택하십시오."
Cout & lt& lt" 1. 결정 요소 평가 "
Cout & lt& lt"2. 행렬 곱셈 "
Cout & lt& lt"3. 행렬의 역행렬 "
Cout & lt& lt"4. 행렬 변환 "
Cout & lt& lt"5. 단계 유형 "< & ltendl
Cout & lt& lt"0. 프로그램 종료 "
Int 선택;
그리고 (CIN>；; & gt 선택)
{
스위치 (선택)
{
사례 1:
{
Int 크기;
Cout & lt& lt "계산할 결정 요인의 차원을 입력하십시오."
CIN>；; & gt 크기;
결정 요인 JZ (크기);
Jz.setdeterminant ();
Printf ("이 결정 요인의 값은 %.2lf\n", jz.equal ());
깨뜨리다
}
사례 2:
{
Int RC, col, row//rc 는 행렬 a 의 행과 열의 최대값이고 col 은 행렬 a 의 열의 최대값이며 row 는 행렬 b 의 행의 최대값입니다.
Cout & lt& lt 행렬 a 행 및 행렬 b 열 수, 행렬 a 열 수 및 행렬 b 행 수의 최대값을 입력하십시오
CIN>；; & gtrc & gt& gtcol & gt& gt 행;
행렬 A(rc, col);
행렬 B(row, RC);
Cout & lt& lt "행렬 a 에 값을 지정하십시오."
A.setmatrix ();
Cout & lt& lt "행렬 b 에 값을 지정하십시오."
B. setmatrix ();
매트릭스 c;
곱셈 (c, a, b);
C.show ();
깨뜨리다
}
사례 3:
{
Int 크기;
Cout & lt& lt "사각형의 크기를 입력하십시오."
CIN>；; & gt 크기;
행렬 반전 (크기, 크기);
Inversing.setmatrix ();
Inversing.transportation ();
Inversing.show ();
깨뜨리다
}
시나리오 4:
{
Int 크기;
Cout & lt& lt "사각형의 크기를 입력하십시오."
CIN>；; & gt 크기;
행렬 반전 (크기, 크기);
Inversing.setmatrix ();
Inversing.inverse ();
Inversing.show ();
깨뜨리다
}
시나리오 5:
{
Int m, n, r;
Cout & lt& lt "행렬의 열 수와 행 수를 각각 입력하십시오."
CIN>；; & GTM>& gtn；;
행렬 반전 (m, n);
Inversing.setmatrix ();
R=inversing.stairlize(0, m-1);
Cout & lt& lt "행렬의 랭크는"
Inversing.show ();
깨뜨리다
}
시나리오 0:
종료 (0);
깨뜨리다
}
Cout & lt& lt "새 계산 유형 선택"
}
}
/*
다섯；오；5
5 4
1 -2 2-1 1
2 -4 8 0 2
-2 4-2 3
3 -6 0 -6 4
*/
- 관련 기사