(Fix) Added Homework

PROJECT REPORT MATRIX COMPUTATION I
[Added Homework]
Lecturer:
1. Prof. Edmond Chow
2. Prof. Tsung-Min Hwang
3. Prof. Matthew M. Lin
4. Prof. Weichung Wang
By:
1. Irfan Nurhidayat [60640035S]
2. Lee Chen Han [60640007S]
3. Shih Hsiang Ren [60640006S]
NATIONAL TAIWAN NORMAL UNIVERSITY

TAIPEI CITY
2017
PROJECT REPORT MATRIX COMPUTATION I
By
Irfan Nurhidayat, Lee Chen Han, and Shih Hsiang Ren
Tuesday, October 10, 2017

Department of Mathematics, National Taiwan Normal University
Contents:
Outline ……………………………… (2)
1. Dealing sparse matrix with MATLAB ……………………………… (3)
2. Inverse power method ……………………………… (15)
3. Solve linear system with LU and Cholesky ……………………………… (23)
References ……………………………… (40)
Irfan Nurhidayat, Lee Chen Han, and Shih Hsiang Ren (NTNU Students) Page 1
Outline
We downloaded data size 1000 – 10.000 from [1], then we choose Facebook (NIPS), US power
grid, Euroroad, Human Protein (Vidal), Protein, and U. Rovira i Virgili. In this report, we will
explain six difference data as (1) Dealing sparse matrix with MATLAB, (2) Inverse power
method, and (3) Solve linear system with LU and Cholesky.
In section (1), we only display to network information and then using MATLAB to plot a graph.
In section (2), we answered subsection (a) use all of the material from other references
concerning Inverse power method or Inverse iteration, for subsection (b), we added codes from
putty approaching copy and paste, we only change char flag = ‘D’; becoming char flag =
‘H’; later for subsection (c) there exists two problems, the first numerical results, we get the
results from putty, and the second for observations, we use SPSS14 to check normality data
using one sample Kolmogorov-Smirnov test and then seeing correlations between variable used,
we using Pearson test on a test of significance two-tailed. In section (3), we answered subsection
(a) use all of the material from other references concerning LU method and Cholesky method, for
subsection (b), we added codes from putty approaching copy and paste, and finally (c) we get
numerical results from putty, and also used SPSS14 to check normality data using one sample
Kolmogorov-Smirnov test and then seeing correlations between variable used, we using Pearson
test on a test of significance two-tailed.
We use a laptop ASUS with specification: Windows 7, Processor: Intel (R) Celeron (R) CPU
1007U@1.59GHz 1.50GHz, system type 32-bit Operating system, SPSS14, and also MATLAB
R2015a.
1. Dealing sparse matrix with MATLAB
In this section, we explain some remarks for Facebook (NIPS), US power grid, Euroroad,
Human Protein (Vidal), Protein, and U. Rovira i Virgili.
(a) Facebook (NIPS) (Graph of Laplacian)

This directed network contains Facebook user–user friendships. A node represents a user.
An edge indicates that the user represented by the left node is a friend of the user
represented by the right node [2].
Network info:
Name Facebook (NIPS)

Data size 2,888 vertices (users)
Format Undirected Unweighted
Volume 2,981 edges (friendships)
Nonzeros 8,850
Code and Elapsed time clear;
clc;
E = load('out.ego-facebook');
A = GraphAdjacency(E);
L = GraphLaplacian(A);
tic;
spy(L);
toc
title(['ego-facebook spy(L)']);
Elapsed time is 0.279204 seconds.
Plot:
(b) US power grid (Graph of Laplacian)
This undirected network contains information about the power grid of the Western States
of the United States of America. An edge represents a power supply line. A node is either
a generator, a transformation or a substation [3].
Network info:
Name US power grid

Data size 4,941 vertices (nodes)
Volume 6,594 edges (supplies)
Nonzeros 18,129
clc;
E = load('out.opsahl-powergrid');
tic;
spy(L);
toc
title(['opsahl-powergrid
spy(L)']);
Plot:
(c) Euroroad (Graph of Laplacian)
This is the international E-road network, a road network located mostly in Europe. The
network is undirected; nodes represent cities and an edge between two nodes denotes that
they are connected by an E-road [4].
Network info:
Name Euroroad
Data size 1,174 vertices (cities)
Volume 1,417 edges (roads)
Nonzeros 4,008
clc;
E =
load('out.subelj_euroroad_euroroad');
tic;
spy(L);
toc
title(['subelj_euroroad_euroroad
spy(L)']);
Plot:
(d) Human Protein (Vidal) (Graph of Laplacian)
This network represents an initial version of a proteome-scale map of Human binary
protein-protein interactions [5].
Network info:
Name Human Protein (Vidal)

Data size 3,133 vertices (proteins)
Volume 6,726 edges (interactions)
Nonzeros 15,321
clc;
E = load('out.maayan-vidal');
tic;
spy(L);
toc
title(['maayan-vidal spy(L)']);
Plot:
(e) Protein (Graph of Laplacian)
This undirected network contains protein interactions contained in yeast. Research
showed that proteins with a high degree were more important for the survival of the yeast
than others. A node represents a protein and an edge represents a metabolic interaction
between two proteins. The network contains loops [6].
Network info:
Name Protein
Data size 1,870 vertices (proteins)
Volume 2,277 edges/vertex
Nonzeros 6,252
clc;
E =
load('out.moreno_propro_propro');
tic;
spy(L);
toc
title(['moreno_propro_propro
spy(L)']);
Plot:
(f) U. Rovira i Virgili (Graph of Laplacian)
This is the email communication network at the University Rovira i Virgili in Tarragona
in the south of Catalonia in Spain. Nodes are users and each edge represents that at least
one email was sent. The direction of emails or the number of emails is not stored [7].
Network info:
Name U. Rovira i Virgili

Data size 1,133 vertices (users)
Volume 5,451 edges (communications)
Nonzeros 12,035
clc;
E = load('out.arenas-email');
tic;
spy(L);
toc
title(['arenas-email spy(L)']);
Plot:
2. Inverse Power Method
(a) Give an introduction about your problem. Which method will be used to solve this
problem, and describe the parameter setting if it has.
Answer:
 The Inverse Power Method or Inverse Iteration is a modification of the Power method
that gives faster convergence. It is used to determine the eigenvalue of A that is closest
to a specified number q. Suppose the matrix A has eigenvalues λ1 , … , λn with linearly
independent eigenvectors 𝐯 (1) , 𝐯 (2) , … , 𝐯 (n) . The eigenvalues of (A − qI)−1 where
q ≠ λi for i = 1,2, … , n, are
1 1 1
, ,…,
λ1 − q λ2 − q λn − q
with these same eigenvectors 𝐯 (1) , 𝐯 (2) , … , 𝐯 (n) . [8, p.583].

We will use inverse power method to find an approximation for the smallest
eigenvalue of A. Inverse power method can be also effectively employed to compute
the eigenvector associated with a given (approximate) eigenvalue. Inverse power
method is thus ideally suited for refining an initial estimate 𝜆 of an eigenvalue of A,
which can be obtained, for instance, by applying the localization techniques. The
inverse power method has the advantage that it can coverage to any desired eigenvalue
of A.
 The inverse power method consists of inverse power method with a fixed shift, inverse
power method with variant shifts, inverse power method with a relation with Newton
method, and inverse power method with Rayleigh quotient. In this section, we use the
inverse power method with a fixed shift.
 Compute 𝑎𝑖+1 = (A − qI)−1 𝑏𝑖 and 𝑐𝑖+1 = 𝑑(𝑎𝑖+1 ). Set 𝑏𝑖+1 = 𝑎𝑖+1 ⁄𝑐𝑖+1.
(b) Add your codes

Answer:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file sgp_main.cpp
/// @brief The main function.
///
/// @author William Liao
///
#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <iostream>
#include <iomanip>
#include <timer.hpp>
#include "sgp.hpp"
using namespace std;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief Main function for spectral graph partitioning.
///
int main( int argc, char** argv ){
int err_test;
// need at least 2 argument!

assert( argc >= 2 );
// check 2nd argument

assert( argv[1] != NULL );
// read file
int E_size_r, E_size_c, *E;
cout << "Read the graph data from file..............." << flush;
err_test = readGraph(argv[1], &E, &E_size_r, &E_size_c);
assert( err_test == 0 ); cout << " Done. " << endl;
cout << "Size of data is " << E_size_r << "x" << E_size_c << endl;
// set graph type

int type;
char flag1;
if ( argc == 2 )
{
type = setgraphtype(E_size_c);
}else if( argc == 3 ){
type = setgraphtype(argv[2], E_size_c);
}
if ( type == 0 )
{
flag1 = 'S';
cout << "type of graph: simple graph" << endl;
}else if( type == 1 ){
flag1 = 'D';
cout << "type of graph: directed (multi) graph" << endl;
}else if ( type == 2 ){
flag1 = 'W';
cout << "type of graph: directed weighted graph" << endl;
}else if ( type == 3 )
{
flag1 = 'U';
cout << "type of graph: undirected weighted graph" << endl;
}
// Construct adjacency matrix of graph

int nnz, *cooRowIndA, *cooColIndA, n;
double *cooValA;
cout << "Construct adjacency matrix of graph........." << flush;
err_test = GraphAdjacency(E, E_size_r, &nnz, &cooRowIndA, &cooColIndA,
&cooValA, &n, flag1);
cout << "size of matrix = " << n << endl;
cout << "nnz of A = " << nnz << endl;
// Construct Laplacian
int *csrRowIndA, *csrColIndA;
double *csrValA;
double shift_sigma = 0; // Modify shift_sigma to set the shift
cout << "Construct Laplacian matrix of graph........." << flush;
GraphLaplacian(&nnz, cooRowIndA, cooColIndA, cooValA, n, &csrRowIndA,
&csrColIndA, &csrValA, shift_sigma);
cout << " Done. " << endl;
cout << "nnz of L = " << nnz << endl;
// Shift to zero-based indexing

int tmp;
for (int i = 0; i < nnz; i++)
{
tmp = csrColIndA[i]-1;
csrColIndA[i] = tmp;
}
for (int i = 0; i < n+1; i++)
{
tmp = csrRowIndA[i]-1;
csrRowIndA[i] = tmp;
}
// Solve EVP
double mu0 = 0.6, mu; // Modify mu0 to change the initial
// guess of eigenvalue
double *x, timer;
x = new double[n];
char flag = 'H'; // Modify flag to choose solver on GPU
// or CPU. Possible options are
// 'H': solver on host (CPU)
// 'D': solver on device (GPU)
cout << "Solving Eigenvalue Problem.................." << flush;
switch (flag){
case 'H':
tic(&timer);
solveShiftEVPHost(n, nnz, csrValA, csrRowIndA, csrColIndA, mu0,
&mu, x);
cout << " Done. ";
toc(&timer);
break;
case 'D':
tic(&timer);
solveShiftEVP(n, nnz, csrValA, csrRowIndA, csrColIndA, mu0, &mu, x);
cout << " Done. ";
toc(&timer);
break;
}
cout << "The estimated eigenvalue near " << mu0 << " = ";
cout << fixed << setprecision(13) << mu << endl;
return 0;
}
(c) Numerical results and observations
Answer:
 Numerical results:
Facebook (NIPS)
tms17nla71@z-gotham:~/NLA17/hands_on$ ./sgp_main.out ego-facebook
Read the graph data from file............... Done.
Size of data is 2981x2
type of graph: simple graph
Construct adjacency matrix of graph......... Done.
size of matrix = 2888
nnz of A = 5962
Construct Laplacian matrix of graph......... Done.
nnz of L = 8850
Solving Eigenvalue Problem.................. Done. Elapsed time is 4.92705 seconds.
The estimated eigenvalue near 0.6 = 0.3059906953263
US power grid
tms17nla71@z-gotham:~/NLA17/hands_on$ ./sgp_main.out opsahl-powergrid
nnz of A = 13188
nnz of L = 18129
Euroroad
tms17nla71@z-gotham:~/NLA17/hands_on$ ./sgp_main.out subelj_euroroad_euroroad
nnz of A = 2834
nnz of L = 4008
Human Protein (Vidal)

tms17nla71@z-gotham:~/NLA17/hands_on$ ./sgp_main.out maayan-vidal
nnz of A = 13452
nnz of L = 16008
Protein
tms17nla71@z-gotham:~/NLA17/hands_on$ ./sgp_main.out moreno_propro_propro
nnz of A = 4554
nnz of L = 6350
U. Rovira i Virgili
tms17nla71@z-gotham:~/NLA17/hands_on$ ./sgp_main.out arenas-email
nnz of A = 10902
nnz of L = 12035
The above result can be represented properly via the following table:
Num. Data name Matrix size Estimated Eigenvalue Elapsed time (s)
1 Facebook (NIPS) 2888 0.6 = 0.3059906953263 4.92705
2 US power grid 4941 0.6 = 0.5995172358402 1.19833
3 Euroroad 1174 0.6 = 0.5559011188133 0.342537
4 Human Protein (Vidal) 3133 0.6 = 0.5766127932350 17.528
5 Protein 1870 0.6 = 0.5942596841620 3.11122
6 U. Rovira i Virgili 1133 0.6 = 0.6011546382331 0.587308
 Observations:
We use SPSS14 on a test of normality data for Estimated Eigenvalue and Elapsed time
then be used one sample Kolmogorov-Smirnov test. The following below the results:
NPar Tests
One-Sample Kolmogorov-Smirnov Test
Estimated_Eig
envalue
N 6
Mean .5389
Normal Parameters(a,b)
Std. Deviation .11539
Most Extreme Absolute .392
Differences Positive .295
Negative -.392
Kolmogorov-Smirnov Z .960
Asymp. Sig. (2-tailed) .315
a Test distribution is Normal.
b Calculated from data.
Elapsed_time
N 6
Mean 4.6157
Std. Deviation 6.56131
Negative -.257
Afterwards, we use SPSS14 on a test of correlations for Estimated Eigenvalue and Elapsed
time then be used correlation coefficients, Pearson, with a test of significance two-tailed,
and also we displayed descriptive statistics like mean and standard deviations. The
following below the results:
Correlations
Descriptive Statistics
Mean Std. Deviation N

Estimated_Eigenvalue .5389 .11539 6
Elapsed_time 4.6157 6.56131 6
Correlations
Estimated_Eig
envalue Elapsed_time
Estimated_Eigenvalue Pearson Correlation 1 -.053
Sig. (2-tailed) .921
N 6 6
Elapsed_time Pearson Correlation -.053 1
N 6 6
We have a conclusion that Estimated Eigenvalue and Elapsed time there exists a
correlation.
3. Solve linear system with LU and Cholesky
In this section, we will have explaining 2 kinds method that is LU Method and Cholesky
Method like below:
LU Method
Answer: See [8].
 If Gaussian elimination can be performed on the linear system 𝐴𝑥 = 𝑏 (Suppose size
of 𝐴 is n×n) without row interchanges, then the matrix 𝐴 can be factored into the
product of a lower-triangular matrix 𝐿 and an upper-triangular matrix 𝑈 , that is,
𝐴 = 𝐿𝑈. To solve 𝐴𝑥 = 𝑏, it is equivalent to solve 𝐿𝑈𝑥 = 𝑏. Then first, we let 𝑈𝑥 = 𝑦
and solving 𝐿𝑦 = 𝑏, we can solve this easily because 𝐿 is a lower-triangular matrix.
After we get y, second we have to solve 𝑈𝑥 = 𝑦 with this is also easy to solve because
𝑈 is an upper-triangular matrix.
 To turn 𝐴 into 𝐿𝑈, we consider the method that we used to change 𝐴 into row echelon
form, that is use row operation:
(𝐸𝑗 − 𝑚𝑗,𝑘 𝐸𝑘 ) → (𝐸𝑗 ), for 𝑗 = 𝑘 + 1, … , 𝑛.
and to use this operation on 𝐴, it is equivalent to multiplied a matrix 𝐿(𝑘) by the left
side of matrix 𝐴, which 𝐿(𝑘) is define by:
Then 𝐴 = 𝐿(1) 𝐿(2) … 𝐿(𝑛−3) 𝐿(𝑛−2) 𝐿(𝑛−1) 𝑈 = 𝐿𝑈.

 Set 𝐴 ∈ 𝑀𝑛×𝑛 and b ∈ ℝ𝑛 . Compute 𝐴 = 𝐿𝑈, and solve 𝐿𝑦 = 𝑏, 𝑈𝑥 = 𝑦.
(b) Add your codes
Answer:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
///
#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <iostream>
#include <iomanip>
#include "sgp.hpp"
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
int err_test;


// read file
// set graph type
int type;
char flag1;
if ( argc == 2 )
{
}
if ( type == 0 )
{
flag1 = 'S';
flag1 = 'D';
flag1 = 'W';
{
flag1 = 'U';
}

double *cooValA;
double *csrValA;
double shift_sigma = 1e-5; // Modify shift_sigma to set the
// shift

int tmp;
{
}
for (int i = 0; i < n+1; i++)
{
}
// Generate RHS
double *b;
b = new double[n];
genRHS(b, n, nnz, csrValA, csrRowIndA, csrColIndA);
// Solve LS
double *x, timer;
x = new double[n];
int solver = 0; // Modify solver to switch between

// different linear solvers. Possible
// options are
// 0: LU
// 1: Cholesky
// 2: QR
cout << "Solving Linear System......................." << flush;
switch (flag){
case 'H':
tic(&timer);
solvelsHost(n, nnz, csrValA, csrRowIndA, csrColIndA, b, x, solver);
cout << " Done. ";
toc(&timer);
break;
case 'D':
tic(&timer);
solvels(n, nnz, csrValA, csrRowIndA, csrColIndA, b, x, solver); cout << "
Done. ";
toc(&timer);
break;
}
// Compute redsidual
double res;
res = residual(n, nnz, csrValA, csrRowIndA, csrColIndA, b, x);
cout << "||Ax - b|| = " << res << endl;
return 0;
}

Answer:
Facebook (NIPS)
tms17nla70@z-gotham:~/NLA17/H03$ ./sgp_main_ls.out ego-facebook
nnz of A = 5962
nnz of L = 8850
Solving Linear System....................... Done. Elapsed time is 0.141535 seconds.
||Ax - b|| = 8.22781e-12
US power grid
tms17nla70@z-gotham:~/NLA17/H03$ ./sgp_main_ls.out opsahl-powergrid
nnz of A = 13188
nnz of L = 18129
||Ax - b|| = 4.06615e-14
Euroroad
tms17nla71@z-gotham:~/NLA17/H03$ ./sgp_main_ls.out subelj_euroroad_euroroad
nnz of A = 2834
nnz of L = 4008
||Ax - b|| = 1.63342e-14

tms17nla69@z-gotham:~/NLA17/H03$ ./sgp_main_ls.out maayan-vidal
nnz of A = 13452
nnz of L = 16008
||Ax - b|| = 0.00138355
Protein
tms17nla70@z-gotham:~/NLA17/H03$ ./sgp_main_ls.out moreno_propro_propro
nnz of A = 4554
nnz of L = 6350
||Ax - b|| = 0.00496796
U. Rovira i Virgili
tms17nla70@z-gotham:~/NLA17/H03$ ./sgp_main_ls.out arenas-email
nnz of A = 10902
nnz of L = 12035
||Ax - b|| = 4.02995e-13
Num. Data name Matrix size ‖Ax − b‖ Elapsed time (s)
1 Facebook (NIPS) 2888 8.22781e-12 0.141535
2 US power grid 4941 4.06615e-14 0.239474
3 Euroroad 1174 1.63342e-14 0.154559
4 Human Protein (Vidal) 3133 0.00138355 0.694007
5 Protein 1870 0.00496796 0.148069
6 U. Rovira i Virgili 1133 4.02995e-13 0.242995
 Observations:
Let ‖Ax − b‖ is called Norm, we use SPSS14 on a test of normality data for Norm and
Elapsed time then be used one sample Kolmogorov-Smirnov test. The following below
the results:
NPar Tests
Norm
N 6
Mean .0011
Negative -.298
Elapsed_time
N 6
Mean .2701
Negative -.273
Afterwards, we use SPSS14 on a test of correlations for Norm and Elapsed time then be
used correlation coefficients, Pearson, with a test of significance two-tailed, and also we
displayed descriptive statistics like mean and standard deviations. The following below
the results:
Correlations

Elapsed_time .2701 .21267 6
Norm .0011 .00199 6
Correlations
Elapsed_time Norm
Elapsed_time Pearson Correlation 1 -.009
N 6 6
Norm Pearson Correlation -.009 1
N 6 6
We have a conclusion that Norm and Elapsed time there exists a correlation.
Cholesky Method
Answer: See [8].
 If matrix 𝐴 is positive definite, then the matrix 𝐴 can be factored into the product of a
lower-triangular matrix 𝐿 and the transpose matrix of matrix 𝐿, denoted 𝐿𝑡 that is,
𝐴 = 𝐿𝐿𝑡 .
To solve 𝐴𝑥 = 𝑏, it is equivalent to solve 𝐿𝐿𝑡 𝑥 = 𝑏. Then first, we let 𝐿𝑡 𝑥 = 𝑦 and
solveing 𝐿𝑦 = 𝑏, we can solve this easily because 𝐿 is a lower-triangular matrix. After
we get y, second we have to solve 𝐿𝑡 𝑥 = 𝑦 with this is also easy to solve because 𝐿𝑡 is
an upper-triangular matrix.
 We found the lower-triangular matrix 𝐿 by following algorithm:
Suppose 𝐿 = (𝑙𝑖𝑗 )𝑛×𝑛 .
(1) Set 𝑙11 = √𝑎11
(2) For 𝑗 = 2,… , n, set 𝑙𝑗𝑖 = 𝑎𝑗1 /𝑙11
(3) For 𝑖 = 2, … , n-1 do (4) and (5)
2 1/2
(4) Set 𝑙𝑖𝑖 = (𝑎𝑖𝑖 − ∑𝑖−1
𝑘=1 𝑙𝑖𝑘 )
(5) For 𝑗 = 𝑖 + 1, … , 𝑛. Set 𝑙𝑗𝑖 = (𝑎𝑗𝑖 − ∑𝑖−1
𝑘=1 𝑙𝑗𝑘 𝑙𝑖𝑘 )/𝑙𝑖𝑖
2 1/2
(6) Set 𝑙𝑛𝑛 = (𝑎𝑛𝑛 − ∑𝑛−1
𝑘=1 𝑙𝑛𝑘 )
 Set 𝐴 ∈ 𝑀𝑛×𝑛 and b ∈ ℝ𝑛 . Compute 𝐴 = 𝐿𝐿𝑡 , and solve 𝐿𝑦 = 𝑏, 𝐿𝑡 𝑥 = 𝑦.
(b) Add your codes

Answer:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
///
#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <iostream>
#include <iomanip>
#include "sgp.hpp"
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
int err_test;


// read file
// set graph type

int type;
char flag1;
if ( argc == 2 )
{
}
if ( type == 0 )
{
flag1 = 'S';
flag1 = 'D';
flag1 = 'W';
{
flag1 = 'U';
}

double *cooValA;
double *csrValA;
double shift_sigma = 1e-5; // Modify shift_sigma to set the
// shift

int tmp;
{
}
for (int i = 0; i < n+1; i++)
{
}
// Generate RHS
double *b;
b = new double[n];
genRHS(b, n, nnz, csrValA, csrRowIndA, csrColIndA);
// Solve LS
double *x, timer;
x = new double[n];
int solver = 1; // Modify solver to switch between

// different linear solvers. Possible
// options are
// 0: LU
// 1: Cholesky
// 2: QR
cout << "Solving Linear System......................." << flush;
switch (flag){
case 'H':
tic(&timer);
solvelsHost(n, nnz, csrValA, csrRowIndA, csrColIndA, b, x, solver);
cout << " Done. ";
toc(&timer);
break;
case 'D':
tic(&timer);
solvels(n, nnz, csrValA, csrRowIndA, csrColIndA, b, x, solver); cout << "
Done. ";
toc(&timer);
break;
}
// Compute redsidual
double res;
res = residual(n, nnz, csrValA, csrRowIndA, csrColIndA, b, x);
cout << "||Ax - b|| = " << res << endl;
return 0;
}

Answer:
Facebook (NIPS)
tms17nla69@z-gotham:~/NLA17/H03$ ./sgp_main_ls.out ego-facebook
nnz of A = 5962
nnz of L = 8850
||Ax - b|| = 1.05751e-11
US power grid
tms17nla69@z-gotham:~/NLA17/H03$ ./sgp_main_ls.out opsahl-powergrid
nnz of A = 13188
nnz of L = 18129
||Ax - b|| = 7.89707e-14
Euroroad
tms17nla69@z-gotham:~/NLA17/H03$ ./sgp_main_ls.out subelj_euroroad_euroroad
nnz of A = 2834
nnz of L = 4008
||Ax - b|| = 2.85548e-14

tms17nla69@z-gotham:~/NLA17/H03$ ./sgp_main_ls.out maayan-vidal
nnz of A = 13452
nnz of L = 16008
||Ax - b|| = 0.00138355
Protein
tms17nla69@z-gotham:~/NLA17/H03$ ./sgp_main_ls.out moreno_propro_propro
nnz of A = 4554
nnz of L = 6350
||Ax - b|| = 0.00230557
U. Rovira i Virgili
tms17nla69@z-gotham:~/NLA17/H03$ ./sgp_main_ls.out URVirgili
nnz of A = 10902
nnz of L = 12035
||Ax - b|| = 5.4033e-13
Num. Data name Matrix size ‖Ax − b‖ Elapsed time (s)
1 Facebook (NIPS) 2888 1.05751e-11 0.282097
2 US power grid 4941 7.89707e-14 0.340004
3 Euroroad 1174 2.85548e-14 0.321828
4 Human Protein (Vidal) 3133 0.00138355 0.801672
5 Protein 1870 0.00230557 0.325734
6 U. Rovira i Virgili 1133 5.4033e-13 0.41268
 Observations:
Let ‖Ax − b‖ is called Norm, we use SPSS14 on a test of normality data for Norm and
Elapsed time then be used one sample Kolmogorov-Smirnov test. The following below
the results:
NPar Tests
Norm
N 6
Mean .0006
Negative -.269
Elapsed_time
N 6
Mean .4140
Negative -.249
Afterwards, we use SPSS14 on a test of correlations for Norm and Elapsed time then be
used correlation coefficients, Pearson, with a test of significance two-tailed, and also we
displayed descriptive statistics like mean and standard deviations. The following below
the results:
Correlations

Elapsed_time .4140 .19465 6
Norm .0006 .00100 6
Correlations
Elapsed_time Norm
Elapsed_time Pearson Correlation 1 .343
N 6 6
Norm Pearson Correlation .343 1
N 6 6
We have a conclusion that Norm and Elapsed time there exists a correlation.
REFERENCES
[1] http://konect.uni-koblenz.de/networks/
[2] http://konect.uni-koblenz.de/networks/ego-facebook
[3] http://konect.uni-koblenz.de/networks/opsahl-powergrid
[4] http://konect.uni-koblenz.de/networks/subelj_euroroad
[5] http://konect.uni-koblenz.de/networks/maayan-vidal
[6] http://konect.uni-koblenz.de/networks/moreno_propro
[7] http://konect.uni-koblenz.de/networks/arenas-email
[8] Burden, R.L., and Faires, J.D., (2011). Numerical Analysis. 9ed. Cengage Learning.

(Fix) Added Homework

Uploaded by

Copyright:

Available Formats

You might also like

(Fix) Added Homework

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

(Fix) Added Homework

Uploaded by

Copyright:

Available Formats

PROJECT REPORT MATRIX COMPUTATION I

NATIONAL TAIWAN NORMAL UNIVERSITY

Irfan Nurhidayat, Lee Chen Han, and Shih Hsiang Ren

Tuesday, October 10, 2017

(a) Facebook (NIPS) (Graph of Laplacian)

Name Facebook (NIPS)

Elapsed time is 0.279204 seconds.

Name US power grid

Elapsed time is 0.146274 seconds.

Elapsed time is 0.112663 seconds.

Name Human Protein (Vidal)

Elapsed time is 3.119617 seconds.

Elapsed time is 0.126463 seconds.

Name U. Rovira i Virgili

Elapsed time is 0.134533 seconds.

with these same eigenvectors 𝐯 (1) , 𝐯 (2) , … , 𝐯 (n) . [8, p.583].

(b) Add your codes

using namespace std;

// need at least 2 argument!

// check 2nd argument

// set graph type

// Construct adjacency matrix of graph

// Shift to zero-based indexing

cout << "Solving Eigenvalue Problem.................." << flush;

Human Protein (Vidal)

One-Sample Kolmogorov-Smirnov Test

Mean Std. Deviation N

Then 𝐴 = 𝐿(1) 𝐿(2) … 𝐿(𝑛−3) 𝐿(𝑛−2) 𝐿(𝑛−1) 𝑈 = 𝐿𝑈.

using namespace std;

// need at least 2 argument!

// check 2nd argument

// set graph type

// Construct adjacency matrix of graph

// Shift to zero-based indexing

int solver = 0; // Modify solver to switch between

cout << "Solving Linear System......................." << flush;

cout << "||Ax - b|| = " << res << endl;

(c) Numerical results and observations

Human Protein (Vidal)

One-Sample Kolmogorov-Smirnov Test

Mean Std. Deviation N

(b) Add your codes

// need at least 2 argument!

// check 2nd argument

// set graph type

// Construct adjacency matrix of graph

// Shift to zero-based indexing

int solver = 1; // Modify solver to switch between

cout << "Solving Linear System......................." << flush;

cout << "||Ax - b|| = " << res << endl;

(c) Numerical results and observations

Human Protein (Vidal)

Mean Std. Deviation N

You might also like