diff --git a/src/matrix/matrix.c b/src/matrix/matrix.c
index 937f76d..09705ec 100644
--- a/src/matrix/matrix.c
+++ b/src/matrix/matrix.c
@@ -467,19 +467,21 @@ complexo **conjugada(complexo **mtx, int linhas, int colunas)
 
     return matrix;
 }
-/**###Função Hermitiana: 
- * A função `hermitiana` implementa a operação de matriz hermitiana. Essa operação consiste em obter a matriz conjugada da matriz de entrada e, em seguida, calcular a transposta dessa matriz conjugada. A matriz resultante é uma matriz hermitiana.																																							
-- A função hermitiana recebe três parâmetros: mtx (uma matriz de números complexos), linhas (o número de linhas da matriz) e colunas (o número de colunas da matriz).
-Ela declara duas variáveis do tipo complexo**: matriz e matriz_h.
-- Em seguida, a função aloca memória para duas matrizes usando a função allocateComplexMatrix. A primeira matriz (matriz) tem o mesmo tamanho da matriz de entrada, enquanto a segunda matriz (matriz_h), também tem o mesmo tamanho.
-- A função chama a função conjugada passando a matriz de entrada mtx, linhas e colunas. Essa função retorna a matriz conjugada da matriz de entrada.
-- O resultado da função conjugada é atribuído à matriz matriz.
-- Em seguida, a função chama a função transposta passando a matriz matriz, linhas e colunas. Essa função retorna a transposta da matriz passada como argumento.
-O resultado da função transposta é atribuído à matriz matriz_h.
-- Por fim, a função retorna a matriz matriz_h, que é a matriz hermitiana resultante.
+
+/**###Hermitian Function: 
+ * The `hermitian` function implements the operation of hermitian matrix. This operation consists of obtaining the conjugate matrix of the input matrix and then calculating the transpose of this conjugate matrix. The resulting matrix is a hermitian matrix.
+- The `hermitian` function takes three parameters: `mtx` (a matrix of complex numbers), `linhas` (the number of rows in the matrix), and `colunas` (the number of columns in the matrix).
+It declares two variables of type `complexo**`: `matriz` and `matriz_h`.
+- Then, the function allocates memory for two matrices using the `allocateComplexMatrix` function. The first matrix (`matriz`) has the same size as the input matrix, while the second matrix (`matriz_h`), also has the same size.
+- The function calls the `conjugate` function passing the input matrix `mtx`, `linhas`, and `colunas`. This function returns the conjugate matrix of the input matrix.
+- The result of the `conjugate` function is assigned to the `matriz` matrix.
+- Then, the function calls the `transpose` function passing the `matriz` matrix, `linhas`, and `colunas`. This function returns the transpose of the matrix passed as an argument.
+The result of the `transpose` function is assigned to the `matriz_h` matrix.
+- Finally, the function returns the `matriz_h` matrix, which is the resulting hermitian matrix.
  @param[in] mtx, linhas, colunas
  @param[out] matriz_h.
 */
+
 complexo **hermitiana(complexo** mtx, int linhas, int colunas)
 {
     complexo **matriz, **matriz_h;
@@ -492,15 +494,15 @@ complexo **hermitiana(complexo** mtx, int linhas, int colunas)
 
     return matriz_h;
 }
-/**###Função Soma: 
- * A função `soma` implementa a operação de soma de matriz(es). Essa operação consiste em somar duas ou mais matrizes, entretanto no exemplo a seguir só com duas matrizes.
-- A função `soma` recebe quatro parâmetros: `mtx_a` (uma matriz "a" de números complexos),`mtx_b` (uma matriz "b" de números complexos), `linhas` (o número de linhas da matriz) e `colunas` (o número de colunas da matriz).
-- Ela declara uma variável do tipo `complexo**` chamada `matriz`, que será usada para armazenar a matriz da operação de soma.
-- Em seguida, a função aloca memória para a matriz `matriz` usando a função `allocateComplexMatrix`. A matriz `matriz` tem o mesmo tamanho das matrizes "a" e "b".
-- A função usa dois loops aninhados para percorrer cada elemento da matriz `mtx`. O loop externo itera pelas linhas e o loop interno itera pelas colunas.
-- Dentro do loop, a função atribui o valor real da soma dos elementos da matriz de entrada `mtx_a[c][l].real` e `mtx_b[c][l].real`, ao elemento correspondente da matriz `matriz[l][c].real`.
-- A função atribui também de maneira análoga a soma do valor da parte imaginária dos elementos das matrizes de entrada `mtx_a[c][l].img` e `mtx_b[c][l].real`, ao elemento correspondente da matriz `matriz[l][c].img`.	
-- Depois que todos os elementos das matrizes `mtx_a` e 'mtx_b' são processados, a função retorna a matriz `matriz`, que contém a matriz da função soma.
+/**###Sum Function: 
+ * The `sum` function implements the operation of matrix addition. This operation consists of adding two or more matrices, however in the following example only with two matrices.
+- The `sum` function takes four parameters: `mtx_a` (a "a" matrix of complex numbers),`mtx_b` (a "b" matrix of complex numbers), `linhas` (the number of rows in the matrix), and `colunas` (the number of columns in the matrix).
+- It declares a variable of type `complexo**` called `matriz`, which will be used to store the matrix of the sum operation.
+- Then, the function allocates memory for the `matriz` matrix using the `allocateComplexMatrix` function. The `matriz` matrix has the same size as the "a" and "b" matrices.
+- The function uses two nested loops to go through each element of the `mtx` matrix. The outer loop iterates over the rows and the inner loop iterates over the columns.
+- Inside the loop, the function assigns the real value of the sum of the input matrix elements `mtx_a[c][l].real` and `mtx_b[c][l].real`, to the corresponding element of the `matriz[l][c].real`.
+- The function also assigns in an analogous way the sum of the value of the imaginary part of the input matrix elements `mtx_a[c][l].img` and `mtx_b[c][l].real`, to the corresponding element of the `matriz[l][c].img`.
+- After all elements of the `mtx_a` and 'mtx_b' matrices are processed, the function returns the `matriz` matrix, which contains the matrix of the sum function.
  * @param[in] mtx_a, mtx_b, linhas, colunas
  * @param[out] matriz
  * */
@@ -519,15 +521,15 @@ complexo **soma(complexo** mtx_a, complexo** mtx_b, int linhas, int colunas)
 		}
 	return matriz;
 }
-/**###Função Subtração: 
- * A função `subtração` implementa a operação de soma de matriz(es). Essa operação consiste em subtrair duas ou mais matrizes, entretanto no exemplo a seguir como no acima só com duas matrizes.
-- A função `subtração` recebe quatro parâmetros: `mtx_a` (uma matriz "a" de números complexos),`mtx_b` (uma matriz "b" de números complexos), `linhas` (o número de linhas da matriz) e `colunas` (o número de colunas da matriz).
-- Ela declara uma variável do tipo `complexo**` chamada `matriz`, que será usada para armazenar a matriz da operação de subtração.
-- Em seguida, a função aloca memória para a matriz `matriz` usando a função `allocateComplexMatrix`. A matriz `matriz` tem o mesmo tamanho das matrizes "a" e "b".
-- A função usa dois loops aninhados para percorrer cada elemento da matriz `mtx`. O loop externo itera pelas linhas e o loop interno itera pelas colunas.
-- Dentro do loop, a função atribui o valor real da subtração dos elementos da matriz de entrada `mtx_a[c][l].real` e `mtx_b[c][l].real`, ao elemento correspondente da matriz `matriz[l][c].real`.
-- A função atribui também de maneira análoga a subtração do valor da parte imaginária dos elementos das matrizes de entrada `mtx_a[c][l].img` e `mtx_b[c][l].real`, ao elemento correspondente da matriz `matriz[l][c].img`.	
-- Depois que todos os elementos das matrizes `mtx_a` e 'mtx_b' são processados, a função retorna a matriz `matriz`, que contém a matriz da função subtração.
+/**###Subtraction Function: 
+ * The `subtraction` function implements the operation of matrix subtraction. This operation consists of subtracting two or more matrices, however in the following example as in the above only with two matrices.
+- The `subtraction` function takes four parameters: `mtx_a` (a "a" matrix of complex numbers),`mtx_b` (a "b" matrix of complex numbers), `linhas` (the number of rows in the matrix), and `colunas` (the number of columns in the matrix).
+- It declares a variable of type `complexo**` called `matriz`, which will be used to store the matrix of the subtraction operation.
+- Then, the function allocates memory for the `matriz` matrix using the `allocateComplexMatrix` function. The `matriz` matrix has the same size as the "a" and "b" matrices.
+- The function uses two nested loops to go through each element of the `mtx` matrix. The outer loop iterates over the rows and the inner loop iterates over the columns.
+- Inside the loop, the function assigns the real value of the subtraction of the input matrix elements `mtx_a[c][l].real` and `mtx_b[c][l].real`, to the corresponding element of the `matriz[l][c].real`.
+- The function also assigns in an analogous way the subtraction of the value of the imaginary part of the input matrix elements `mtx_a[c][l].img` and `mtx_b[c][l].real`, to the corresponding element of the `matriz[l][c].img`.
+- After all elements of the `mtx_a` and 'mtx_b' matrices are processed, the function returns the `matriz` matrix, which contains the matrix of the subtraction function.
  * @param[in] mtx_a, mtx_b, linhas, colunas
  * @param[out] matriz
  * */
@@ -546,13 +548,13 @@ complexo **subtracao(complexo** mtx_a, complexo** mtx_b, int linhas, int colunas
 		}
 	return matriz;
 }
-/**###Função Produto Interno: 
- * A função `produto interno` implementa a operação de produto de dois vetores complexos.
-- A função `produto interno` recebe quatro parâmetros: `v1` (um vetor "v1" de números complexos),`v2` (um vetor "v2" de números complexos), `linhas` (o número de linhas dos vetores) e `colunas` (o número de colunas dos vetores).
-- Ela declara uma variável do tipo `complexo` chamada `resultado` com valores iniciais (0,0), que será usada para armazenar o resulado do produto interno.
-- Em seguida, a função verifica se o número de colunas seja igual a 1. Caso contrário, exibi-se uma mensagem de erro que o produto não pode ser realizado pela a incompatibilidade de vetores, a função encerra com a função 'exit(1)'
-- A função após a verificação inicia um loop que percorre as linhas dos vetores, no loop é feita a multiplicação de 'v1[l][0]' e 'v2[l][0]' por meio da função 'multcomp' que é armazenada na variável 'temp'.
-- Após a multiplicação, a variável 'temp' é somada à variável 'resultado' usando a função 'multcomp'.
+/**###Inner Product Function: 
+ * The `inner product` function implements the operation of the product of two complex vectors.
+- The `inner product` function takes four parameters: `v1` (a "v1" vector of complex numbers),`v2` (a "v2" vector of complex numbers), `linhas` (the number of rows of the vectors), and `colunas` (the number of columns of the vectors).
+- It declares a variable of type `complexo` called `resultado` with initial values (0,0), which will be used to store the result of the inner product.
+- Then, the function checks if the number of columns is equal to 1. Otherwise, it displays an error message that the product cannot be performed due to the incompatibility of vectors, the function ends with the 'exit(1)' function
+- After the check, the function starts a loop that goes through the rows of the vectors, in the loop the multiplication of 'v1[l][0]' and 'v2[l][0]' is done through the 'multcomp' function which is stored in the 'temp' variable.
+- After the multiplication, the 'temp' variable is added to the 'resultado' variable using the 'multcomp' function.
  * @param[in] v1, v2, linhas, colunas
  * @param[out] resultado
  * */
@@ -574,14 +576,14 @@ complexo produto_interno(complexo **v1, complexo **v2, int linhas, int colunas)
     return resultado;
 
 }
-/**###Função Produto Matricial: 
- * A função `produto matricial` implementa a operação de produto de duas matrizes complexos.
-- A função `produto matricial` recebe quatro parâmetros: `mtx_a` (uma matriz "a" de números complexos),`mtx_b` (uma matriz "b" de números complexos), `linhas` (o número de linhas das matrizes) e `colunas` (o número de colunas das matrizes).
-- Ela declara uma variável do tipo `complexo` chamada `matriz`, que será usada para armazenar o resulado do produto matricial.
-- Em seguida, a função valida a operação verificando se o número de colunas da matriz 'a' é igual ao número de linhas da matriz 'b' seja igual. Caso não, exibi-se uma mensagem de erro que o produto não pode ser realizado pela a incompatibilidade de matrizes e encerra o programa com a função 'exit(1)'.
-- A função após a verificação inicia um loop para percorrer as células da matriz resultante, para cada célula um acumulador é iniciado com o valor zero.
-- Dentro do loop, é realizado outro loop para calcular o somatório do produto da matriz a e matriz b, tal operação é feita a partir da função 'multcomp'.
-- Em seguida a função 'soma_complexo' é chamada para adiconar o resultado ao acumulador.
+/**###Matrix Product Function: 
+ * The `matrix product` function implements the operation of the product of two complex matrices.
+- The `matrix product` function takes four parameters: `mtx_a` (a "a" matrix of complex numbers),`mtx_b` (a "b" matrix of complex numbers), `linhas` (the number of rows of the matrices), and `colunas` (the number of columns of the matrices).
+- It declares a variable of type `complexo` called `matriz`, which will be used to store the result of the matrix product.
+- Then, the function validates the operation by checking if the number of columns of the 'a' matrix is equal to the number of rows of the 'b' matrix. If not, it displays an error message that the product cannot be performed due to the incompatibility of matrices and ends the program with the 'exit(1)' function.
+- After the check, the function starts a loop to go through the cells of the resulting matrix, for each cell an accumulator is started with the value zero.
+- Inside the loop, another loop is performed to calculate the sum of the product of matrix a and matrix b, such operation is done from the 'multcomp' function.
+- Then the 'soma_complexo' function is called to add the result to the accumulator.
  * @param[in] mtx_a, mtx_b, linhas, colunas
  * @param[out] matriz
  * */
@@ -646,15 +648,15 @@ complexo **produto_matricial(complexo** mtx_a, complexo **mtx_b, int linhas, int
     
     return matriz;
 }*/
-/**###Função Produto por Escalar: 
- * A função `produto por escalar` implementa a operação de matriz por um escalar qualquer. 
-- A função produto por escalar recebe quatro parâmetros: mtx (uma matriz de números complexos), linhas (o número de linhas da matriz), colunas (o número de colunas da matriz) e k(número inteiro escalar).
-Ela declara uma variável do tipo complexo**: matriz.
-- Em seguida, a função aloca memória para a matriz usando a função allocateComplexMatrix. 
-- A função usa dois loops aninhados para percorrer cada elemento da matriz `mtx`. O loop externo itera pelas linhas e o loop interno itera pelas colunas.
-- Dentro do loop, a função atribui o valor real do elemento da matriz de entrada `mtx[c][l].real`, ao elemento correspondente da matriz `matriz[l][c].real` que é multiplicado pelo o inteiro 'k'.
-- A função atribui também de maneira análoga, o valor da multplicação do escalar pela a parte imaginária do elemento das matriz de entrada `mtx[c][l].img` , ao elemento correspondente da matriz `matriz[l][c].img`.	
-- Depois que todos os elementos das matriz`mtx` são processados, a função retorna a matriz `matriz
+/**###Scalar Product Function: 
+ * The `scalar product` function implements the operation of a matrix by any scalar. 
+- The scalar product function takes four parameters: `mtx` (a matrix of complex numbers), `linhas` (the number of rows in the matrix), `colunas` (the number of columns in the matrix), and `k` (integer scalar).
+- It declares a variable of type `complexo**`: `matriz`.
+- Then, the function allocates memory for the matrix using the `allocateComplexMatrix` function. 
+- The function uses two nested loops to go through each element of the `mtx` matrix. The outer loop iterates over the rows and the inner loop iterates over the columns.
+- Inside the loop, the function assigns the real value of the input matrix element `mtx[c][l].real`, multiplied by the integer 'k', to the corresponding element of the `matriz[l][c].real`.
+- The function also assigns in an analogous way, the value of the multiplication of the scalar by the imaginary part of the input matrix element `mtx[c][l].img`, to the corresponding element of the `matriz[l][c].img`.
+- After all elements of the `mtx` matrix are processed, the function returns the `matriz` matrix.
 
  @param[in] mtx, linhas, colunas, k
  @param[out] matriz.
@@ -750,16 +752,15 @@ void teste_transposta(void)
 		}
 }
 
-/**###Função Calculo do SVD: 
- * A função `Calculo SVD` implementa o operador SVD.
-- A função `Calculo SVD` recebe três parâmetros: `mtx` (uma matriz de números complexos),`linhas` (número de linhas da matriz), `colunas` (o número de colunas da matriz).
-- O SVD foi implementado somente para matrizes reais, portanto, antes de iniciar o calculo do SVD, a função testa se há parte imaginaria, caso houver um aviso aparece na tela informando que não há suporte para matrizes complexas.
-- Não há retorno na função, ela imprime na tela o valor do SVD da matriz `mtx`.
+/**###SVD Calculation Function: 
+ * The `SVD Calculation` function implements the SVD operator.
+- The `SVD Calculation` function takes three parameters: `mtx` (a matrix of complex numbers),`linhas` (number of rows in the matrix), `colunas` (the number of columns in the matrix).
+- The SVD was implemented only for real matrices, therefore, before starting the SVD calculation, the function tests if there is an imaginary part, if there is a warning appears on the screen informing that there is no support for complex matrices.
+- There is no return in the function, it prints on the screen the value of the SVD of the matrix `mtx`.
  * @param[in] mtx, linhas, colunas
  * @param[out] void
  * */
 
-
 void calc_svd(complexo** mtx, int linhas, int colunas)
 {
 	for (int l = 0; l < linhas; l++)
@@ -1482,17 +1483,17 @@ complexo **allocateComplexMatrix (int linhas, int colunas)
 
     return matrix;
 }
-/**###Função Soma Complexo: 
- A função `soma_complexo` recebe dois números complexos `c1` e `c2` como parâmetros e retorna o resultado da soma desses dois números complexos.
-- Dentro da função, uma variável chamada `soma` do tipo `complexo` é declarada para armazenar o resultado da soma.
+/**###Complex Sum Function: 
+ The `complex_sum` function takes two complex numbers `c1` and `c2` as parameters and returns the result of the sum of these two complex numbers.
+- Inside the function, a variable named `sum` of type `complex` is declared to store the result of the sum.
 
-- A parte real do número resultante é calculada somando as partes reais dos números complexos `c1` e `c2`, ou seja, `soma.real = c1.real + c2.real`.
+- The real part of the resulting number is calculated by adding the real parts of the complex numbers `c1` and `c2`, that is, `sum.real = c1.real + c2.real`.
 
-- Da mesma forma, a parte imaginária do número resultante é calculada somando as partes imaginárias dos números complexos `c1` e `c2`, ou seja, `soma.img = c1.img + c2.img`.
+- Similarly, the imaginary part of the resulting number is calculated by adding the imaginary parts of the complex numbers `c1` and `c2`, that is, `sum.img = c1.img + c2.img`.
 
-- Por fim, o número complexo `soma`, contendo a parte real e a parte imaginária calculadas, é retornado pela função como resultado da soma dos números complexos `c1` e `c2`.
+- Finally, the complex number `sum`, containing the calculated real and imaginary parts, is returned by the function as the result of the sum of the complex numbers `c1` and `c2`.
  * @param[in] c1, c2
- * @param[out] resultado
+ * @param[out] result
  * */
 complexo soma_complexo(complexo c1, complexo c2)
 {
@@ -1559,17 +1560,17 @@ void teste_calc_svd(void)
 	calc_svd (mtx_d, ld, cd);
 }
 
-/**###Função Multicomp: 
- * A função `multcomp` recebe dois números complexos `c1` e `c2` como parâmetros e retorna o resultado da multiplicação desses dois números complexos.
-- Dentro da função, uma variável chamada `multiplicado` do tipo `complexo` é declarada para armazenar o resultado da multiplicação. 
+/**###Multicomp Function: 
+ * The `multcomp` function takes two complex numbers `c1` and `c2` as parameters and returns the result of the multiplication of these two complex numbers.
+- Inside the function, a variable named `multiplied` of type `complex` is declared to store the result of the multiplication. 
 
-- A parte real do número resultante é calculada pela fórmula `(c1.real * c2.real) - (c1.img * c2.img)`, onde `c1.real` e `c2.real` representam as partes reais dos números complexos `c1` e `c2`, e `c1.img` e `c2.img` representam as partes imaginárias dos números complexos `c1` e `c2`. 
+- The real part of the resulting number is calculated by the formula `(c1.real * c2.real) - (c1.img * c2.img)`, where `c1.real` and `c2.real` represent the real parts of the complex numbers `c1` and `c2`, and `c1.img` and `c2.img` represent the imaginary parts of the complex numbers `c1` and `c2`. 
 
-- Da mesma forma, a parte imaginária do número resultante é calculada pela fórmula `(c1.real * c2.img) + (c1.img * c2.real)`. 
+- Similarly, the imaginary part of the resulting number is calculated by the formula `(c1.real * c2.img) + (c1.img * c2.real)`. 
 
-- Por fim, o número complexo `multiplicado`, contendo a parte real e a parte imaginária calculadas, é retornado pela função como resultado da multiplicação dos números complexos `c1` e `c2`.
+- Finally, the complex number `multiplied`, containing the calculated real and imaginary parts, is returned by the function as the result of the multiplication of the complex numbers `c1` and `c2`.
  * @param[in] c1, c2
- * @param[out] multiplicado
+ * @param[out] multiplied
  * */
 complexo multcomp(complexo c1, complexo c2)
 {