行列を処理するためのテスト コードを開発しています。コードでは、行列は、行列などを乗算するためのさまざまな関数を持つクラスによって定義されます。コンパイル時に予想される初期化子に関して問題が発生しました。この問題の正しい方向を教えていただけますか?
#include <iostream>
#include <math.h>
#include <iomanip>
#define Column_Spacing 10;
using namespace std;
class Matrix{
public:
void Output_Matrix(double **, int, int);
double** Zero_Matrix(int);
double** Input_Matrix(int);
void Calculate_Minor(double **, double **, int, int, int);
double Determinant (double **, int);
void Matrix_Inversion(double **, double **, int);
};
/*******************************************************************************
function: output matrix
This function is used to output a matrix of arbitrary size. It requires three
arguments: the matrix/matrix location, the number of rows in the matrix and the
number of columns in the matrix.
*******************************************************************************/
void Output_Matrix(double **Matrix, int Number_of_Rows, int Number_of_Columns){
int Rows_Output_Iterator = 0, Columns_Output_Iterator = 0;
while (Rows_Output_Iterator < Number_of_Rows){
while (Columns_Output_Iterator < Number_of_Columns){
cout << "/t" << Matrix [Rows_Output_Iterator][Columns_Output_Iterator];
Columns_Output_Iterator++;
}
cout << endl;
Columns_Output_Iterator = 0;
Rows_Output_Iterator++;
}
}
/*******************************************************************************
function: zero matrix
This function is used to create an arbitrary-sized matrix in which all of its
elements are zero.
*******************************************************************************/
double** Zero_Matrix(int Matrix_Order){
int Number_of_Rows_Zero, Number_of_Columns_Zero;
if (Matrix_Order > 0){
Number_of_Rows_Zero = Matrix_Order;
Number_of_Columns_Zero = Matrix_Order;
}
else{
cout << "Zero Matrix." << endl;
cout << "State the number of rows in the zero matrix: ";
cin >> Number_of_Rows_Zero;
cout << "State the number of columns in the zero matrix: ";
cin >> Number_of_Columns_Zero;
}
double **Zero_Matrix = new double*[Number_of_Rows_Zero];
for (int Zero_Matrix_Iterator = 0; Zero_Matrix_Iterator < Number_of_Rows_Zero; Zero_Matrix_Iterator++){
Zero_Matrix[Zero_Matrix_Iterator] = new double[Number_of_Columns_Zero];
}
for (int Row_Iterator = 0; Row_Iterator < Number_of_Rows_Zero; Row_Iterator++){
for (int Column_Iterator = 0; Column_Iterator < Number_of_Columns_Zero; Column_Iterator++){
Zero_Matrix[Row_Iterator][Column_Iterator] = 0;
}
}
return Zero_Matrix;
}
/*******************************************************************************
function: input matrix
This function is used to create an arbitrary-sized matrix defined by the used
and to fill it with arbitrary entries specified by the user.
*******************************************************************************/
double** Input_Matrix(int Matrix_Order){
int Number_of_Rows, Number_of_Columns;
double Entry;
cout << "Input Matrix A." << endl;
if (Matrix_Order > 0){
Number_of_Rows = Matrix_Order;
Number_of_Columns = Matrix_Order;
}
else{
cout << "State the number of rows in the matrix: ";
cin >> Number_of_Rows;
cout << "State the number of columns in the matrix: ";
cin >> Number_of_Columns;
}
double **Matrix_A = new double*[Number_of_Rows];
for (int Iterator = 0; Iterator < Number_of_Rows; Iterator++){
Matrix_A[Iterator] = new double[Number_of_Columns];
}
cout << "Entry ij" << endl;
for (int Row_Iterator = 0; Row_Iterator < Number_of_Rows; Row_Iterator++){
for (int Column_Iterator = 0; Column_Iterator < Number_of_Columns; Column_Iterator++){
cout << "Entry " << Row_Iterator << Column_Iterator << ": ";
cin >> Entry;
Matrix_A [Row_Iterator][Column_Iterator] = Entry;
}
}
cout << "Matrix A = " << endl;
Output_Matrix(Matrix_A, Number_of_Rows, Number_of_Columns);
return Matrix_A;
}
/*******************************************************************************
function: calculate minor
This function calculates the minor of an arbitrary input matrix. This function
requires five arguments: the input matrix, the minor (to store the output
value), the row number (which will be eliminated from the input matrix), the
column number which will be eliminated from the input matrix and the order of
the matrix respectively.
*******************************************************************************/
void Calculate_Minor(double **Matrix, double **Minor, int Row_Number, int Column_Number, int Matrix_Order){
int Row_Count = 0, Column_Count = 0;
for (int Row_Iterator = 0; Row_Iterator < Matrix_Order; Row_Iterator++){
if (Row_Iterator != Row_Number){
Column_Count = 0;
for(int Column_Iterator = 0; Column_Iterator < Matrix_Order; Column_Iterator++){
if (Column_Iterator != Column_Number){
Minor[Row_Count][Column_Count] = Matrix[Row_Iterator][Column_Iterator];
Column_Count++;
}
}
Row_Count++;
}
}
}
/*******************************************************************************
function: determinant
This function calculates the determinant of an arbitrary sized input matrix.
This function requires two arguments/inputs which are the input matrix and the
order of the matrix respectively. This function uses recursion i.e. the function
can, if necessary, be called again suppling the corresponding minors of the
original input matrix until the total determinant has been calculated. This
function requires the use of the function Calculate_Minor.
*******************************************************************************/
double Determinant (double **Matrix, int Matrix_Order){
double det = 0;
if (Matrix_Order == 1){
return Matrix[0][0];
}
double **Minor_Matrix = new double*[Matrix_Order - 1];
for (int Iterator = 0; Iterator < Matrix_Order - 1; Iterator++){
Minor_Matrix[Iterator] = new double[Matrix_Order - 1];
}
for (int Column_Iterator = 0; Column_Iterator <= (Matrix_Order - 1); Column_Iterator++){
Calculate_Minor(Matrix, Minor_Matrix, 0, Column_Iterator, Matrix_Order);
det += (Column_Iterator % 2 == 1?-1.0:1.0)*Matrix[0][Column_Iterator]*Determinant(Minor_Matrix, Matrix_Order - 1);
//det += pow(-1, Iterator_2)*Matrix[0][Iterator_2]*Determinant(Minor, Matrix_Size - 1);
}
for (int Iterator = 0; Iterator < (Matrix_Order - 1); Iterator++){
delete [] Minor_Matrix[Iterator];
}
delete [] Minor_Matrix;
//cout << "det = " << det << endl;
return det;
}
/*******************************************************************************
function: matrix inversion
This function calculates the inverse of an arbitrary input matrix. This function
requires three arguments/inputs which are the input matrix, the cofactor matrix
(somewhere to store the cumulative output of this function for example a matrix
whose entries are all zero) and the order of the matrix respectively. This
function uses the determinant function and the Calculate_Minor function.
*******************************************************************************/
void Matrix_Inversion(double **Matrix, double **Cofactor_Matrix, int Matrix_Order){
if (Determinant(Matrix, Matrix_Order) == 0){
cout << "The matrix is singular i.e. det(A) = 0 hence, no inverse matrix (A^-1) exists." << endl;
}
else{
double Coefficient = 1/(Determinant(Matrix, Matrix_Order));
double *Temporary = new double[(Matrix_Order - 1)*(Matrix_Order - 1)];
double **Minor = new double*[Matrix_Order - 1];
for (int Iterator = 0; Iterator < (Matrix_Order - 1); Iterator++){
Minor[Iterator] = Temporary + (Iterator*(Matrix_Order - 1));
}
for (int Row_Iterator = 0; Row_Iterator < Matrix_Order; Row_Iterator++){
for (int Column_Iterator = 0; Column_Iterator < Matrix_Order; Column_Iterator++){
Calculate_Minor(Matrix, Minor, Row_Iterator, Column_Iterator, Matrix_Order);
Cofactor_Matrix[Row_Iterator][Column_Iterator] = Determinant(Minor, Matrix_Order - 1);
if ((Row_Iterator + Column_Iterator)%2 == 1){
Cofactor_Matrix[Row_Iterator][Column_Iterator] = -Cofactor_Matrix[Row_Iterator][Column_Iterator];
}
}
}
double **Cofactor_Transpose = new double*[Matrix_Order];
for (int Iterator = 0; Iterator < Matrix_Order; Iterator++){
Cofactor_Transpose[Iterator] = new double[Matrix_Order];
}
for (int Row_Iterator = 0; Row_Iterator < Matrix_Order; Row_Iterator++){
for (int Column_Iterator = 0; Column_Iterator < Matrix_Order; Column_Iterator++){
Cofactor_Transpose[Column_Iterator][Row_Iterator] = Cofactor_Matrix[Row_Iterator][Column_Iterator];
}
}
double **Inverse_Matrix = new double*[Matrix_Order];
for (int Iterator = 0; Iterator < Matrix_Order; Iterator++){
Inverse_Matrix[Iterator] = new double[Matrix_Order];
}
for (int Row_Iterator = 0; Row_Iterator < Matrix_Order; Row_Iterator++){
for (int Column_Iterator = 0; Column_Iterator < Matrix_Order; Column_Iterator++){
Inverse_Matrix[Column_Iterator][Row_Iterator] = Coefficient*Cofactor_Matrix[Row_Iterator][Column_Iterator];
}
}
cout << "(Inverse Matrix) A^-1 = " << Coefficient << endl;
Output_Matrix(Cofactor_Transpose, Matrix_Order, Matrix_Order);
cout << "= " << endl;
Output_Matrix(Inverse_Matrix, Matrix_Order, Matrix_Order);
delete [] Temporary;
delete [] Minor;
delete [] Cofactor_Transpose;
delete [] Inverse_Matrix;
}
}
int main(){
int Matrix_Order = 0;
cout << "Define the order of the input matrix (... if the input matrix is square - if not, set this variable to zero): ";
cin >> Matrix_Order;
Matrix Matrix_A, Cofactor_Matrix, determinant, Matrix_Inverse;
double **Matrix_A.Input_Matrix(Matrix_Order);
/*
double **Cofactor_Matrix.Zero_Matrix(Matrix_Order);
double det = determinant.Determinant(Matrix_A, Matrix_Order);
cout << "(Determinant) det = " << det << endl;
Matrix_Inverse.Matrix_Inversion(Matrix_A, Cofactor_Matrix, Matrix_Order);
*/
return 0;
}