R Notebook

Function	Usage	Example
matrix()	Create matrix	matrix(1:9, nrow=3)
cbind()	Combine columns	cbind(1:3, 4:6)
rbind()	Combine rows	rbind(1:3, 4:6)
dim()	Get dimensions	dim(matrix(1:6, 2, 3))
nrow()	Number of rows	nrow(matrix(1:6, 2, 3))
ncol()	Number of columns	ncol(matrix(1:6, 2, 3))
sum()	Sum elements	sum(1:5)
prod()	Product elements	prod(1:4)
mean()	Arithmetic mean	mean(c(1,2,3,4))
var()	Variance	var(c(1,2,3,4,5))
sd()	Standard deviation	sd(c(1,2,3,4,5))
max()	Maximum value	max(c(3,1,4,1,5))
min()	Minimum value	min(c(3,1,4,1,5))
sort()	Sort vector	sort(c(3,1,4,1,5))
order()	Get sort order	order(c(3,1,4))
rev()	Reverse vector	rev(1:5)
cumsum()	Cumulative sum	cumsum(1:5)
cumprod()	Cumulative product	cumprod(1:5)
abs()	Absolute value	abs(c(-1,2,-3))
sqrt()	Square root	sqrt(c(4,9,16))
acos()	Arc cosine	acos(0.5)
pi	π constant	pi
det()	Determinant	det(matrix(c(1,2,3,4),2))
solve()	Solve/inverse	solve(matrix(c(4,7,2,6),2))
t()	Transpose	t(matrix(1:6,2,3))
diag()	Diagonal/extract	diag(3)
identical()	Exact equality	identical(1,1.0)
sample()	Random sample	sample(1:10, 3)
seq()	Generate sequence	seq(1,10,2)
rep()	Replicate values	rep(5,3)
if()	Conditional	if(x>0) print("positive")
else()	Alternative	else print("negative")
for()	Loop	for(i in 1:5) print(i)
while()	While loop	while(x<10) x<-x+1
function()	Define function	f <- function(x) x^2
return()	Return value	return(x+y)
list()	Create list	list(a=1, b="text")
c()	Combine values	c(1,2,3)
numeric()	Create numeric vector	numeric(5)
colSums()	Column sums	colSums(matrix(1:9,3))
rowSums()	Row sums	rowSums(matrix(1:9,3))
colMeans()	Column means	colMeans(matrix(1:9,3))
rowMeans()	Row means	rowMeans(matrix(1:9,3))
%*%	Matrix multiplication	matrix(1:4,2) %*% matrix(5:8,2)
eigen()	Eigenvalues/vectors	eigen(matrix(c(4,1,1,3),2))

Here are all the vector functions:

# 1. Dot product
dot_product <- function(a, b) {
  sum(a * b)
}

# 2. Magnitude
magnitude <- function(a) {
  sqrt(sum(a^2))
}

# 3. Normalize
normalize <- function(a) {
  mag <- magnitude(a)
  if (mag == 0) stop("Zero vector cannot be normalized")
  a / mag
}

# 4. Cross product (3D)
cross_product <- function(a, b) {
  if (length(a) != 3 || length(b) != 3) stop("Vectors must be 3D")
  c(a[2]*b[3] - a[3]*b[2],
    a[3]*b[1] - a[1]*b[3],
    a[1]*b[2] - a[2]*b[1])
}

# 5. Check orthogonal
is_orthogonal <- function(a, b, tol = 1e-10) {
  abs(dot_product(a, b)) < tol
}

# 6. Check parallel
is_parallel <- function(a, b, tol = 1e-10) {
  mag_a <- magnitude(a)
  mag_b <- magnitude(b)
  if (mag_a == 0 || mag_b == 0) return(TRUE)
  abs(dot_product(a, b) / (mag_a * mag_b)) > 1 - tol
}

# 7. Angle in degrees
angle_degrees <- function(a, b) {
  mag_a <- magnitude(a)
  mag_b <- magnitude(b)
  if (mag_a == 0 || mag_b == 0) stop("Zero vector has no angle")
  acos(dot_product(a, b) / (mag_a * mag_b)) * 180 / pi
}

# 8. Projection of a onto b
projection <- function(a, b) {
  (dot_product(a, b) / dot_product(b, b)) * b
}

# 9. Scalar projection
scalar_projection <- function(a, b) {
  dot_product(a, b) / magnitude(b)
}

# 10. Add vectors
vector_add <- function(a, b) {
  a + b
}

# 11. Subtract vectors
vector_subtract <- function(a, b) {
  a - b
}

# 12. Multiply by scalar
vector_scale <- function(a, k) {
  a * k
}

# 13. Sum of elements
vector_sum <- function(a) {
  sum(a)
}

# 14. Product of elements
vector_prod <- function(a) {
  prod(a)
}

# 15. Maximum
vector_max <- function(a) {
  max(a)
}

# 16. Minimum
vector_min <- function(a) {
  min(a)
}

# 17. Mean
vector_mean <- function(a) {
  sum(a) / length(a)
}

# 18. Variance
vector_var <- function(a) {
  mean_val <- vector_mean(a)
  sum((a - mean_val)^2) / (length(a) - 1)
}

# 19. Standard deviation
vector_sd <- function(a) {
  sqrt(vector_var(a))
}

# 20. Reverse
vector_reverse <- function(a) {
  a[length(a):1]
}

# 21. Bubble sort
bubble_sort <- function(a) {
  n <- length(a)
  for (i in 1:(n-1)) {
    for (j in 1:(n-i)) {
      if (a[j] > a[j+1]) {
        temp <- a[j]
        a[j] <- a[j+1]
        a[j+1] <- temp
      }
    }
  }
  a
}

# 22. Index of max
which_max <- function(a) {
  which.max(a)
}

# 23. Index of min
which_min <- function(a) {
  which.min(a)
}

# 24. Cumulative sum
cumsum_vec <- function(a) {
  result <- numeric(length(a))
  result[1] <- a[1]
  for (i in 2:length(a)) {
    result[i] <- result[i-1] + a[i]
  }
  result
}

# 25. Cumulative product
cumprod_vec <- function(a) {
  result <- numeric(length(a))
  result[1] <- a[1]
  for (i in 2:length(a)) {
    result[i] <- result[i-1] * a[i]
  }
  result
}

# 26. Euclidean distance
euclidean_dist <- function(a, b) {
  sqrt(sum((a - b)^2))
}

# 27. Manhattan distance
manhattan_dist <- function(a, b) {
  sum(abs(a - b))
}

# 28. Check unit vector
is_unit_vector <- function(a, tol = 1e-10) {
  abs(magnitude(a) - 1) < tol
}

# 29. Median without median()
vector_median <- function(a) {
  sorted <- sort(a)
  n <- length(a)
  if (n %% 2 == 1) {
    sorted[(n+1)/2]
  } else {
    (sorted[n/2] + sorted[n/2 + 1]) / 2
  }
}

# 30. Check linear independence of 3 vectors
are_linearly_independent <- function(a, b, c) {
  if (length(a) != 3 || length(b) != 3 || length(c) != 3) {
    stop("Vectors must be 3D")
  }
  det(matrix(c(a, b, c), nrow = 3, byrow = TRUE)) != 0
}

Example usage:

a <- c(1, 2, 3)
b <- c(4, 5, 6)

dot_product(a, b)  # 32
magnitude(a)  # 3.741657
normalize(a)  # [0.267, 0.534, 0.801]
cross_product(a, b)  # [-3, 6, -3]
is_orthogonal(a, b)  # FALSE
angle_degrees(a, b)  # 12.933 degrees

Write a function to multiply two 2x2 matrices.

mul2by2 <- function(A,B){
  C <- matrix(NA, nrow=2, ncol=2)
  
  C[1,1] <- A[1,1]*B[1,1] + A[1,2]*B[2,1]
  C[1,2] <- A[1,1]*B[1,2] + A[1,2]*B[2,2]
  C[2,1] <- A[2,1]*B[1,1] + A[2,2]*B[2,1]
  C[2,2] <- A[2,1]*B[1,2] + A[2,2]*B[2,2]
  
  return(C)
}
A<-matrix(c(1,2,7,4),nrow=2)
B<-matrix(c(2,3,4,10),nrow=2)
mul2by2(A,B)

     [,1] [,2]
[1,]   23   74
[2,]   16   48

Write a function to multiply two matrices of compatible dimensions.

#2*3
#3*2

matrix_multiply <- function(A, B) {
  if (ncol(A) != nrow(B)) {
    stop("Incompatible dimensions: ncol(A) must equal nrow(B)")
  }
  result <- matrix(0, nrow = nrow(A), ncol = ncol(B))
  
  for (i in 1:nrow(A)) {
    for (j in 1:ncol(B)) {
      result[i, j] <- sum(A[i, ] * B[, j])
    }
  }
  
  result
}

ans=matrix_multiply(A,B)
print(ans)

     [,1] [,2]
[1,]   23   74
[2,]   16   48

Write a function to replace a row in a matrix with a vector.

row_replace <- function(A,r,vect){
  A[r,]<-vect
  return(A)
  }
ans<-row_replace(A,2,c(0,0))
print(ans)

     [,1] [,2]
[1,]    1    7
[2,]    0    0

Write a function to find the maximum element in a matrix.

max_ele<- function(A){
  maxi<-A[1,1]
  for (i in 1:nrow(A)){
    for (j in 1:ncol(A)){
      if (A[i,j]>maxi){
        maxi<-A[i,j]
      }
    }
  }
  return(maxi)
}
ans<-max_ele(A)
print(ans)

[1] 7

Write a function to compute row sums of a matrix.

A

     [,1] [,2]
[1,]    1    7
[2,]    2    4

row_sums<-function(A){
  result<-numeric(nrow(A))
  for (i in 1:nrow(A)){
    result[i]<-sum(A[i,])
  }
  return(result)
}

ans<-row_sums(A)
print(ans)

[1] 8 6

Write a function to check if a matrix is upper triangular.

uptrian <- function(A){
  for (i in 1:nrow(A)){
    for (j in 1:ncol(A)){
      if (i>j){
        A[i,j]!=0
        return(FALSE)
      }
    }
  }
  return(TRUE)
}
ans<-uptrian(A)
print(ans)

[1] FALSE

A<-c()
A<-append(A,2)
A<-append(A,4)

Write a function to check if a matrix is scalar (multiple of identity).

scaler_check <- function(A){
  for (i in 1:nrow(A)){
    for (j in 1:ncol(A)){
      if(i!=j & A[i,j]!=0){
        return(FALSE)
      } 
      else if(i==j & A[i,j]!=A[1,1]){
        return(FALSE)
      }
    }
  }
  return(TRUE)
  }

A<-matrix(c(1,2,7,4),nrow=2)
B<-matrix(c(1,0,0,1), nrow=2)
scaler_check(B)

[1] TRUE

Write a function to compute the row-wise maximum of a matrix.

rowmax<-function(A){
  maxs<-numeric(nrow(A))
  for (i in 1:nrow(A)){
    max=A[i,1]
    for (j in 1:ncol(A)){
      if (A[i,j]>max){
        max<-A[i,j]
      }
    }
    maxs[i]<-max 
  }
  return(maxs)
}
print(rowmax(A))

[1] 7 4

A

     [,1] [,2]
[1,]    1    7
[2,]    2    4

Write a function to compute cumulative sum of each row.

cumsumrow <- function(A){
  mat<-matrix(NA,nrow=nrow(A),ncol=ncol(A))
  for (i in 1:nrow(A)){
    cumsum<-numeric(ncol(A))
    cumsum[1]<-A[i,1]
    for (j in 2:ncol(A)){
      cumsum[j]<-A[i,j]+cumsum[j-1]
    }
    mat[i,]<-cumsum
  }
  return(mat)
}

print(cumsumrow(A))

     [,1] [,2]
[1,]    1    8
[2,]    2    6

A

     [,1] [,2]
[1,]    1    7
[2,]    2    4

25. Cumulative product

cumprod_vec <- function(a) { result <- numeric(length(a)) result[1] <- a[1] for (i in 2:length(a)) { result[i] <- result[i-1] * a[i] } result }

vecx<-c(10,20,188,348)
sum(vecx^2)

[1] 156948

A<-c(1,2,3,4)
B<-c(2,4,6,8)
all(A/B==A[1]/B[1])

[1] TRUE

# 21. Bubble sort
bubble_sort <- function(a) {
  n <- length(a)
  for (i in 1:(n-1)) {
    for (j in 1:(n-i)) {
      if (a[j] > a[j+1]) {
        temp <- a[j]
        a[j] <- a[j+1]
        a[j+1] <- temp
      }
    }
  }
  a
}