Algorithms_in_C++  1.0.0
Set of algorithms implemented in C++.
lu_decompose.cpp File Reference

LU decomposition of a square matrix More...

#include <cassert>
#include <ctime>
#include <iomanip>
#include <iostream>
#include "./lu_decomposition.h"
Include dependency graph for lu_decompose.cpp:

Functions

template<typename T >
std::ostreamoperator<< (std::ostream &out, matrix< T > const &v)
 
void test1 ()
 
void test2 ()
 
int main (int argc, char **argv)
 

Detailed Description

LU decomposition of a square matrix

Author
Krishna Vedala

Function Documentation

◆ main()

int main ( int  argc,
char **  argv 
)

Main function

84  {
85  std::srand(std::time(NULL)); // random number initializer
86 
87  test1();
88  test2();
89  return 0;
90 }
Here is the call graph for this function:

◆ operator<<()

template<typename T >
std::ostream& operator<< ( std::ostream out,
matrix< T > const &  v 
)

operator to print a matrix

18  {
19  const int width = 10;
20  const char separator = ' ';
21 
22  for (size_t row = 0; row < v.size(); row++) {
23  for (size_t col = 0; col < v[row].size(); col++)
24  out << std::left << std::setw(width) << std::setfill(separator)
25  << v[row][col];
26  out << std::endl;
27  }
28 
29  return out;
30 }
Here is the call graph for this function:

◆ test1()

void test1 ( )

Test LU decomposition

Todo:
better ways to self-check a matrix output?
36  {
37  int mat_size = 3; // default matrix size
38  const int range = 50;
39  const int range2 = range >> 1;
40 
41  /* Create a square matrix with random values */
45  for (int i = 0; i < mat_size; i++) {
46  // calloc so that all valeus are '0' by default
47  for (int j = 0; j < mat_size; j++)
48  /* create random values in the limits [-range2, range-1] */
49  A[i][j] = static_cast<double>(std::rand() % range - range2);
50  }
51 
52  std::clock_t start_t = std::clock();
53  lu_decomposition(A, &L, &U);
54  std::clock_t end_t = std::clock();
55  std::cout << "Time taken: "
56  << static_cast<double>(end_t - start_t) / CLOCKS_PER_SEC << "\n";
57 
58  std::cout << "A = \n" << A << "\n";
59  std::cout << "L = \n" << L << "\n";
60  std::cout << "U = \n" << U << "\n";
61 }
Here is the call graph for this function:

◆ test2()

void test2 ( )

Test determinant computation using LU decomposition

66  {
67  std::cout << "Determinant test 1...";
68  matrix<int> A1({{1, 2, 3}, {4, 9, 6}, {7, 8, 9}});
69  assert(determinant_lu(A1) == -48);
70  std::cout << "passed\n";
71 
72  std::cout << "Determinant test 2...";
73  matrix<int> A2({{1, 2, 3}, {4, 5, 6}, {7, 8, 9}});
74  assert(determinant_lu(A2) == 0);
75  std::cout << "passed\n";
76 
77  std::cout << "Determinant test 3...";
78  matrix<float> A3({{1.2, 2.3, 3.4}, {4.5, 5.6, 6.7}, {7.8, 8.9, 9.0}});
79  assert(determinant_lu(A3) == 3.63);
80  std::cout << "passed\n";
81 }
Here is the call graph for this function:
std::srand
T srand(T... args)
mat_size
ll mat_size
Definition: matrix_exponentiation.cpp:45
std::clock_t
std::vector
STL class.
test2
void test2()
Definition: lu_decompose.cpp:66
std::vector::size
T size(T... args)
std::setfill
T setfill(T... args)
std::clock
T clock(T... args)
test1
void test1()
Definition: lu_decompose.cpp:36
std::cout
std::valarray< double >
std::rand
T rand(T... args)
lu_decomposition
int lu_decomposition(const matrix< T > &A, matrix< double > *L, matrix< double > *U)
Definition: lu_decomposition.h:29
std::endl
T endl(T... args)
std::left
T left(T... args)
determinant_lu
double determinant_lu(const matrix< T > &A)
Definition: lu_decomposition.h:90
std::time
T time(T... args)
std::setw
T setw(T... args)