Vectores y Matrices

Los vectores se representan como listas, las matrices como listas de listas

{a, b, c} vector (a, b, c)
{{a, b}, {c, d}} matriz (a   b)          c   d

In[31]:=

m = {{a, b}, {c, d}}

Out[31]=

{{a, b}, {c, d}}

La primera fila

In[32]:=

m[[1]]

Out[32]=

{a, b}

m_12

In[33]:=

m[[1, 2]]

Out[33]=

b

un vector

In[34]:=

v = {x, y}

Out[34]=

{x, y}

elementos no definidos se trabajan como escalares

In[35]:=

p v + q

Out[35]=

{q + p x, q + p y}

Los vectores (y matrices) se suman componente a componente

In[36]:=

v + {xa, ya} + {xxa, yya}

Out[36]=

{x + xa + xxa, y + ya + yya}

In[37]:=

m + m

Out[37]=

{{2 a, 2 b}, {2 c, 2 d}}

La multiplicación entre vectores no está definida (se obtiene una lista con multiplicación de elementos término a término para objetos de igual tamaño)

In[38]:=

v v

Out[38]=

{x^2, y^2}

In[39]:=

v m

Out[39]=

{{a x, b x}, {c y, d y}}

In[40]:=

m v

Out[40]=

{{a x, b x}, {c y, d y}}

In[44]:=

m m

Out[44]=

{{a^2, b^2}, {c^2, d^2}}

El producto punto (escalar)

In[41]:=

v . v

Out[41]=

x^2 + y^2

In[42]:=

m . v

Out[42]=

{a x + b y, c x + d y}

In[43]:=

v . m

Out[43]=

{a x + c y, b x + d y}

In[45]:=

m . m

Out[45]=

{{a^2 + b c, a b + b d}, {a c + c d, b c + d^2}}

In[46]:=

v . m . v

Out[46]=

x (a x + c y) + y (b x + d y)

v=. m=.

Dada la forma en que Mathematica trabaja las listas no hay necesidad de distinguir entre vectores columna y vectores fila

Funciones para vectores:

Table[f, {i, n}] construye un vector de longitud n evaluando f con i = 1, 2, ..., n
Array[a, n] construye un vector de longitud n de la forma {a[1], a[2], .., a[n]}
Range[n] crea el vector {1, 2, ... n}
Range[n_1, n_2] crea el vector {n_1, n_1 + 1, ... n_2}
Range[n_1, n_2, dn] crea el vector {n_1, n_1 + dn, ... n_2}
vec[[i]] o Part[vec, i] el i - ésimo elemento de vec
Length[vec] cantidad de elementos de vec
ColumnForm[vec] imprime los elementos de vec en una columna
c v multiplicación por escalar c
a . b producto punto
Cross[a, b] producto cruz (a×b)
Norm[v] norma

Funciones para matrices:

Table[f, {i, m}, {j, n}] construye una matriz m×n evaluando f con i de  1 a m y j de 1 a n
Array[a, {m, n}] construye  una matriz m×n  con el elemento i, j  igual a a[i, j]
IdentityMatrix[n] crea una matriz identidad de n×n
DiagonalMatrix[lista] genera una matriz cuadrada con los elementos de lista en  la diagonal
mat[[i]] o Part[mat, i] la i - ésima fila de mat
mat[[All, j]] o Part[mat, All, j] la j - ésima columna de mat
mat[[i, j]] o Part[mat, i, j] el elemento i, j de mat
Dimensions[mat] dimensiones de mat
MatrixForm[mat] muestra mat en forma de matriz

In[47]:=

Table[i + j, {i, 3}, {j, 3}]

Out[47]=

{{2, 3, 4}, {3, 4, 5}, {4, 5, 6}}

In[48]:=

%//MatrixForm

Out[48]//MatrixForm=

( 2   3   4 )            3   4   5            4   5   6

In[52]:=

Array[a, 4]//MatrixForm

Out[52]//MatrixForm=

( a[1] )            a[2]            a[3]            a[4]

In[51]:=

Array[p, {3, 2}]//MatrixForm

Out[51]//MatrixForm=

( p[1, 1]   p[1, 2] )            p[2, 1]   p[2, 2]            p[3, 1]   p[3, 2]

In[53]:=

Dimensions[Array[p, {3, 2}]]

Out[53]=

{3, 2}

In[54]:=

DiagonalMatrix[{a, b, c}]

Out[54]=

{{a, 0, 0}, {0, b, 0}, {0, 0, c}}

c m multiplica por escalar
a . b product entre matrices
Inverse[m] inversa de matriz
MatrixPower[m, n]                                                  th StyleBox[FormBox[RowBox[{n, Cell[BoxData[  ], InlineFormula],  potencia de una matriz }], TraditionalForm]]
Det[m] determinante
Tr[m] traza
Transpose[m] traspuesta
Eigenvalues[m] valores propios
Eigenvectors[m] vectores propios

In[59]:=

m//MatrixForm

Out[59]//MatrixForm=

( a   b )            c   d

In[56]:=

Det[m]

Out[56]=

-b c + a d

In[58]:=

Transpose[m]//MatrixForm

Out[58]//MatrixForm=

( a   c )            b   d

In[60]:=

Inverse[m]//MatrixForm

Out[60]//MatrixForm=

(     d              b      )           ----------    -----------           -b ...               c            a           -----------   ----------            -b c + a d   -b c + a d

In[61]:=

h = Table[1/(i + j - 1), {i, 3}, {j, 3}]

Out[61]=

{{1, 1/2, 1/3}, {1/2, 1/3, 1/4}, {1/3, 1/4, 1/5}}

In[62]:=

h//MatrixForm

Out[62]//MatrixForm=

(     1   1 )               -   -           1   2   3            1   1   1           -   -   -           2   3   4            1   1   1           -   -   -           3   4   5

In[63]:=

Inverse[h]

Out[63]=

{{9, -36, 30}, {-36, 192, -180}, {30, -180, 180}}

In[64]:=

h . %//MatrixForm

Out[64]//MatrixForm=

( 1   0   0 )            0   1   0            0   0   1

In[65]:=

m=. h=.

In[67]:=

r = Table[i + j + 1, {i, 3}, {j, 3}]

Out[67]=

{{3, 4, 5}, {4, 5, 6}, {5, 6, 7}}

In[68]:=

Eigenvalues[r]

Out[68]=

{1/2 (15 + 249^(1/2)), 1/2 (15 - 249^(1/2)), 0}

In[69]:=

%//N

Out[69]=

{15.3899, -0.389867, 0.}

In[70]:=

rn = N[r]

Out[70]=

{{3., 4., 5.}, {4., 5., 6.}, {5., 6., 7.}}

In[71]:=

Eigenvalues[rn]

Out[71]=

{15.3899, -0.389867, -1.49955*10^-16}

r=. rn=.


Created by Mathematica  (August 6, 2004)