Diffusion Eigenvalue Problems (master) Browse

eigpro/Matrix.h
a0a6218630c7master

Matrix.h
View Options



			#ifndef EIGENVALUE_MATRIX_H
			#define EIGENVALUE_MATRIX_H

			#include <string>
			#include <iostream>

			using namespace std;

			//! The Matrix class
			/*!
			The "Matrix" class is meant to perform different kinds of operations on a data structure representing a square matrix.
			Specifically, it provides the following implementations of numerical methods for eigenvalue computation:
			- Power and Inverse power method;
			- Implementation of Power and Inverse power methods with shift.
			*/
			class Matrix {

			private:

			//! A private integer variable called size
			/*!
			An integer value representing the row and the column dimension of a square matrix
			*/
			int size;

			//! A private pointer to a pointer of double variables called matrix
			/*!
			A pointer to a pointer of double values; each double value represents the content of cell of a square matrix
			*/
			double** matrix;

			//! A private double variable called shift_amount
			/*!
			A double value representing the shift amount
			to adopt when executing the Power and Inverse power methods with shift
			*/
			double shift_amount;

			public:

			//! A constructor
			/*!
			The constructor initializes the content of the square matrix by reading size*size values from a text file
			\param filename a string representing the name of the input text file
			*/
			Matrix (string filename);

			//! A destructor
			/*!
			The destructor deletes the square matrix
			*/
			~Matrix();

			//! A public member printing the content of the square matrix
			/*!
			\param matrix the square matrix
			\param size the row and the column dimension of the square matrix
			\return void
			*/
			void printMatrix(double** matrix, int size);

			//! A public member for eigenvalue computation based either on the Power method or on the Power method with shift (if shift is provided in the input file)
			/*!
			\param m the square matrix
			\param size the row and the column dimension of the square matrix
			\param tol the accepted tolerance adopted in the eigenvalue computation
			\param shift_amount the shift amount adopted in the Power method with shift
			\return a double value representing the eigenvalue
			*/
			double powerMethod(double** m, int size, double tol, double shift_amount);

			//! A public member for eigenvalue computation based either on the Inverse Power method or on the Inverse Power method with shift (if shift is provided)
			/*!
			\param matrix the square matrix
			\param size the row and the column dimension of the square matrix
			\param tol the accepted tolerance adopted in the eigenvalue computation
			\param shift_amount the shift amount adopted in the Power method with shift
			\return a double value representing the eigenvalue
			*/
			double inversePowerMethod(double** matrix, int size, double tol, double shift_amount);

			//! A getter method that returns the shift_amount variable
			double get_shift_amount();

			//! A getter method that returns the matrix variable
			double** get_matrix();

			//! A getter method that returns the size variable
			int get_size();

			//! A public member that computes the PA=LU decomposition
			/*!
			\param A the square matrix with size N;
			Matrix A is modified, containing both matrices L-E and U as A=(L-E)+U such that PA=LU
			\param Tol a small tolerance number to detect failure when the matrix is near degenerate
			\param N the size of the square matrix
			\param P an integer vector P of size N+1
			\return 0 if the method failed, 1 if the method succeeded
			*/
			int LUPDecompose(double *A, int N, double Tol, int P);

			//! A public member that solves the equation A*x=b
			/*!
			\param A the matrix filled in LUPDecompose
			\param P the array filled in LUPDecompose
			\param b a known array of double values
			\param N the size of the square matrix
			\param x the solution vector of A*x=b
			\return void
			*/
			void LUPSolve(double *A, int P, double b, int N, double x);

			//! A public member that computes the A-shift_amount*I matrix
			/*!
			\param A a matrix filled in LUPDecompose
			\param size the size of the square matrix
			\param shift the shift amount
			\return the output matrix (A-shift_amount*I)
			*/
			double shift(double A, int size, double shift);
			//! A public member that runs the tests
			int test(int i);

			private:

			//! A public member that computes the Euclidean norm of a vector
			/*!
			\param u the input array
			\param size the size of the array
			\return a double value representing the Euclidean norm
			*/
			double l2_norm(double *u, int size);

			//! A public member that computes the infinity norm of a vector
			/*!
			\param u the input array
			\param size the size of the array
			\return a double value representing the infinity norm
			*/
			double linf_norm(double *u, int size);
			};

			#endif //EIGENVALUE_MATRIX_H

eigpro/Matrix.ha0a6218630c7master

Matrix.hView Options

eigpro/Matrix.h
a0a6218630c7master

Matrix.h
View Options