Họ và tên: Nguyễn Quang Trường

MSSV: 102220173
Lớp: 22T_DT3
Đề số 1
Câu 1:
X = 2mod 5, X = 3mod 7, X = 4mod 9, X = 5mod 11, X = 6mod 13

#include <iostream>
#include <vector>
#include <cmath>
#include <iomanip>
using namespace std;
//Chinest
vector<int> p;
vector<int> anpha;

int UCLN_C1(int a, int b) {

while ( a != b) {
if (a > b)
a = a - b;
else
b = b - a;
}
return a;
}

bool checkBack (int y, int x, int k, int m) {

if (k * m + 1 == x * y) return true;
else return false;
}
int ModuleInverse(int x, int m) {
int count = 0;
while (true) {
int temp = (int)(1.0 * (m*count + 1)/x);
if (checkBack(temp, x, count, m)) {
return temp;
}
else count++;
}
}

vector<int> arrayA;
vector<int> arrayM;

void init() {
int level;
cout << "So phuong trinh = "; cin >> level;
int count = 0;
while (count < level) {
int a1, m1;
cout << "Nhap he so phuong trinh " << (count + 1) << ":" << endl;
cout << " a" << (count + 1) << " = "; cin >> a1;
cout << " m" << (count + 1) << " = "; cin >> m1;
arrayA.push_back(a1);
arrayM.push_back(m1);
count++;
}
}

bool checkCondition() {
for (int i = 0; i < arrayM.size(); i++) {
int temp = arrayM[i];
for (int j = 0; j < arrayM.size(); j++) {
if (i == j) continue;
if (UCLN_C1(temp, arrayM[j]) == 1) continue;
else return false;
}
}
return true;
}

void ChineseRemainder() {
vector<int> res_nhan;
vector<int> mod;
if (checkCondition()) {
int M = 1;
int final = 0;
for (int i = 0; i < arrayM.size(); i++) {
int mul = 1;
for (int j = 0; j < arrayM.size(); j++) {
if (i != j) mul *= arrayM[j];
}
res_nhan.push_back(mul);
mod.push_back(ModuleInverse(mul, arrayM[i]));
final += (arrayA[i]*mul*mod[i]);
M *= arrayM[i];
}
cout << "Mot nghiem cua x la: x = " << final << endl;
 cout << "Ho nghiem cua x la: x = " << (final%M) << " + k*" << M <<
" (k thuoc N)" << endl;
}
}

int main() {
cout << "\n\n(*)Cau 1: Giai he phuong trinh dong du:\n";
init();
ChineseRemainder();
}

Câu 2:
Ma trận: (-10 4 7)
( 4 -5 8 )
( 7 8 -9)

Câu a: LDLT
#include <iostream>
#include <iomanip>
#include <cmath>
#include <cstring>
using namespace std;
//LDLT (cholesky biến thể)
void LDLT(double a[100][100], int n) {
double lower[100][100];
memset(lower, 0, sizeof(lower));

double d[100] = {0};

for (int i = 0; i < n; i++) {

lower[i][i] = 1;
for (int j = 0; j <= i; j++) {
double sum = 0;
if (i == j) {
for (int k = 0; k < j; k++) {
sum += lower[j][k] * lower[j][k] * d[k];
}
d[j] = a[j][j] - sum;
} else {
for (int k = 0; k < j; k++) {
sum += lower[i][k] * lower[j][k] * d[k];
}
lower[i][j] = (a[i][j] - sum) / d[j];
}
}
}

cout << "\nMa tran L:\n";

for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << setw(10) << lower[i][j];
}
cout << endl;
}

cout << "\nMa tran D:\n";

for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j)
cout << setw(10) << d[i];
else
cout << setw(10) << 0;
}
cout << endl;
}

cout << "\nMa tran L^T:\n";

for (int i = 0; i < n; i++) {
 for (int j = 0; j < n; j++) {
cout << setw(10) << lower[j][i];
}
cout << endl;
}

double temp[100][100] = {0};

double reconstructed[100][100] = {0};

for (int i = 0; i < n; i++) {

for (int j = 0; j <= i; j++) {
temp[i][j] = lower[i][j] * d[j];
}
}

for (int i = 0; i < n; i++) {

for (int j = 0; j < n; j++) {
for (int k = 0; k <= min(i, j); k++) {
reconstructed[i][j] += temp[i][k] * lower[j][k];
}
}
}

cout << "\nMa tran A ( L * D * L^T):\n";

for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cout << setw(10) << reconstructed[i][j];
}
cout << endl;
}
}

int main() {
int n = 3;
double a[100][100] = {
{-10, 4, 7},
{4, -5, 8},
{7, 8, -9}
};

LDLT(a, n);

return 0;
}
Câu b: Chéo hóa

#include <iostream>
#include <Eigen/Dense>
#include <vector>
using namespace std;

double a[100][100];
double P[100][100];
double D[100][100];
double P_Inverse[100][100];

void nhanMaTran(double p[][100], double q[][100], int m, int l, int n, double

res[][100]){
for(int i = 0 ; i < m ; i++){
for(int j = 0 ; j < n ; j++){
res[i][j] = 0;
for(int k = 0 ; k < l ; k++){
res[i][j] += p[i][k] * q[k][j];
}
}
 }
}

void subMatrix(double a[100][100], int n, int x, int y, double submatrix[100]

[100]){

int subi = 0;
for(int i = 0 ; i < n ; i++){
int subj = 0;
if(i == y) continue;
for(int j = 0 ; j < n ; j++){
if(j == x) continue;
submatrix[subi][subj] = a[i][j];
subj++;
}
subi++;
}
}
double determinant(double a[][100], int n) {
double det = 1.0;
for (int i = 0; i < n; i++) {
int pivot = i;
for (int j = i + 1; j < n; j++) {
if (abs(a[j][i]) > abs(a[pivot][i])) {
pivot = j;
}
}
if (pivot != i) {
swap(a[i], a[pivot]);
det *= -1;
}
if (a[i][i] == 0) {
return 0;
}
det *= a[i][i];
for (int j = i + 1; j < n; j++) {
double factor = a[j][i] / a[i][i];
for (int k = i + 1; k < n; k++) {
a[j][k] -= factor * a[i][k];
}
}
}
return det;
}

int main() {
 int n; cin >> n;

for(int i = 0 ; i < n ; i++){

for(int j = 0 ; j < n ; j++) cin >> a[i][j];
}

Eigen::MatrixXd A(n, n);

for (int i = 0; i < n; ++i) {

for (int j = 0; j < n; ++j) {
A(i, j) = a[i][j];
}
}

Eigen::EigenSolver<Eigen::MatrixXd> es(A);

std::vector<double> eigenvalues;
for (int i = 0; i < es.eigenvalues().size(); ++i) {
eigenvalues.push_back(abs(es.eigenvalues()[i].real()) < 1e-4 ? 0 :
es.eigenvalues()[i].real());
}

std::vector<std::vector<double> > eigenvectors;

for (int i = 0; i < es.eigenvectors().cols(); ++i) {
std::vector<double> vec;
for (int j = 0; j < es.eigenvectors().rows(); ++j) {
vec.push_back(abs(es.eigenvectors()(j, i).real()) < 1e-4 ? 0 :
es.eigenvectors()(j, i).real());
}
eigenvectors.push_back(vec);
}

for(int i = 0 ; i < eigenvalues.size() ; i++){

D[i][i] = (eigenvalues[i]);
}

for(int i = 0 ; i < n ; i++){

for(int j = 0 ; j < n; j++){
P[i][j] = eigenvectors[j][i];
}
}

cout << "P:\n";

for(int i = 0 ; i < n ; i++){
for(int j = 0 ; j < n ; j++) cout << P[i][j] << " ";
 cout << endl;
}

cout << "D:\n";

for(int i = 0 ; i < n ; i++){
for(int j = 0 ; j < n ; j++) cout << D[i][j] << " ";
cout << endl;
}

cout << "P-1:\n";

for(int i = 0 ; i < n ; i++){

for(int j = 0 ; j < n ; j++){
double submatrix[100][100];
subMatrix(P, n, j, i, submatrix);
double det = determinant(submatrix, n - 1);
P_Inverse[i][j] = pow(-1, i + j) * det;
}
}

double det = determinant(P, n);

if(det == 0){
cout << "Khong the nghich dao ma tran";
return 0;
}

for(int i = 0 ; i < n ; i++){

for(int j = 0 ; j < n ; j++){
P_Inverse[j][i] /= det;
cout << P_Inverse[j][i] << " ";
}
cout << endl;
}

return 0;
}
Câu 3: SVD
Ma trận: ( 0 5 10 )
(5 5 5)
(10 10 10)

#include <iostream>
#include <vector>
#include <cmath>
#include <iomanip>
#include<Eigen/Dense>
#define MAX 100000
#define TOL 1.0e-5
using namespace std;
using Eigen::MatrixXd;
using Eigen::VectorXd;

//Chéo hóa và SVD

//g++ -std=c++11 -I /opt/homebrew/opt/eigen/include/eigen3 Cau2.cpp -o
cau2.exe

double a[100][100];
double P[100][100];
double D[100][100];
double P_Inverse[100][100];

void nhanMaTran(double p[][100], double q[][100], int m, int l, int n, double

res[][100]){
for(int i = 0 ; i < m ; i++){
for(int j = 0 ; j < n ; j++){
res[i][j] = 0;
for(int k = 0 ; k < l ; k++){
res[i][j] += p[i][k] * q[k][j];
}
}
}
}

void subMatrix(double a[100][100], int n, int x, int y, double submatrix[100]

[100]){
int subi = 0;
for(int i = 0 ; i < n ; i++){
int subj = 0;
if(i == y) continue;
for(int j = 0 ; j < n ; j++){
if(j == x) continue;
submatrix[subi][subj] = a[i][j];
subj++;
}
subi++;
}
}

double determinant(double a[][100], int n) {

double det = 1.0;
for (int i = 0; i < n; i++) {
int pivot = i;
for (int j = i + 1; j < n; j++) {
if (abs(a[j][i]) > abs(a[pivot][i])) {
pivot = j;
}
}
if (pivot != i) {
swap(a[i], a[pivot]);
 det *= -1;
}
if (a[i][i] == 0) {
return 0;
}
det *= a[i][i];
for (int j = i + 1; j < n; j++) {
double factor = a[j][i] / a[i][i];
for (int k = i + 1; k < n; k++) {
a[j][k] -= factor * a[i][k];
}
}
}
return det;
}

bool checkNormalized(const VectorXd& vector) {

for (int i = 0; i < vector.size(); i++) {
if (vector(i) > 1) {
return false;
}
}
return true;
}

void normalized(VectorXd& vector) {

if (!checkNormalized(vector)) {
double h = 0;
for (int i = 0; i < vector.size(); i++) {
h += pow(vector(i), 2);
}
for (int i = 0; i < vector.size(); i++) {
vector(i) = vector(i) / h;
}
}
}

VectorXd gramSchmidtOrthogonalize(const Eigen::MatrixXd& U,

const Eigen::VectorXd& vec, int currentCol) {
Eigen::VectorXd orthogonalVec = vec;

for (int i = 0; i < currentCol; ++i) {

orthogonalVec -= (U.col(i).dot(vec)) * U.col(i);
}

normalized(orthogonalVec);
 return orthogonalVec;
}

MatrixXd emptyMatrix(const int& row, const int& col) {

MatrixXd result(row, col);
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++)
result(i, j) = 0;
}
return result;
}

VectorXd emptyVector(const int& size) {

VectorXd result(size);
for (int i = 0; i < size; i++) {
result(i) = 0;
}
return result;
}

MatrixXd findT(const MatrixXd &matrix, const int& row, const int& col) {
MatrixXd result(col, row);
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++)
result(j, i) = matrix(i, j);
}
return result;
}

MatrixXd multipleMatrix(const MatrixXd &a, const MatrixXd &b, const int&

rowA,
const int& colA, const int& colB) {
MatrixXd result = emptyMatrix(rowA, colB);
for (int i = 0; i < rowA; i++) {
for (int j = 0; j < colB; j++) {
for (int k = 0; k < colA; k++) {
result(i, j) += a(i, k) * b(k, j);
}
}
}
return result;
}

MatrixXd findS(const MatrixXd &matrix, const int& row, const int& col) {
MatrixXd matrixT = findT(matrix, row, col);
return multipleMatrix(matrixT, matrix, col, row, col);
}

void orderEigen(VectorXd& eigenValues, MatrixXd& eigenVectors) {

int size = eigenValues.size();
for (int i = 0; i < size - 1; i++) {
double max = eigenValues(i);
int index = i;
for (int j = i + 1; j < size; j++) {
if (max < eigenValues(j)) {
index = j;
max = eigenValues(j);
}
}
if (index != i) {
double tmp = eigenValues(i);
eigenValues(i) = max;
eigenValues(index) = tmp;
eigenVectors.col(i).swap(eigenVectors.col(index));
}
}
}

void solveSVD(const MatrixXd& matrix, const int& row, const int& col) {
MatrixXd S = findS(matrix, row, col);
Eigen::EigenSolver<Eigen::MatrixXd> solver(S);
if (solver.info() != Eigen::Success) {
std::cerr << "Khong the tinh eigenvalue." << std::endl;
return;
}
VectorXd eigenValues = solver.eigenvalues().real();
MatrixXd eigenVectors = solver.eigenvectors().real();
orderEigen(eigenValues, eigenVectors);

vector<double> eigenRealValues;
int count = 0;
int size = eigenValues.size();
for (int i = 0; i < size; i++) {
double eigenValue = eigenValues(i);
if (eigenValue > TOL) {
eigenRealValues.push_back(sqrt(eigenValue));
} else {
break;
}
}

MatrixXd VT = findT(eigenVectors, col, col);

MatrixXd M = emptyMatrix(row, col);
for (int i = 0; i < eigenRealValues.size(); i++) {
M(i, i) = eigenRealValues[i];
}

int dem = 0;
if (row < col) dem = row;
else dem = col;

MatrixXd U = emptyMatrix(row, row);

int t = eigenRealValues.size();
for (int i = 0; i < t; i++) {
U.col(i) = (1.0 / eigenRealValues[i]) * matrix * eigenVectors.col(i);
}

if (row == 2) {
if (t == 1) {
Eigen::VectorXd vec = Eigen::VectorXd::Random(row);
U.col(1) = gramSchmidtOrthogonalize(U, vec, 1);
}
}

if (row == 3)
{
while (t < 3) {
if (t == 2) {
Eigen::VectorXd vec = Eigen::VectorXd::Random(row);
U.col(2) = gramSchmidtOrthogonalize(U, vec, 2);
}
if (t == 1) {
Eigen::VectorXd u0 = U.col(0);
Eigen::VectorXd u1(3);
if (u0[0] * u0[1] * u0[2] != 0) {
u1[0] = u0[1];
u1[1] = - u0[0];
u1[2] = 0;
U.col(1) = u1.normalized();
Eigen::VectorXd vec1 = Eigen::VectorXd::Random(row);
U.col(2) = gramSchmidtOrthogonalize(U, vec1, 2);
} else {
if (u0[0] == 0) {
u1[0] = 0;
u1[1] = u0[2];
u1[2] = -u0[1];
}
if (u0[1] == 0)
 {
u1[1] = 0;
u1[0] = u0[2];
u1[2] = -u0[0];

}
if (u0[2] == 0)
{
u1[2] = 0;
u1[0] = u0[1];
u1[1] = -u0[0];

}
U.col(1) = u1.normalized();
Eigen::VectorXd vec2 = Eigen::VectorXd::Random(row);
U.col(2) = gramSchmidtOrthogonalize(U, vec2, 2);
}
}
t++;
}
}
if (row >=4)
{
for (int i = t; i < row; ++i) {
Eigen::VectorXd vec = Eigen::VectorXd::Random(row);
U.col(i) = gramSchmidtOrthogonalize(U, vec, i);
}
}

for (int i = 0; i < U.rows(); ++i) {

for (int j = 0; j < U.cols(); ++j) {
if (abs(U(i, j)) < TOL) {
U(i, j) = 0;
}
}
}

for (int i = 0; i < col; i++) {

for (int j = 0; j < col; j++) {
if (abs(VT(i, j)) < TOL) {
VT(i, j) = 0;
}
}
}

cout << "\nU:\n" << U << endl;

 cout << "\nSigma:\n" << M << endl;
cout << "\nVt:\n" << VT << endl;
}

int main() {
int row = 3, col = 3;
MatrixXd matrix(3, 3);
matrix(0, 0) = 0; matrix(0, 1) = 5; matrix(0, 2) = 10;
matrix(1, 0) = 5; matrix(1, 1) = 5; matrix(1, 2) = 5;
matrix(2, 0) = 10; matrix(2, 1) = 10; matrix(2, 2) = 10;
cout << "Matrix: " << endl;
cout << matrix << endl;
cout << "\nBai 3: " << endl;
solveSVD(matrix, 3, 3);
}