1)

multiplica_vet = function(v,a){
  if(!is.numeric(v)) stop("Vetor v precisa ser numérico!")
  if(!is.numeric(a)) stop("Escalar a precisa ser numérica!")
  if(length(a)!=1) stop("Escalar a deve ser um valor único!")
  n = length(v)
  w = c()
  for(i in 1:n){
    w[i] = v[i]*a
  }
  return(w)
}

multiplica_vet(1:10,3)
##  [1]  3  6  9 12 15 18 21 24 27 30

2)

soma_vetor = function(v,u){
  if(!is.numeric(v)) stop("Vetor v precisa ser numérico!")
  if(!is.numeric(u)) stop("Vetor u precisa ser numérico!")
  n = length(v)
  k = length(u)
  if(n!=k) stop("Vetores com dimensões diferentes!")
  w = c()
  for(i in 1:n){
    w[i] = v[i] + u[i]
  }
  return(w)
}
soma_vetor(c(2,3,4),c(4,3,2))
## [1] 6 6 6

3)

# 1. Defina n como o tamanho do vetor v;
# 2. Defina k como o tamanho do vetor u;
# 3. Se n for diferente de k retorne erro e FIM;
# 4. Crie um vetor w vazio;
# 5. Inicie i = 1;
# 6. w[i] = v[i] - u[i]
# 7. Incremente i: i = i + 1;
# 8. Se i <= n, volta para a linha 6;
# 9. Retorne w.

subtrai_vetor = function(v,u){
  if(!is.numeric(v)) stop("Vetor v precisa ser numérico!")
  if(!is.numeric(u)) stop("Vetor u precisa ser numérico!")
  n = length(v)
  k = length(u)
  if(n!=k) stop("Vetores com dimensões diferentes!")
  w = c()
  for(i in 1:n){
    w[i] = v[i] - u[i]
  }
  return(w)
}
subtrai_vetor(c(2,3,4),c(4,3,2))
## [1] -2  0  2

4)

prod_interno = function(u,v){
  if(!is.numeric(v)) stop("Vetor v precisa ser numérico!")
  if(!is.numeric(u)) stop("Vetor u precisa ser numérico!")
  n = length(v)
  k = length(u)
  if(n!=k) stop("Vetores com dimensões diferentes!")
  p = 0
  for(i in 1:n){
    p = p + u[i]*v[i]
  }
  return(p)
}
prod_interno(c(5,3,2),c(1,3,2))
## [1] 18

5)

ortogonais_vet = function(u,v){
  p = prod_interno(u,v)
  if(p == 0) return(TRUE)
  else return(FALSE)
}

ortogonais_vet(c(1,3,2),c(3,-1,0))
## [1] TRUE
ortogonais_vet(c(1,3,2),c(3,3,0))
## [1] FALSE

6)

prod_matriz = function(A,r){
  if(!is.matrix(A)) return("A precisa ser uma matriz!")
  if(!is.numeric(r)) stop("Escalar r precisa ser numérico!")
  n_col = ncol(A)
  n_row = nrow(A)
  M = matrix(ncol = n_col, nrow = n_row)
  for(i in 1:n_row){
    for(j in 1:n_col){
      M[i,j] = A[i,j]*r
    }
  }
  return(M)
}

A = matrix(c(1,2,3,4,5,6),nrow = 3,ncol = 3)
A
##      [,1] [,2] [,3]
## [1,]    1    4    1
## [2,]    2    5    2
## [3,]    3    6    3
prod_matriz(A,3)
##      [,1] [,2] [,3]
## [1,]    3   12    3
## [2,]    6   15    6
## [3,]    9   18    9

7)

soma_matriz = function(A,B){
  if(!is.matrix(A)) return("A precisa ser uma matriz!")
  if(!is.matrix(B)) return("B precisa ser uma matriz!")
  n_colA = ncol(A)
  n_rowA = nrow(A)
  n_colB = ncol(B)
  n_rowB = nrow(B)
  if(n_colA != n_colB || n_rowA != n_rowB) stop("Dimensões das matrizes devem ser iguais!")
  M = matrix(ncol = n_colA, nrow = n_rowA)
  for(i in 1:n_rowA){
    for(j in 1:n_colA){
      M[i,j] = A[i,j] + B[i,j]
    }
  }
  return(M)
}

A = matrix(c(1,2,3,4,5,6),nrow = 3,ncol = 3)
B = matrix(c(6,5,4,3,2,1),nrow = 3,ncol = 3)
soma_matriz(A,B)
##      [,1] [,2] [,3]
## [1,]    7    7    7
## [2,]    7    7    7
## [3,]    7    7    7

8)

# 1. Defina n_rowA número de linhas da matriz A;
# 2. Defina n_colA número de colunas da matriz A;
# 3. Defina n_rowB número de linhas da matriz B;
# 4. Defina n_colB número de colunas da matriz B;
# 5. Se n_rowA é diferente de n_rowB, retorne uma mensagem de erro e FIM.
# 6. Se n_colA é diferente de n_colB, retorne uma mensagem de erro e FIM.
# 7. Inicie uma matriz M de dimensão n x m. 
# 8. Inicie i = 1;
# 9. Inicie j = 1;
# 10. Faça M[i,j] = A[i,j] - B[i,j];
# 11. Incremente j: j = j + 1;
# 12. Se j < = n_rowA volte para a linha 10;
# 13. Incremente i: i = i + 1;
# 14. Se i < = n_colA volte para a linha 9;
# 15. Retorne M.

subtrai_matriz = function(A,B){
  if(!is.matrix(A)) return("A precisa ser uma matriz!")
  if(!is.matrix(B)) return("B precisa ser uma matriz!")
  n_colA = ncol(A)
  n_rowA = nrow(A)
  n_colB = ncol(B)
  n_rowB = nrow(B)
  if(n_colA != n_colB || n_rowA != n_rowB) stop("Dimensões das matrizes devem ser iguais!")
  M = matrix(ncol = n_colA, nrow = n_rowA)
  for(i in 1:n_rowA){
    for(j in 1:n_colA){
      M[i,j] = A[i,j] - B[i,j]
    }
  }
  return(M)
}

A = matrix(c(1,2,3,4,5,6),nrow = 3,ncol = 3)
B = matrix(c(6,5,4,3,2,1),nrow = 3,ncol = 3)
subtrai_matriz(A,B)
##      [,1] [,2] [,3]
## [1,]   -5    1   -5
## [2,]   -3    3   -3
## [3,]   -1    5   -1

9)

transposta = function(A){
  if(!is.matrix(A)) return("A precisa ser uma matriz!")
  n_colA = ncol(A)
  n_rowA = nrow(A)
  M = matrix(ncol = n_rowA, nrow = n_colA)
  for(i in 1:n_rowA){
    for(j in 1:n_colA){
      M[j,i] = A[i,j]
    }
  }
  return(M)
}

A = matrix(c(1,2,3,4,5,6,7,8,9),ncol = 3,nrow = 3)
transposta(A)
##      [,1] [,2] [,3]
## [1,]    1    2    3
## [2,]    4    5    6
## [3,]    7    8    9

10)

# 1. Defina n_rowA número de linhas da matriz A;
# 2. Defina n_colA número de colunas da matriz A;
# 3. Se n_rowA for diferente de n_colA, retorna erro e FIM;
# 5. Defina a tranposta de A como t_A;
# 6. t_A recebe transposta(A);
# 7. Inicie i = 1;
# 8. Inicie j = 1;
# 9. Se t_A[i,j] != A[i,j], retorne FALSE
# 10. Incremente j: j = j + 1;
# 11. Se j < = n_rowA volte para a linha 9;
# 12. Incremente i: i = i + 1;
# 13. Se i < = n_colA volte para a linha 8;
# 14. Retorne TRUE.

simetrica = function(A){
  if(!is.matrix(A)) return("A precisa ser uma matriz!")
  n_colA = ncol(A)
  n_rowA = nrow(A)
  if(n_colA != n_rowA) return("A matriz A deve ser quadrada!")
  t_A = transposta(A)
  for(i in 1:n_rowA){
    for(j in 1:n_colA){
      if(A[i,j] != t_A[i,j]) return(FALSE)
    }
  }
  return(TRUE)
}

A = matrix(0,nrow = 3,ncol = 3)
simetrica(A)
## [1] TRUE
A = matrix(1:4,ncol = 2)
simetrica(A)
## [1] FALSE

11)

mult_matriz_vet = function(A,v){
  if(!is.matrix(A)) return("A precisa ser uma matriz!")
  if(!is.numeric(v)) stop("Vetor v precisa ser numérico!")
  n_rowA = nrow(A)
  n_colA = ncol(A)
  k = length(v)
  if(n_colA != k) stop("Dimensões incompatíveis!")
  w = c()
  for(i in 1:n_rowA){
    w[i] = prod_interno(A[i,],v)
  }
  return(w)
}

A = matrix(c(1,2,3,4,5,6,7,8,9),ncol = 3)
v = c(2,2,2)

mult_matriz_vet(A,v)
## [1] 24 30 36

12)

mult_matriz = function(A,B){
  if(!is.matrix(A)) return("A precisa ser uma matriz!")
  if(!is.matrix(B)) return("B precisa ser uma matriz!")
  n_colA = ncol(A)
  n_rowA = nrow(A)
  n_colB = ncol(B)
  n_rowB = nrow(B)
  if(n_colA != n_rowB) return("Dimensões incompatíveis!")
  M = matrix(nrow = n_rowA,ncol = n_colB)
  for(i in 1:n_rowA){
    for(j in 1:n_colB){
      M[i,j] = prod_interno(A[i,],B[,j])
    }
  }
  return(M)
}

A = matrix(c(1,2,3),nrow = 3)
B = matrix(c(5,4,3), ncol = 3)

mult_matriz(A,B)
##      [,1] [,2] [,3]
## [1,]    5    4    3
## [2,]   10    8    6
## [3,]   15   12    9

13)

alfa=4; beta= -3; v1=c(2,-3,-1,5,0,-2); v2=c(3,4,-1,0,1,1); v3=c(1,2,3,4,5); v4=c(0,1,1)
M1 = matrix(c(1,3,2,-1,0,1),ncol = 3, byrow = T)
M2 = matrix(c(0,-5,3,-1,1,-1,1,4,0), ncol = 3, byrow = T)
M3 = matrix(c(3,1,-2,10,3,-1), ncol = 2, byrow = T)
M4 = matrix(c(1,1,0,1), ncol = 2 , byrow = T)
M5 = matrix(c(3,1,0,1,1,1,3,2,0,3,-5,0,1,2,0,0), ncol = 4, byrow = T)

a)

multiplica_vet(v3,alfa)
## [1]  4  8 12 16 20

b)

soma_vetor(v1,v2)
## [1]  5  1 -2  5  1 -1

c)

subtrai_vetor(v3, v1)
## Error in subtrai_vetor(v3, v1): Vetores com dimensões diferentes!

d)

prod_interno(v1,v2)
## [1] -7

e)

prod_interno(multiplica_vet(v1,alfa),subtrai_vetor(v2,v1))
## [1] -200

f)

prod_interno(soma_vetor(v1,v2),subtrai_vetor(v1,v2))
## [1] 15

g)

ortogonais_vet(v1,v2)
## [1] FALSE

h)

prod_matriz(M1,beta)
##      [,1] [,2] [,3]
## [1,]   -3   -9   -6
## [2,]    3    0   -3

i)

transposta(M1)
##      [,1] [,2]
## [1,]    1   -1
## [2,]    3    0
## [3,]    2    1

j)

simetrica(M1)
## [1] "A matriz A deve ser quadrada!"
simetrica(M4)
## [1] FALSE
simetrica(M5)
## [1] TRUE

k)

mult_matriz_vet(M1,v4)
## [1] 5 1

l)

soma_vetor(mult_matriz_vet(M2,v4),v4)
## [1] -2  1  5

m)

mult_matriz(M1,M2)
##      [,1] [,2] [,3]
## [1,]   -1    6    0
## [2,]    1    9   -3

n)

mult_matriz(M2,M1)
## [1] "Dimensões incompatíveis!"

o)

mult_matriz(transposta(M3),M2)
##      [,1] [,2] [,3]
## [1,]    5   -5   11
## [2,]  -11    1   -7

p)

soma_matriz(mult_matriz(M1,M3),M4)
##      [,1] [,2]
## [1,]    4   30
## [2,]    0   -1

q)

mult_matriz(mult_matriz(M1,M2),M3)
##      [,1] [,2]
## [1,]  -15   59
## [2,]  -24   94

r)

subtrai_matriz(mult_matriz(mult_matriz(M1,M2),M3), M4)
##      [,1] [,2]
## [1,]  -16   58
## [2,]  -24   93