Minicurso de Python para Matemática

Python para Matemática Mini-Notas de Aula 3 Elementos da programação estruturada 5 Gráficos

Compre o livro ou o e-book deste material aqui! Consulte outras formas de colaborar.

4 Elementos da computação matricial

Nesta seção, vamos explorar a NumPy (Numerical Python), biblioteca para tratamento numérico de dados. Ela é extensivamente utilizada nos mais diversos campos da ciência e da engenharia. Aqui, vamos nos restringir a introduzir algumas de suas ferramentas para a computação matricial.

Usualmente, a biblioteca é importada como segue

⬇

1import numpy as np

4.1 NumPy array

Um numpy.array é uma tabela de valores (vetor, matriz ou multidimensional) e contém informação sobre os dados brutos, indexação e como interpretá-los. Os elementos são todos do mesmo tipo (diferente de uma lista Python), referenciados pela propriedade dtype. A indexação dos elementos pode ser feita por um tuple de inteiros não negativos, por booleanos, por outro numpy.array ou por números inteiros. O ndim de um numpy.array é seu número de dimensões (chamadas de axes¹¹¹¹endnote: ¹¹axes, do inglês, plural de axis, eixo.). O numpy.ndarray.shape é um tuple de inteiros que fornece seu tamanho (número de elementos) em cada dimensão. Sua inicialização pode ser feita usando-se listas simples ou encadeadas. Por exemplo,

⬇

1a = np.array([1, 3, -1, 2])

2print(a)

[ 1 3 -1 2]

⬇

1a.dtype

dtype('int64')

⬇

1a.shape

(4,)

⬇

1a[2]

-1

⬇

1a[1:3]

array([ 3, -1])

temos um numpy.array de números inteiros com quatro elementos dispostos em um único axis (eixo). Podemos interpretá-lo como uma representação de um vetor linha ou coluna, i.e.

a=(1,3,-1,2)

(28)

vetor coluna ou $a^{T}$ vetor linha.

Outro exemplo,

⬇

1a = np.array([[1.0,2,3],

2 [-3,-2,-1]])

3a.dtype

dtype('float64')

⬇

1a.shape

(2, 3)

⬇

1a[1,1]

-2.0

temos um numpy.array de números decimais (float) dispostos em um arranjo com dois axes (eixos). O primeiro axis tem tamanho $2$ e o segundo tem tamanho $3$ . Ou seja, podemos interpretá-lo como uma matriz de duas linhas e três colunas. Podemos fazer sua representação algébrica como

a=\begin{bmatrix}1&2&3\\ -3&-2&-1\end{bmatrix}

(29)

Exercício 4.1.1.

Use numpy.array para alocar:

a)

o vetor

$v=\left(-5,\pi,\operatorname{sen}(\pi/3)\right)$ (30)
b)

a matriz

$A=\begin{bmatrix}-1&\displaystyle\frac{1}{3}\\[10.00002pt] 2&\displaystyle\sqrt{2}\\[10.00002pt] \displaystyle e^{-1}&-3\\ \end{bmatrix}$ (31)

Resposta 0.

⬇

1import numpy as np

2# a)

3v = np.array([-5., np.pi, np.sin(np.pi/3)])

4print('v = ', v)

5# b)

6A = np.array([[-1., 1./3],

7 [2., np.sqrt(2)],

8 [np.exp(-1.), -3.]])

9print('A = \n', A)

4.1.1 Inicialização de um array

O NumPy conta com úteis funções de inicialização de numpy.array. Vejam algumas das mais frequentes:

•

numpy.zeros: inicializa um numpy.array com todos seus elementos iguais a zero.

⬇

1np.zeros(2)

⬇

array([0., 0.])
•

numpy.ones: inicializa um numpy.array com todos seus elementos iguais a $1$ .

⬇

1np.ones((3,2), dtype='int')

⬇

array([[1, 1],

[1, 1],

[1, 1]])
•

numpy.empty: inicializa um numpy.array sem alocar valores para seus elementos¹²¹²endnote: ¹²Atenção! No momento da alocação, os valores dos elementos serão dinâmicos conforme “lixo” da memória..

⬇

1np.empty(3)

⬇

array([4.9e-324, 1.5e-323, 2.5e-323])
•

numpy.arange: inicializa um numpy.array com uma sequência de elementos¹³¹³endnote: ¹³Similar à função Python range..

⬇

1np.arange(1,6,2)

⬇

array([1, 3, 5])
•

numpy.linspace(a, b[, num=n]): inicializa um numpy.array como uma sequência de elementos que começa em a, termina em b (incluídos) e contém n elementos igualmente espaçados.

⬇

1np.linspace(0, 1, num=5)

⬇

array([0. , 0.25, 0.5 , 0.75, 1. ])

Exercício 4.1.2.

Aloque a matriz escalar

A=\begin{bmatrix}-2&0&0\\ 0&-2&0\\ 0&0&-2\end{bmatrix}

(32)

como um numpy.array.

Resposta 0.

⬇

1import numpy as np

2A = -2*np.ones((3,3))

3print('A = \n', A)

Exercício 4.1.3.

Construa um numpy.array para alocar uma partição uniforme com $11$ pontos do intervalo $[0,1]$ . Ou seja, um arranjo $\boldsymbol{x}=(x_{1},x_{2},\dotsc,x_{n})$ , de elementos $x_{i}=(i-1)h$ , com passo $h=1/(n-1)$ .

Resposta 0.

⬇

1import numpy as np

2x = np.linspace(0., 1., 11)

3print('x = ', x)

4.1.2 Manipulação de arrays

Outras duas funções importantes no tratamento de arrays são:

•

numpy.reshape: permite a alteração da forma de um numpy.array.

⬇

1a = np.array([-2,-1])

2print(a)

⬇

[-2 -1]

⬇

1b = a.reshape(2,1)

2print(b)

⬇

[[-2]

[-1]]

O numpy.reshape também permite a utilização de um coringa -1 que será dinamicamente determinado de forma obter-se uma estrutura adequada. Por exemplo,

⬇

1a = np.array([[1,2],[3,4]])

2print(a)

⬇

[[1 2]

[3 4]]

⬇

1b = a.reshape((-1,1))

2print(b)

⬇

[[1]

[2]

[3]

[4]]
•

numpy.transpose: computa a transposta de uma matriz.

⬇

1a = np.array([[1,2],[3,4]])

2print(a)

⬇

[[1 2]

[3 4]]

⬇

1b = a.transpose()

2print(b)

⬇

[[1 3]

[2 4]]
•

numpy.concatenate: concatena arrays.

⬇

1a = np.array([1,2])

2b = np.array([2,3])

3c = np.concatenate((a,b))

4print(c)

⬇

[1 2 2 3]

⬇

1a = a.reshape((1,-1))

2b = b.reshape((1,-1))

3d = np.concatenate((a,b), axis=0)

4print(d)

⬇

[[1 2]

[2 3]]

Exercício 4.1.4.

Aloque o seguinte vetor como um numpy.array

\boldsymbol{a}=(2,3,-1,1,4,-5).

(33)

Então, use o método numpy.reshape para, a partir de b, alocar a matriz

A=\begin{bmatrix}-1&1\\ 4&5\end{bmatrix}

(34)

como um numpy.array.

Resposta 0.

⬇

1import numpy as np

2a = np.array([2, 3, -1, 1, 4, 5])

3A = a.reshape((3,-1))

Exercício 4.1.5.

Tendo em vista que

A=\begin{bmatrix}\frac{\sqrt{3}}{2}&-\frac{1}{2}\\ \frac{1}{2}&\frac{\sqrt{3}}{2}\end{bmatrix}

(35)

é uma matriz ortogonal¹⁴¹⁴endnote: ¹⁴ $A$ é dita matriz ortogonal, quando $A^{-1}=A^{T}$ ., compute $A^{-1}$ .

Resposta 0.

⬇

1import numpy as np

2A = np.array([[np.sqrt(3)/2, -1./2],

3 [1./2, np.sqrt(3)/2]])

4Ainv = A.transpose()

Exercício 4.1.6.

Considere o seguinte sistema de equações

	$\displaystyle 2x_{1}-x_{2}$	$\displaystyle=3$		(36)
	$\displaystyle x_{1}+3x_{2}$	$\displaystyle=-2$		(36)

Use numpy.array para alocar:

1.

a matriz de coeficientes deste sistema.
2.

o vetor dos termos constantes deste sistema.
3.

a matriz estendida deste sistema.

Resposta 0.

⬇

1import numpy as np

2# a)

3A = np.array([[2, -1],

4 [1, 3]])

5# b)

6b = np.array([3, -2])

7# c)

8E = np.concatenate((A, b.reshape(-1,1)), axis=1)

4.1.3 Operadores elemento-a-elemento

Os operadores aritméticos disponível no Python atuam elemento-a-elemento nos numpy.arrays. Por exemplo,

⬇

1a = np.array([1,2])

2b = np.array([2,3])

3a+b

array([3, 5])

⬇

1a-b

array([-1, -1])

⬇

1b*a

array([2, 6])

⬇

1a**b

array([1, 8])

⬇

12*b

array([4, 6])

O NumPy também conta com várias funções matemáticas elementares que operam elemento-a-elemento em arrays. Por exemplo,

⬇

1a = np.array([np.pi, np.sqrt(2)])

array([3.14159265, 1.41421356])

⬇

1np.sin(a)

array([1.22464680e-16, 9.87765946e-01])

⬇

1np.exp(a)

array([23.14069263, 4.11325038])

Exercício 4.1.7.

Compute os valores da função cosseno para os elementos do vetor

\boldsymbol{\theta}=\left(0.,30^{\circ},45^{\circ},60^{\circ},90^{\circ}\right).

(37)

Resposta 0.

⬇

1import numpy as np

2thta = np.array([0., np.pi/6, np.pi/4,

3 np.pi/3, np.pi/2])

4y = np.cos(thta)

4.2 Elementos da álgebra linear

O numpy conta com um módulo de álgebra linear, usualmente importado com

⬇

1import numpy.linalg as npla

4.2.1 Vetores

Um vetor podem ser alocado usando um numpy.array de um eixo (dimensão). Por exemplo,

	$\displaystyle x=(2,-1),$		(38)
	$\displaystyle y=(3,1,\pi)$		(39)

podem ser alocados com

⬇

1x = np.array([2,-1])

2print(x)

[ 2 -1]

⬇

1y = np.array([3, 1, np.pi])

2print(y)

[3. 1. 3.14159265]

Exercício 4.2.1.

Aloque cada um dos seguintes vetores como um numpy.array:

a)

$x=(1.2,-3.1,4)$
c)

$z=(\pi,\sqrt{2},e^{-2})$

Resposta 0.

⬇

1import numpy as np

2# a)

3x = np.array([1.2, -3.1, 4])

4print('x = ', x)

5# b)

6z = np.array([np.pi, np.sqrt(2.), np.exp(-2)])

7print('z = ', z)

4.2.2 Produto escalar e norma

Dados dois vetores

	$\displaystyle x=(x_{0},x_{1},\dotsc,x_{n-1}),$		(40)
	$\displaystyle y=(y_{0},y_{1},\dotsc,y_{n-1}),$		(41)

define-se o produto escalar por

x\cdot y=x_{0}y_{0}+x_{1}y_{1}+\cdots+x_{n-1}y_{n-1}.

(42)

Com o NumPy, podemos computá-lo com a função hlnumpy.dot. Por exemplo,

⬇

1x = np.array([-1, 0, 2])

2y = np.array([0, 1, 1])

3d = np.dot(x,y)

4print(d)

A norma $l_{2}$ de um vetor é definida por

\|x\|_{2}=\sqrt{\sum_{i=0}^{n-1}x_{i}^{2}}.

(43)

O NumPy conta com o método numpy.linalg.norm para computá-la. Por exemplo,

⬇

1nrm = npla.norm(y)

2print(nrm)

4.457533443631058

Exercício 4.2.2.

Faça um código para computar o produto escalar $x\cdot y$ sendo

	$\displaystyle x=(1.2,\ln(2),4),$		(44)
	$\displaystyle y=(\pi^{2},\sqrt{3},e)$		(45)

Resposta 0.

⬇

1import numpy as np

2x = np.array([1.2, np.log(2), 4])

3y = np.array([np.pi**2, np.sqrt(3), np.e])

4d = np.dot(x,y)

4.2.3 Matrizes

Uma matriz pode ser alocada como um numpy.array de dois eixos (dimensões). Por exemplo, as matrizes

	$\displaystyle A=\begin{bmatrix}2&-1&7\\ 3&1&0\end{bmatrix},$		(46)
	$\displaystyle B=\begin{bmatrix}4&0\\ 2&1\\ -8&6\end{bmatrix}$		(47)

podem ser alocadas como segue

⬇

1A = np.array([[2,-1,7],

2 [3,1,0]])

3print(A)

[[ 2 -1 7]

[ 3 1 0]]

⬇

1B = np.array([[4,0],

2 [2,1],

3 [-8,6]])

4print(B)

[[ 4 0]

[ 2 1]

[-8 6]]

Como já vimos, o NumPy conta com operadores elemento-a-elemento que podem ser utilizados na álgebra envolvendo arrays, logo também aplicáveis a matrizes (consulte a Subseção 4.1.3). Na sequência, vamos introduzir outras operações próprias deste tipo de objeto.

Exercício 4.2.3.

Aloque cada uma das seguintes matrizes como um numpy.array:

a)

$A=\begin{bmatrix}-1&2\\ 2&-4\\ 6&0\end{bmatrix}$ (48)
b)

$B=A^{T}$

Resposta 0.

⬇

1import numpy as np

2# a)

3A = np.array([[-1, 2],

4 [2, -4],

5 [6, 0]])

6# b)

7B = A.transpose()

Exercício 4.2.4.

Seja

⬇

1A = np.array([[2,1],[1,1],[-3,-2]])

Determine o formato (shape) dos seguintes arrays:

a)

A[:,0]
b)

A[:,0:1]
c)

A[1:3,0]
d)

A[1:3,0:1]
e)

A[1:3,0:2]

Resposta 0.

⬇

1import numpy as np

2# a)

3A = np.array([[2, 1],

4 [1, 1],

5 [-3, -2]])

6print('a)', A[:,0].shape)

7print('b)', A[:,0:1].shape)

8print('c)', A[1:3,0].shape)

9print('d)', A[1:3,0:1].shape)

10print('e)', A[1:3,0:2].shape)

4.2.4 Inicialização de matrizes

Além das inicializações de arrays já estudadas na Subseção 4.1.1, temos mais algumas que são particularmente úteis no caso de matrizes.

•

numpy.eye(n): retorna a matriz identidade $n\times n$ .

⬇

1I = np.eye(3)

2print(I)

⬇

[[1. 0. 0.],

[0. 1. 0.],

[0. 0. 1.]]
•

numpy.diag: extrai a diagonal ou constrói um numpy.array diagonal.

⬇

1D = np.diag([1,2,3])

2print(D)

⬇

[[1, 0, 0],

[0, 2, 0],

[0, 0, 3]]

Exercício 4.2.5.

Aloque a matriz dos coeficientes e o vetor dos termos constantes do seguinte sistema de equações

		$\displaystyle x_{1}=0$		(49)
		$\displaystyle-x_{i-1}+2x_{i}-x_{i+1}=h^{2}f_{i}$
		$\displaystyle x_{n}=0$

onde $f_{i}=\pi^{2}\sin(\pi x_{i})$ , $x_{i}=(i-1)h$ , $h=1/(n-1)$ , n=5.

Resposta 0.

⬇

1import numpy as np

2n = 5

3h = 1./(n-1)

4x = np.linspace(0., 1., n)

5b = np.pi**2*np.sin(np.pi*x)

6A = np.diag(2*np.ones(n)) + \

7 np.diag(-np.ones(n-1), k=-1) + \

8 np.diag(-np.ones(n-1), k=1)

9A[0,0] = 1.

10A[0,1] = 0.

11A[n-1,n-2] = 0.

12A[n-1,n-1] = 1.

13print('A = \n', A)

14print('b = \n', b)

4.2.5 Multiplicação de matrizes

A multiplicação da matriz $A=[a_{ij}]_{i,j=0}^{n-1,l-1}$ pela matriz $B=[b_{ij}]_{i,j=0}^{l-1,m-1}$ é a matriz $C=AB=[c_{ij}]_{i,j=0}^{n-1,m-1}$ tal que

c_{ij}=\sum_{k=0}^{l-1}a_{ik}b_{k,j}

(50)

O numpy tem a função numpy.matmul para computar a multiplicação de matrizes. Por exemplo, a multiplicação das matrizes dadas em (46) e (47), computamos

⬇

1C = np.matmul(A,B)

2print(C)

[[-50 41],

[ 14 1]]

Observação 4.2.1.(matmul, *, @)

É importante notar que numpy.matmul(A,B) é a multiplicação de matrizes, enquanto que * consiste na multiplicação elemento a elemento. Alternativamente a numpy.matmul(A,B) pode-se usar A @ B.

Exercício 4.2.6.

Aloque as matrizes

	$\displaystyle C=\begin{bmatrix}1&2&-1\\ 3&2&1\\ 0&-2&-3\end{bmatrix}$		(51)
	$\displaystyle D=\begin{bmatrix}2&3\\ 1&-1\\ 6&4\end{bmatrix}$		(52)
	$\displaystyle E=\begin{bmatrix}1&2&1\\ 0&-1&3\end{bmatrix}$		(53)

Então, se existirem, compute e forneça as dimensões das seguintes matrizes

a)

$C D$
b)

$D^{T}E$
c)

$D^{T}C$
d)

$D E$

Resposta 0.

⬇

1import numpy as np

2C = np.array([[1, 2, -1],

3 [3, 2, 1],

4 [0, -2, -3]])

5D = np.array([[2, 3],

6 [1, -1],

7 [6, 4]])

8E = np.array([[1, 2, 1],

9 [0, -1, 3]])

10print('a) CD = \n', C@D)

11print("b) não existe D'E")

12print("c) D'C = \n", C.T@C)

13print("d) DE = \n", D@E)

4.2.6 Traço e determinante de uma matriz

O numpy tem a função numpy.ndarray.trace para computar o traço de uma matriz (soma dos elementos de sua diagonal). Por exemplo,

⬇

1A = np.array([[-1,2,0],[2,3,1],[1,2,-3]])

2print('tr(A) = ', A.trace())

tr(A) = -1

Já, o determinante é fornecido no módulo numpy.linalg. Por exemplo,

⬇

1A = np.array([[-1,2,0],[2,3,1],[1,2,-3]])

2print('det(A) = ', npla.det(A))

det(A) = 25.000000000000007

Exercício 4.2.7.

Compute a solução do seguinte sistema de equações

$\displaystyle x_{1}-x_{2}+x_{3}$	$\displaystyle=-2$	(54)
$\displaystyle 2x_{1}+2x_{2}+x_{3}$	$\displaystyle=5$
$\displaystyle-x_{1}-x_{2}+2x_{3}$	$\displaystyle=-5$

pelo método de Cramer¹⁵¹⁵endnote: ¹⁵Gabriel Cramer, 1704 - 1752, matemático suíço. Fonte: Wikipédia: Gabriel Cramer..

Resposta 0.

⬇

1import numpy as np

2import numpy.linalg as npla

3# matriz dos coefs

4A = np.array([[1, -1, 1],

5 [2, 2, 1],

6 [-1, -1, 2]])

7# vetor dos termos consts

8b = np.array([-2, 5, -5])

9# mat aux A1

10A1 = A.copy()

11A1[:,0] = b

12# sol x1

13x1 = npla.det(A1)/npla.det(A)

14print('x1 = ', x1)

15# mat aux A2

16A2 = A.copy()

17A2[:,1] = b

18# sol x2

19x2 = npla.det(A2)/npla.det(A)

20print('x2 = ', x2)

21# mat aux A3

22A3 = A.copy()

23A3[:,2] = b

24# sol x3

25x3 = npla.det(A3)/npla.det(A)

26print('x3 = ', x3)

4.2.7 Posto e inversa de uma matriz

O posto (rank) de uma matriz é o número de linhas ou colunas linearmente independentes. O numpy conta com a função numpy.linalg.matrix_rank para computá-lo. Por exemplo,

⬇

1npla.matrix_rank(np.eye(3))

⬇

1A = np.array([[1,2,3],[-1,1,-1],[0,3,2]])

2npla.matrix_rank(A)

O método numpy.linalg.inv pode ser usado para computar a inversa de uma matriz full rank. Por exemplo,

⬇

1A = np.array([[1, 2, 3],

2 [-1, 1, -1],

3 [1, 3, 2]])

4Ainv = np.linalg.inv(A)

5print('Ainv @ A = \n', Ainv @ A)

Ainv @ A =

[[ 1.00000000e+00 -2.22044605e-16 -8.88178420e-16]

[ 0.00000000e+00 1.00000000e+00 0.00000000e+00]

[ 0.00000000e+00 -2.22044605e-16 1.00000000e+00]]

Exercício 4.2.8.

Compute, se possível, a matriz inversa de cada uma das seguintes matrizes

	$\displaystyle B=\begin{bmatrix}2&-1\\ -2&1\end{bmatrix}$		(55)
	$\displaystyle C=\begin{bmatrix}-2&0&1\\ 3&1&-1\\ 2&1&0\end{bmatrix}$		(56)

Verifique suas respostas.

Resposta 0.

⬇

1import numpy as np

2import numpy.linalg as npla

4def inv(A):

5 if (npla.matrix_rank(A) == A.shape[1]):

6 return npla.inv(A)

7 else:

8 print('Matriz não invertível.')

9 return None

11B = np.array([[2, -1],

12 [-2, 1]])

13print('inv(B) = \n', inv(B))

15A = np.array([[-2, 0, 1],

16 [3, 1, -1],

17 [2, 1, 0]])

18print('inv(A) = \n', inv(A))

4.2.8 Autovalores e autovetores de uma Matriz

Um auto-par $(\lambda,v)$ de uma matriz $A$ , $\lambda$ um escalar chamado de autovalor e $v\neq 0$ é um vetor chamado de autovetor, é tal que

A\lambda=\lambda v.

(57)

O numpy tem a função numpy.linalg.eig para computar os auto-pares de uma matriz. Por exemplo,

⬇

1lmbda, v = npla.eig(np.eye(3))

2print('autovalores = \n', lmbda)

3print('autovetores = \n', v)

autovalores =

[1. 1. 1.]

autovetores =

[[1. 0. 0.]

[0. 1. 0.]

[0. 0. 1.]]

Observamos que a função retorna um tuple de numpy.arrays, sendo que o primeiro contém os autovalores (repetidos conforme suas multiplicidades) e o segundo item é a matriz dos autovetores (dispostos nas colunas).

Exercício 4.2.9.

Compute os auto-pares da matriz

A=\begin{bmatrix}1&3&2\\ 3&2&-1\\ 2&-1&1\end{bmatrix}.

(58)

Então, verifique se, de fato, $Av=\lambda v$ para cada auto-par $(\lambda,v)$ computado.

Resposta 0.

⬇

1import numpy as np

2import numpy.linalg as npla

3A = np.array([[1, 3, 2],

4 [3, 2, -1],

5 [2, -1, 1]])

6lmbda, v = np.linalg.eig(A)

7# testando os auto-pares

8print(npla.norm(A @ v[:, 0] - lmbda[0] * v[:, 0]) < 1e-10)

9print(npla.norm(A @ v[:, 1] - lmbda[1] * v[:, 1]) < 1e-10)

10print(npla.norm(A @ v[:, 2] - lmbda[2] * v[:, 2]) < 1e-10)

Envie seu comentário

Aproveito para agradecer a todas/os que de forma assídua ou esporádica contribuem enviando correções, sugestões e críticas!

Este texto é disponibilizado nos termos da Licença Creative Commons Atribuição-CompartilhaIgual 4.0 Internacional. Ícones e elementos gráficos podem estar sujeitos a condições adicionais.

Política de uso de dados

Política de uso de dados

Minicurso de Python para Matemática

4 Elementos da computação matricial

4.1 NumPy array

Exercício 4.1.1.

Resposta 0.

4.1.1 Inicialização de um array

Exercício 4.1.2.

Resposta 0.

Exercício 4.1.3.

Resposta 0.

4.1.2 Manipulação de arrays

Exercício 4.1.4.

Resposta 0.

Exercício 4.1.5.

Resposta 0.

Exercício 4.1.6.

Resposta 0.

4.1.3 Operadores elemento-a-elemento

Exercício 4.1.7.

Resposta 0.

4.2 Elementos da álgebra linear

4.2.1 Vetores

Exercício 4.2.1.

Resposta 0.

4.2.2 Produto escalar e norma

Exercício 4.2.2.

Resposta 0.

4.2.3 Matrizes

Exercício 4.2.3.

Resposta 0.

Exercício 4.2.4.

Resposta 0.

4.2.4 Inicialização de matrizes

Exercício 4.2.5.

Resposta 0.

4.2.5 Multiplicação de matrizes

Observação 4.2.1.(matmul, *, @)

Exercício 4.2.6.

Resposta 0.

4.2.6 Traço e determinante de uma matriz

Exercício 4.2.7.

Resposta 0.

4.2.7 Posto e inversa de uma matriz

Exercício 4.2.8.

Resposta 0.

4.2.8 Autovalores e autovetores de uma Matriz

Exercício 4.2.9.

Resposta 0.

Envie seu comentário