int jacobi_method(double **A, double **R, int n)
{
int iterations = 0;
int k, l;
double eps = 1.0e-8;
double max_off = max_off_diag(A, &k, &l, n);
double max_number_iterations = (double) n * (double) n * (double) n;
while (max_off*max_off > eps && (double) iterations < max_number_iterations) {
rotate(A, R, k, l, n);
max_off = max_off_diag(A, &k, &l, n);
iterations++;
}
return iterations;
}
int main(int argc, char *argv[])
{
// if (length(argv)<3)
// {
// exit();
// }
// int N = atoi(argv[1]);
// double rho_max = atof(argv[2]);
int iterations = 0;
int max_iterations = 1000000; // Around 40 iterations gives the 3 lowest eigenvalues with 4 leading digits
int N = 200;
double eps = 1e-8;
//// Constants for length of the radius we are looking at
double rho_max = 5.0; // Max value, should be alittle above max V(rho), rhomax = sqrt(lambda_highest*2)
double rho_min = 0.0;
double h = (rho_max-rho_min)/(N+1);
//// Setting up A and R ////
double ** A = new double*[N]; // Pointer to pointer
double ** R = new double*[N];
for (int i = 0; i < N; i++)
{
A[i] = new double[N];
R[i] = new double[N];
}
//// Setting up V ////
double * V = new double[N];
for (int i = 1; i < N+1; i++)
{
V[i-1] = (i*h)*(i*h); // rho[i]**2
}
//// Giving A values ////
double h_marked = 1.0/(h*h);
for (int i = 0; i < N-1; i++)
{
A[i][i] = 2.0*h_marked + V[i];
A[i][i+1] = -h_marked;
A[i+1][i] = -h_marked;
}
A[N-1][N-1] = 2.0*h_marked + V[N-1];
//// Giving R values ////
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N; j++)
{
R[i][j] = 0.0;
}
R[i][i] = 1.0;
}
printMatlabMatrix(A,N);
// jacobis_method(A,R,N,&iterations, &max_iterations, eps);
//// setting up k,l element number ////
int k;
int l;
//// Running the algorithm ////
double maxoffdiag = max_off_diag(A, &k, &l, N);
while (maxoffdiag > eps && iterations < max_iterations)
{
maxoffdiag = max_off_diag(A, &k, &l, N);
rotate(A,R,k,l,N);
iterations++;
}
checkIterations(iterations,max_iterations);
//// Writing eigenvalues and eigenvectors to files
writeEigVal(A,N,rho_max,iterations);
writeEigVec(R,N);
//// Deallocation of memory ////
for (int i = 0; i < N; i++)
{
delete [] R[i];
delete [] A[i];
}
delete [] A;
delete [] R;
delete [] V;
}
int main(int argc, char *argv[])
{
// Retrieving constants from command line ======================================
int N = atoi(argv[1]); // Integration points/resolution
double rho_min = atof(argv[2]); // Start radius
double rho_max = atof(argv[3]); // End radius, should be alittle above max V(rho), rhomax = sqrt(lambda_highest*2)
double omega_r = atof(argv[4]); // Omega_r constant
int omega_index = atoi(argv[5]); // Omega index(for saving file)
std::string folder_path = argv[6]; // Folder path
// Setting up iteration limits =================================================
int iterations = 0;
int max_iterations = 1e7; // Around 40 iterations gives the 3 lowest eigenvalues with 4 leading digits
double eps = 1e-8;
// "Width" of integration point ================================================
double h = (rho_max-rho_min)/(N+1);
// Setting up A and R ==========================================================
double ** A = new double*[N]; // Pointer to pointer
double ** R = new double*[N];
for (int i = 0; i < N; i++)
{
A[i] = new double[N];
R[i] = new double[N];
}
// Setting up V ================================================================
double * V = new double[N];
for (int i = 1; i < N+1; i++)
{
V[i-1] = (i*h)*(i*h)*omega_r*omega_r + 1.0/(i*h);
}
// Giving A values =============================================================
double h_marked = 1.0/(h*h);
for (int i = 0; i < N-1; i++)
{
A[i][i] = 2.0*h_marked + V[i];
A[i][i+1] = -h_marked;
A[i+1][i] = -h_marked;
}
A[N-1][N-1] = 2.0*h_marked + V[N-1];
// Giving R values =============================================================
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N; j++)
{
R[i][j] = 0.0;
}
R[i][i] = 1.0;
}
// setting up k,l element number ===============================================
int k;
int l;
// Running the algorithm =======================================================
double maxoffdiag = max_off_diag(A, &k, &l, N);
while (maxoffdiag > eps && iterations < max_iterations)
{
rotate(A,R,k,l,N);
maxoffdiag = max_off_diag(A, &k, &l, N);
iterations++;
}
// Checking if we have exceeded our max iteration bound or not =================
checkIterations(iterations,max_iterations);
// Writing eigenvalues and eigenvectors to files ===============================
writeEigVal(A,N,rho_max,rho_min,iterations,eps,omega_r,omega_index,folder_path);
writeEigVec(R,N,omega_index,folder_path);
// Deallocation of memory ======================================================
for (int i = 0; i < N; i++)
{
delete [] R[i];
delete [] A[i];
}
delete [] A;
delete [] R;
delete [] V;
}
