I was trying to knit following code to Pdf (knit without code is working well)

But i got following error

ERROR

processing file: pdf-test.Rmd

output file: pdf-test.knit.md

"C:/RStudio/resources/app/bin/quarto/bin/tools/pandoc" +RTS -K512m -RTS pdf-test.knit.md --to latex --from markdown+autolink_bare_uris+tex_math_single_backslash --output pdf-test.tex --lua-filter "C:\Users\Sava\AppData\Local\R\win-library\4.3\rmarkdown\rmarkdown\lua\pagebreak.lua" --lua-filter "C:\Users\Sava\AppData\Local\R\win-library\4.3\rmarkdown\rmarkdown\lua\latex-div.lua" --embed-resources --standalone --highlight-style tango --pdf-engine pdflatex --variable graphics --variable "geometry:margin=1in"

! Illegal parameter number in definition of \GetTitleStringResult.

Error: LaTeX failed to compile pdf-test.tex. See The R package tinytex - Helper Functions to Manage TinyTeX, and Compile LaTeX Documents - Yihui Xie | 谢益辉 for debugging tips. See pdf-test.log for more info.

Execution halted

## CODE

## title: "NEWTEST2"

output: pdf_document

date: "2023-11-21"

```
knitr::opts_chunk$set(echo = TRUE)
```

```
library(microbenchmark)
```

#AUFGABE 25 A

```
create_hilbert_matrix <- function(n) {
hilbert_matrix <- matrix(NA, nrow = n, ncol = n)
for (i in 1:n) {
for (j in 1:n) {
hilbert_matrix[i, j] <- 1 / (i + j - 1)
}
}
return(hilbert_matrix)
}
# function with n = 6
n <- 6
result <- create_hilbert_matrix(n)
print(result)
```

#AUFGABE 25 B

```
library(microbenchmark)
# Function to create a Hilbert matrix
create_hilbert_matrix <- function(n) {
outer(1:n, 1:n, function(x, y) 1 / (x + y - 1))
}
# Function to compare Cholesky decomposition and solve() for matrix inversion
compare_inversion_methods <- function(n) {
# Generate Hilbert
hilbert <- create_hilbert_matrix(n)
# Compute inverse using Cholesky decomposition
chol_inv <- function() solve(chol(hilbert))
# Compute inverse using solve()
solve_inv <- function() solve(hilbert)
# Perform the microbenchmark comparison
mb <- microbenchmark(
chol_inv(),
solve_inv(),
times = 100
)
return(mb)
}
# Compare for n = 3
result_n3 <- compare_inversion_methods(3)
print(result_n3)
# Compare for n = 10
result_n10 <- compare_inversion_methods(10)
print(result_n10)
```

```
library(microbenchmark)
# Function to create a Hilbert matrix
hilbert_matrix <- function(n) {
outer(1:n, 1:n, function(x, y) 1 / (x + y - 1))
}
#Matrices
hilbert1 <- hilbert_matrix(3)
hilbert2 <- hilbert_matrix(10)
result1 <- microbenchmark(solve(hilbert1),
chol2inv(chol(hilbert1)),
setup = set.seed(120))
result1
```

###For the 3×3

#solve(hilbert1) had a higher average computation time (mean = 40.786 microseconds) compared to chol2inv(chol(hilbert1)) (mean = 21.436 microseconds). This suggests that for a 3×3 Hilbert matrix, using Cholesky decomposition followed by inversion (chol2inv()) is faster than direct inversion using solve()

```
res2 <- microbenchmark(solve(hilbert2),
chol2inv(chol(hilbert2)),
setup = set.seed(120))
res2
```

###For the 10×10

#chol2inv(chol(hilbert2)) showed lower average computation time (mean = 34.093 microseconds) compared to solve(hilbert2) (mean = 48.82 microseconds). Again, indicating that for a larger 10×10 Hilbert matrix, using Cholesky decomposition followed by inversion is faster than direct inversion using solve().

###AUFGABE 26 A

```
# Given matrix X
X <- matrix(c(1, 2, 3, 1, 4, 9), ncol = 2)
# Compute Y = 1.5 * X
Y <- 1.5 * X
# Compute X as Y divided by 1.5
X <- Y / drop(1.5)
```

```
# Compute transposed Y
t_Y <- t(Y)
# Display transposed Y
t_Y
```

```
# Calculate cross-product of Y
first_transposed <- crossprod(Y)
# Calculate cross-product using tcrossprod()
second_transposed <- tcrossprod(Y)
# Benchmarking with microbenchmark
microbenchmark(
crossprod(Y),
tcrossprod(Y),
times = 100L,
setup = set.seed(120)
)
```

# Explanation of crossprod and tcrossprod functions in R:

# The crossprod function computes the cross-product of matrices by multiplying the transposed matrix with itself.

# The tcrossprod function calculates the cross-product of matrices, but in a different way.

# When computing Y^T * Y and Y * Y^T, where Y is a matrix:

# - tcrossprod(Y) is faster for computing Y * Y^T as it performs the multiplication without explicitly transposing Y.

# - crossprod(t(Y)) is used for computing Y^T * Y but requires explicitly transposing Y before the cross-product.

#tcrossprod(Y) is more efficient for matrix multiplication involving the matrix and its transpose due to its direct calculation.

#AUFGABE 26 B

```
A <- matrix(rep(1, 1000000), nrow = 1000)
v <- rep(1, 1000)
# Benchmarking the matrix multiplications for 10 times
microbenchmark(
A2v = A %*% A %*% v,
AA_v = (A %*% A) %*% v,
A_Av = A %*% (A %*% v),
times = 10L,
setup = set.seed(120)
)
```

# For operation A^2v:

# The attempt to directly compute A^2v using the %^% operator resulted in an error,

# as this operator is not a standard operation in R for matrix exponentiation.

# To emulate A^2v, the code was adjusted to perform A * A * v using %*% for matrix multiplication.

# For operation (AA)v:

# This operation calculated (AA)v by performing A * A (matrix multiplication)

# and then multiplying the resulting matrix with vector v.

# For operation A(Av):

# A(Av) was calculated by first computing A * v (matrix-vector multiplication)

# and then multiplying the resulting vector with matrix A.

# The results indicated differences in computational times among these operations:

# - A(Av) operation demonstrated significantly lower execution times compared to the other operations.

# - A^2v and (AA)v operations displayed similar execution times, which were notably higher than the A(Av) operation.

##AUFGABE 26 C

```
B <- diag(1, 1000)
A <- matrix(rep(1, 1000000), nrow = 1000)
v <- rep(1, 1000)
microbenchmark(
Av = A %*% v,
ABv = A %*% B %*% v,
AB_v = (A %*% B) %*% v,
A_Bv = A %*% (B %*% v),
times = 10L,
setup = set.seed(120)
)
```

# Discussion of Benchmarking Results for Matrix Operations Av, ABv, (AB)v, and A(Bv):

# Av Operation:

# The operation A %*% v represents a straightforward matrix-vector multiplication.

# It exhibited the fastest execution time among the four operations, taking approximately 5.02 milliseconds.

# This operation involves multiplying matrix A with vector v, which is less computationally complex and faster.

# ABv and (AB)v Operations:

# Both ABv and (AB)v involve matrix multiplication with A and B followed by a matrix-vector multiplication with v.

# ABv took approximately 2182.66 milliseconds, while (AB)v took around 2231.87 milliseconds.

# These operations are more computationally intensive due to the additional step of matrix multiplication involving both matrices (A and B).

# A(Bv) Operation:

# The A(Bv) operation involves a matrix-vector multiplication of matrix B with vector v,

# followed by a matrix-vector multiplication with matrix A.

# It took about 9.18 milliseconds, which is longer than Av but shorter than ABv and (AB)v.

# This operation includes the multiplication of matrix B with vector v before further matrix-vector multiplication with matrix A.

# Conclusion:

# - Av, being the simplest operation, executed the fastest.

# - ABv and (AB)v, involving matrix multiplications with both A and B, took longer due to their computational complexity.

# - A(Bv) took longer than Av due to the additional multiplication of B with v before the final matrix-vector multiplication.

###AUFGABE 27 A

```
X <- hilbert_matrix(6)
H <- X%*% solve(t(X) %*% X) %*% t(X)
```

###AUFGABE 27 B

```
eig_H <- eigen(H, symmetric=TRUE)
str(eig_H)
eigenvalues <- eig_H$values
eigenvalues
```

# The command "str(my_eigen)" returns a list consisting of 2 elements.

# The first element of the list is a vector containing eigenvalues,

# and the second element is a vector containing eigenvectors.

# Accessing eigenvalues can be done using the "$" operator.

# "my_eigen$values" provides us with all the eigenvalues.

###AUFGABE 27 C

```
trace <- function(x) sum(diag(x))
trace(H)
sum(eigenvalues)
```

###AUFGABE 27 D

```
det(H)
prod(eigenvalues)
```

###AUFGABE 27 E

```
#eigenvalues of matrix X
x_eigen <- eigen(X)
x_val <- x_eigen$values
#inverse of matrix X
inv_X <- solve(X)
#eigenvalues of the inverse matrix
xinv_eigen <- eigen(inv_X)
xinv_val <- xinv_eigen$values
#reciprocal of eigenvalues of matrix X
to_check <- 1 / x_val
#comparison
sorted_xinv_val <- sort(xinv_val)
sorted_to_check <- sort(to_check)
print(sorted_xinv_val)
print(sorted_to_check)
```

###AUFGABE 28 A

```
#Hilbert matrix for n = 20
hilb20 <- hilbert_matrix(20)
# Explanation of the situation:
# The Cholesky decomposition function (chol()) requires a matrix to be positive definite.
# A symmetric matrix, like the Hilbert matrix, is considered positive definite if all its eigenvalues are positive.
# However, for the Hilbert matrix hilb20 with n = 20, its entries become exceedingly small.
# Upon analyzing the eigenvalues of hilb20, some are significantly smaller than the machine epsilon (.Machine$double.eps).
# These extremely small eigenvalues, below the machine epsilon, cause issues:
# R interprets these values as close to zero or potentially negative, making the matrix non-positive definite.
hilb20_eig <- eigen(hilb20)
hilb20_eig_values <- hilb20_eig$values
# Check eigenvalues smaller or equal to the machine epsilon
hilb20_small_eig <- hilb20_eig_values <= .Machine$double.eps
hilb20_small_eig
```

#This "issue" occurs with all Hilbert matrices where n>12, and Cholesky decomposition cannot be performed

###AUFGABE 28 B

```
# Calculate condition numbers for Hilbert matrices of different sizes
cond_num_3x3 <- kappa(hilbert_matrix(3))
cond_num_5x5 <- kappa(hilbert_matrix(5))
cond_num_7x7 <- kappa(hilbert_matrix(7))
cond_num_20x20 <- kappa(hilbert_matrix(20))
# Display the computed condition numbers
print(cond_num_3x3)
print(cond_num_5x5)
print(cond_num_7x7)
print(cond_num_20x20)
```

```
#condition numbers for Hilbert matrices of sizes 1x1 to 20x20
n <- 20
conditionHilbert <- rep(NA, n)
for (i in 1:n) {
conditionHilbert[i] <- kappa(hilbert_matrix(i))
}
#condition numbers against the size of Hilbert matrices
plot(1:n, conditionHilbert, pch = 20, col = "green",
xlab = "Size of Hilbert Matrix",
ylab = "Condition number",
log = "y",
main = "Condition Number of Hilbert Matrices")
# Explanation of the plot
# The y-axis is logarithmically scaled to display logarithms of condition numbers in the plot.
# Logarithmic scaling helps visualize linear growth in log-transformed condition numbers,
# indicating exponential growth in the original condition numbers.
# Therefore, as the size of the Hilbert matrix increases, its condition number also increases exponentially.
# A peculiarity is observed after n = 13 where condition numbers almost stabilize and remain close to each other.
# Selecting condition numbers for specific Hilbert matrix sizes
interesting_values <- conditionHilbert[c(3, 5, 7, 20)]
interesting_values
```

###AUFGABE 29 A

```
LmNaive <- function(y, X) {
XtX <- t(X) %*% X
# Check if XtX is full rank before inverting
if (qr(XtX)$rank < ncol(XtX)) {
stop("The matrix (X^TX) is not full rank. OLS estimation failed.")
}
beta_hat <- solve(XtX) %*% t(X) %*% y
return(beta_hat)
}
```

```
LmNaive <- function(y, X) {
XtX <- t(X) %*% X
XtX_inv <- solve(XtX)
Xty <- t(X) %*% y
beta_hat <- XtX_inv %*% Xty
return(beta_hat)
}
```

###AUFGABE 29 B

```
LmCP <- function(y, X) {
# Compute X'X and its inverse using crossprod and solve
XtX_inv <- solve(crossprod(X)) # Compute (X'X)^(-1)
# Compute βˆ using tcrossprod and solve
beta_hat <- solve(tcrossprod(X, y)) %*% XtX_inv %*% tcrossprod(X, y)
return(beta_hat) # Return the estimated coefficients βˆ
}
```

###AUFGABE 29 c

```
# LmChol function computes OLS coefficients using Cholesky decomposition
LmChol <- function(y, X) {
# X'X and its Cholesky decomposition
XtX <- t(X) %*% X # Compute X'X
XtX_chol <- chol(XtX) # Cholesky decomposition of X'X
# X'y
Xty <- t(X) %*% y # Calculate X'y
# Solving Lz = X'y using forward substitution
z <- forwardsolve(t(XtX_chol), Xty) # Solve Lz = X'y
# Solving L'β = z using back substitution
beta_hat <- backsolve(XtX_chol, z) # Solve L'β = z
return(beta_hat)
}
```

###AUFGABE 29 D

```
LmSvd <- function(y, X){
svd_output <- svd(X)
U <- svd_output[["u"]]
V <- svd_output[["v"]]
sigma <- svd_output[["d"]]
beta <- V %*% diag(1 / sigma) %*% t(U) %*% y
return(beta)
}
```

###AUFGABE 29 E

```
#βˆ = R−1QT y
LmQR <- function(y, X){
QR <- qr(X)
Q <- qr.Q(QR)
R <- qr.R(QR)
beta_hat <- backsolve(R, crossprod(Q, y))
return(beta_hat)
}
```

###AUFGABE 29 F

```
?lm.fit()
```