@c /linearalgebra.texi/1.11/Fri Jan  5 17:01:04 2007//
@menu
* Introdução a linearalgebra::
* Definições para linearalgebra::
@end menu

@node Introdução a linearalgebra, Definições para linearalgebra, linearalgebra, linearalgebra
@section Introdução a linearalgebra

@code{linearalgebra} é uma colecção de funções para álgebra linear.

Exemplo:

@c ===beg===
@c load (linearalgebra)$
@c M : matrix ([1, 2], [1, 2]);
@c nullspace (M);
@c columnspace (M);
@c ptriangularize (M - z*ident(2), z);
@c M : matrix ([1, 2, 3], [4, 5, 6], [7, 8, 9]) - z*ident(3);
@c MM : ptriangularize (M, z);
@c algebraic : true;
@c tellrat (MM [3, 3]);
@c MM : ratsimp (MM);
@c nullspace (MM);
@c M : matrix ([1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]);
@c columnspace (M);
@c apply ('orthogonal_complement, args (nullspace (transpose (M))));
@c ===end===
@example
(%i1) load (linearalgebra);
Warning - you are redefining the Maxima function require_list
Warning - you are redefining the Maxima function matrix_size
Warning - you are redefining the Maxima function rank
(%o1) /usr/local/share/maxima/5.9.2/share/linearalgebra/linearalgebra.mac
(%i2) M : matrix ([1, 2], [1, 2]);
                            [ 1  2 ]
(%o2)                       [      ]
                            [ 1  2 ]
(%i3) nullspace (M);
                               [  1  ]
                               [     ]
(%o3)                     span([   1 ])
                               [ - - ]
                               [   2 ]
(%i4) columnspace (M);
                                [ 1 ]
(%o4)                      span([   ])
                                [ 1 ]
(%i5) ptriangularize (M - z*ident(2), z);
                         [ 1   2 - z   ]
(%o5)                    [             ]
                         [           2 ]
                         [ 0  3 z - z  ]
(%i6) M : matrix ([1, 2, 3], [4, 5, 6], [7, 8, 9]) - z*ident(3);
                     [ 1 - z    2      3   ]
                     [                     ]
(%o6)                [   4    5 - z    6   ]
                     [                     ]
                     [   7      8    9 - z ]
(%i7) MM : ptriangularize (M, z);
              [ 4  5 - z            6            ]
              [                                  ]
              [                2                 ]
              [     66        z    102 z   132   ]
              [ 0   --      - -- + ----- + ---   ]
(%o7)         [     49        7     49     49    ]
              [                                  ]
              [               3        2         ]
              [           49 z    245 z    147 z ]
              [ 0    0    ----- - ------ - ----- ]
              [            264      88      44   ]
(%i8) algebraic : true;
(%o8)                         true
(%i9) tellrat (MM [3, 3]);
                         3       2
(%o9)                  [z  - 15 z  - 18 z]
(%i10) MM : ratsimp (MM);
               [ 4  5 - z           6           ]
               [                                ]
               [                2               ]
(%o10)         [     66      7 z  - 102 z - 132 ]
               [ 0   --    - ------------------ ]
               [     49              49         ]
               [                                ]
               [ 0    0             0           ]
(%i11) nullspace (MM);
                        [        1         ]
                        [                  ]
                        [   2              ]
                        [  z  - 14 z - 16  ]
                        [  --------------  ]
(%o11)             span([        8         ])
                        [                  ]
                        [    2             ]
                        [   z  - 18 z - 12 ]
                        [ - -------------- ]
                        [         12       ]
(%i12) M : matrix ([1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]);
                       [ 1   2   3   4  ]
                       [                ]
                       [ 5   6   7   8  ]
(%o12)                 [                ]
                       [ 9   10  11  12 ]
                       [                ]
                       [ 13  14  15  16 ]
(%i13) columnspace (M);
                           [ 1  ]  [ 2  ]
                           [    ]  [    ]
                           [ 5  ]  [ 6  ]
(%o13)                span([    ], [    ])
                           [ 9  ]  [ 10 ]
                           [    ]  [    ]
                           [ 13 ]  [ 14 ]
(%i14) apply ('orthogonal_complement, args (nullspace (transpose (M))));
                           [ 0 ]  [  1  ]
                           [   ]  [     ]
                           [ 1 ]  [  0  ]
(%o14)                span([   ], [     ])
                           [ 2 ]  [ - 1 ]
                           [   ]  [     ]
                           [ 3 ]  [ - 2 ]
@end example

@node Definições para linearalgebra,  , Introdução a linearalgebra, linearalgebra
@section Definições para linearalgebra

@deffn {Função} addmatrices (@var{f}, @var{M_1}, ..., @var{M_n})

@c REWORD -- THE RESULT IS NOT GENERALLY THE SUM OF M_1, ..., M_N
Usando a função @var{f} como a função de adição, retorne a adição das
matrizes @var{M_1}, ..., @var{M_n}. A função @var{f} deve aceitar qualquer número de
argumentos (uma função enária do Maxima).

Exemplos:

@c ===beg===
@c m1 : matrix([1,2],[3,4])$
@c m2 : matrix([7,8],[9,10])$
@c addmatrices('max,m1,m2);
@c addmatrices('max,m1,m2,5*m1);
@c ===end===
@example
(%i1) m1 : matrix([1,2],[3,4])$
(%i2) m2 : matrix([7,8],[9,10])$
(%i3) addmatrices('max,m1,m2);
(%o3) matrix([7,8],[9,10])
(%i4) addmatrices('max,m1,m2,5*m1);
(%o4) matrix([7,10],[15,20])
@end example

@end deffn

@deffn {Função} blockmatrixp (@var{M})

Retorna @code{true} se e somente se @var{M} for uma matriz e toda entrada de
@var{M} também for uma matriz.

@end deffn

@deffn {Função} columnop (@var{M}, @var{i}, @var{j}, @var{theta})

Se @var{M} for uma matriz, retorna a matriz que resulta de fazer a  
operação de coluna @code{C_i <- C_i - @var{theta} * C_j}. Se @var{M} não tiver uma linha
@var{i} ou @var{j}, emite uma mensagem de erro.

@end deffn

@deffn {Função} columnswap (@var{M}, @var{i}, @var{j})

Se @var{M} for uma matriz, troca as colunas @var{i} e @var{j}.  Se @var{M} não tiver uma coluna
@var{i} ou @var{j}, emite uma mensagem de erro.

@end deffn

@deffn {Função} columnspace (@var{M})

Se @var{M} for uma matriz, retorna @code{span (v_1, ..., v_n)}, onde o conjunto
@code{@{v_1, ..., v_n@}} é uma base para o espaço coluna de @var{M}.  A diferença entre o maior elemento e o menor elemento do 
conjunto vazio é @code{@{0@}}. Dessa forma, quando o espaço coluna tiver somente 
um membro, retorna @code{span ()}.

@end deffn

@deffn {Função} copy (@var{e})

Retorna uma cópia da expressão @var{e} do Maxima. Embora @var{e} possa ser qualquer
expressão do Maxima, Afunção @code{copy} é mais útil quando @var{e} for ou
uma lista ou uma matriz; considere:
@c ===beg===
load (linearalgebra);
m : [1,[2,3]]$
mm : m$
mm[2][1] : x$
m;
mm;
@c ===end===
@example 
(%i1) load("linearalgebra")$
(%i2) m : [1,[2,3]]$
(%i3) mm : m$
(%i4) mm[2][1] : x$
(%i5) m;
(%o5) [1,[x,3]]
(%i6) mm;
(%o6) [1,[x,3]]
@end example
Vamos tentar a mesma experiência, mas dessa vez tomemos @var{mm} como sendo uma cópia de @var{m}
@c ===beg===
m : [1,[2,3]]$
mm : copy(m)$
mm[2][1] : x$
m;
mm;
@c ===end===
@example
(%i7) m : [1,[2,3]]$
(%i8) mm : copy(m)$
(%i9) mm[2][1] : x$
(%i10) m;
(%o10) [1,[2,3]]
(%i11) mm;
(%o11) [1,[x,3]]
@end example
Dessa vez, a atribuição a @var{mm} não muda o valor de @var{m}.

@end deffn

@deffn {Função} cholesky (@var{M})
@deffnx {Função} cholesky (@var{M}, @var{corpo})

Retorna factorização de Cholesky da matriz hermitiana (or autoadjunta) 
@var{M}. O valor padrão para o segundo argumento é @code{generalring}. Para uma descrição dos
possíveis valores para @var{corpo}, veja @code{lu_factor}.

@end deffn

@deffn {Função} ctranspose (@var{M})

Retorna a matriz transposta conjugada complexa da matriz @var{M}. A função
@code{ctranspose} usa @code{matrix_element_transpose} para transpor cada elemento da matriz.

@end deffn

@deffn {Função} diag_matrix (@var{d_1}, @var{d_2},...,@var{d_n})

Retorna uma matriz diagonal matriz com entradas de diagonal @var{d_1}, @var{d_2},...,@var{d_n}.
Quando as entradas de diagonal forem matrizes, as entradas zero da matriz retornada
serão todas matrizes de tamanho apropriado; por exemplo:
@c ===beg===
@c load(linearalgebra)$
@c diag_matrix(diag_matrix(1,2),diag_matrix(3,4));
@c diag_matrix(p,q);
@c ===end===
@example
(%i1) load(linearalgebra)$

(%i2) diag_matrix(diag_matrix(1,2),diag_matrix(3,4));

                            [ [ 1  0 ]  [ 0  0 ] ]
                            [ [      ]  [      ] ]
                            [ [ 0  2 ]  [ 0  0 ] ]
(%o2)                       [                    ]
                            [ [ 0  0 ]  [ 3  0 ] ]
                            [ [      ]  [      ] ]
                            [ [ 0  0 ]  [ 0  4 ] ]
(%i3) diag_matrix(p,q);

                                   [ p  0 ]
(%o3)                              [      ]
                                   [ 0  q ]
@end example
@end deffn

@deffn {Função} dotproduct (@var{u}, @var{v})

Retorna o produto do ponto (produto escalar) dos vectores @var{u} e @var{v}.  Isso é o mesmo
que @code{conjugate (transpose (@var{u})) . @var{v}}.  Os argumentos @var{u} e @var{v} devem ser
vectores coluna.

@end deffn

@deffn {Função} eigens_by_jacobi (@var{A})
@deffnx {Função} eigens_by_jacobi (@var{A}, @var{tipo_corpo})

Calculam os autovalores e autovectores de @var{A} pelo método de rotações de Jacobi.
@var{A} deve ser uma matriz simétrica (mas essa matriz simétrica precisa não ser nem definida positiva e nem semidefinida positiva).
@var{tipo_corpo} indica o corpo computacional, pode ser ou @code{floatfield} ou @code{bigfloatfield}.
Se @var{tipo_corpo} não for especificado, o padrão é @code{floatfield}.

Os elementos de @var{A} devem ser números ou expressões que avaliam para números
via @code{float} ou @code{bfloat} (dependendo do valor de @var{tipo_corpo}).

Exemplos:
@c ===beg===
@c load (linearalgebra);
@c S : matrix ([1/sqrt(2), 1/sqrt(2)], [- 1/sqrt(2), 1/sqrt(2)]);
@c L : matrix ([sqrt(3), 0], [0, sqrt(5)]);
@c M : S . L . transpose (S);
@c eigens_by_jacobi (M);
@c float ([[sqrt(3), sqrt(5)], S]);
@c eigens_by_jacobi (M, bigfloatfield);
@c ===end===

@example
(%i1) load (linearalgebra);
(%o1) /home/robert/tmp/maxima-head/maxima/share/linearalgebra/li\
nearalgebra.mac
(%i2) S : matrix ([1/sqrt(2), 1/sqrt(2)], [- 1/sqrt(2), 1/sqrt(2)]);
                     [     1         1    ]
                     [  -------   ------- ]
                     [  sqrt(2)   sqrt(2) ]
(%o2)                [                    ]
                     [      1        1    ]
                     [ - -------  ------- ]
                     [   sqrt(2)  sqrt(2) ]
(%i3) L : matrix ([sqrt(3), 0], [0, sqrt(5)]);
                      [ sqrt(3)     0    ]
(%o3)                 [                  ]
                      [    0     sqrt(5) ]
(%i4) M : S . L . transpose (S);
            [ sqrt(5)   sqrt(3)  sqrt(5)   sqrt(3) ]
            [ ------- + -------  ------- - ------- ]
            [    2         2        2         2    ]
(%o4)       [                                      ]
            [ sqrt(5)   sqrt(3)  sqrt(5)   sqrt(3) ]
            [ ------- - -------  ------- + ------- ]
            [    2         2        2         2    ]
(%i5) eigens_by_jacobi (M);
The largest percent change was 0.1454972243679
The largest percent change was 0.0
number of sweeps: 2
number of rotations: 1
(%o5) [[1.732050807568877, 2.23606797749979], 
                        [  0.70710678118655   0.70710678118655 ]
                        [                                      ]]
                        [ - 0.70710678118655  0.70710678118655 ]
(%i6) float ([[sqrt(3), sqrt(5)], S]);
(%o6) [[1.732050807568877, 2.23606797749979], 
                        [  0.70710678118655   0.70710678118655 ]
                        [                                      ]]
                        [ - 0.70710678118655  0.70710678118655 ]
(%i7) eigens_by_jacobi (M, bigfloatfield);
The largest percent change was 1.454972243679028b-1
The largest percent change was 0.0b0
number of sweeps: 2
number of rotations: 1
(%o7) [[1.732050807568877b0, 2.23606797749979b0], 
                [  7.071067811865475b-1   7.071067811865475b-1 ]
                [                                              ]]
                [ - 7.071067811865475b-1  7.071067811865475b-1 ]
@end example

@end deffn

@deffn {Função} get_lu_factors (@var{x}) 

Quando @code{@var{x} = lu_factor (@var{A})}, então @code{get_lu_factors} retorna uma lista da 
forma @code{[P, L, U]}, onde @var{P} é uma matriz de permutação, @var{L} é triangular baixa com
a diagonal preenchida com a unidade, e @var{U} é triangular alta, e @code{@var{A} = @var{P} @var{L} @var{U}}.

@end deffn

@deffn {Função} hankel (@var{col})
@deffnx {Função} hankel (@var{col}, @var{lin})

Retorna uma matriz de Hankel @var{H}. A primeira coluna de @var{H} é @var{col};
excepto para a primeira entrada, a última linha de @var{H} é @var{lin}. O
valor padrão para @var{lin} é o vector nulo com o mesmo comprimento que @var{col}.

@end deffn

@deffn {Função} hessian (@var{f},@var{vars})

Retorna a matriz hessiana de @var{f} com relação às variáveis na lista
@var{vars}.  As entradas @var{i},@var{j} da matriz hessiana são
@var{diff(f vars[i],1,vars[j],1)}.

@end deffn

@deffn {Função} hilbert_matrix (@var{n})

Retorna the @var{n} by @var{n} matriz de Hilbert. Quando @var{n} não for um inteiro
positivo, emite uma mensagem de erro.

@end deffn

@deffn {Função} identfor (@var{M})
@deffnx {Função} identfor (@var{M}, @var{corpo})

Retorna uma matriz identidade que tem o mesmo tamanho que a matriz
@var{M}.  As entradas de diagonal da matriz identidade são a 
identidade multiplicativa do corpo @var{corpo}; o padrão para
@var{corpo} é @var{generalring}.

O primeiro argumento @var{M} pode ser uma  matriz quadrada ou um 
não matriz. Quando @var{M} for uma matriz, cada entrada de @var{M} pode ser uma
matriz quadrada -- dessa forma @var{M} pode ser uma matriz de bloco do Maxima. A
matriz pode ser de bloco para qualquer (finita) quantidade de níveis.

Veja também @code{zerofor}

@end deffn

@deffn {Função} invert_by_lu (@var{M}, @var{(rng generalring)})

Inverte a matriz @var{M} através de factorização linear alta (LU).  A factorização LU
é concluída usando o anel @var{rng}.

@end deffn

@deffn {Função} kronecker_product (@var{A}, @var{B})

Retorna o produto de Kronecker das matrizes @var{A} e @var{B}.

@end deffn

@deffn {Função} listp (@var{e}, @var{p})
@deffnx {Função} listp (@var{e})

Recebendo um argumento opcional @var{p}, retorna @code{true} se @var{e} for 
uma lista do Maxima e @var{p} avalia para @code{true} para elemento da lista.
Quando @code{listp} não recebe o argumento opcional, retorna @code{true} se @var{e} for 
uma lista do Maxima.  em todos os outros casos, retorna @code{false}.

@end deffn

@deffn {Função} locate_matrix_entry (@var{M}, @var{r_1}, @var{c_1}, @var{r_2}, @var{c_2}, @var{f}, @var{rel})

O primeiro argumento deve ser uma matriz; os argumentos que vão de
@var{r_1} até @var{c_2} determinam um sub-matriz de @var{M} que consiste de
linhas que vão de @var{r_1} até @var{r_2} e colunas que vão de @var{c_1} até @var{c_2}. 

Encontra uma entrada na sub-matriz @var{M} que satisfaz alguma propriedade. 
Existem três casos:

(1) @code{@var{rel} = 'bool} e @var{f} um predicado: 

Examina a sub-matriz da esquerda para a direita e de cima para baixo,
e retorna o índice da primeira entrada que satisfizer o 
predicado @var{f}. Se nenhuma entrada da matriz satisfizer o predicado @var{f}, retorna @code{false}.

(2) @code{@var{rel} = 'max} e @var{f} avaliar para um número real:

Examina a sub-matriz procurando por uma entrada que maximize @var{f}.
Retorna retorna o índice da entrada maximizada.

(3) @code{@var{rel} = 'min} e @var{f} avaliar para um número real:

Examina a sub-matriz procurando por uma entrada que minimize @var{f}. 
Retorna o índice de uma entrada minimizada.

@end deffn

@deffn {Função} lu_backsub (@var{M}, @var{b})

Quando @code{@var{M} = lu_factor (@var{A}, @var{corpo})},
então @code{lu_backsub (@var{M}, @var{b})} resolve o sistema
linear @code{@var{A} @var{x} = @var{b}}.

@end deffn

@deffn {Função} lu_factor (@var{M}, @var{corpo})

Retorna uma lista da forma @code{[@var{LU}, @var{perm}, @var{corpo}]}, 
ou da forma @code{[@var{LU}, @var{perm}, @var{cmp}, @var{baixo-cnd} @var{alto-cnd}]}, onde

  (1) A matriz @var{LU} contéa factorização de @var{M} na forma enpacotada. Forma
      empacotada significa três coisas: Primeiro, as linhas de @var{LU} são permutadas confirme a 
      lista @var{perm}.  Se, por exemplo, @var{perm} for a lista list @code{[3,2,1]}, a primeira linha actual 
      da factorização @var{LU} será a terceira linha da matriz @var{LU}. Segundo,
      o factor triangular baixo de m é a parte triangular baixa de @var{LU} com as
      entradas de diagonal todas substituídas pela unidade. Terceiro, o factor triangular alto de 
      @var{M} é a parte triangular alta de @var{LU}.  

  (2) Quando o corpo for ou @code{floatfield} ou @code{complexfield},
      os números @var{baixo-cnd} e @var{alto-cnd} serão associados baixo e alto para o 
      número condicional de norma infinita de @var{M}.  Para todos os corpos (fields), o número condicional de norma infinita 
      não pode ser estimado; para tais corpos, @code{lu_factor} retorna uma lista com dois itens.
      Ambos o baixo e o alto associado  podem diferir de seus verdadeiros valores de 
      factores arbitráriamente grandes. (Veja também @code{mat_cond}.)
   
  O argumento @var{M} deve ser a matriz quadrada.

  O argumento opcional @var{cmp} deve ser um símbolo que determine um anel ou corpo. Os corpos e anéis 
  predefinidos são:

    (a) @code{generalring} -- o anel de expressões do Maxima,
    (b) @code{floatfield} --  o corpo dos números em ponto flutuante do tipo de precisão dupla,
    (c) @code{complexfield} --  o corpo dos números complexos em ponto flutuante do 
        tipo de precisão dupla,
    (d) @code{crering}  -- o anel das expressões racionais canónicas (CRE) do Maxima,
    (e) @code{rationalfield} -- o corpo dos números racionais,
    (f) @code{runningerror} -- rastro de todos os erros de arredondamento de números em ponto flutuante,
     (g) @code{noncommutingring} -- o anel de expressões do Maxima onde multiplicação for o
        operador ponto não comutativo.       

Quando o corpo for @code{floatfield}, @code{complexfield}, ou
@code{runningerror}, o algoritmo usa pivotagem parcial; para todos
os outros corpos, linhas são comutadas somente quando necessário para evitar um piv@^o
nulo.

A adição aritmética em ponto flutuante não é associativa, então o significado
de 'corpo' difere da definição matemática.

Um membro do corpo @code{runningerror} é uma lista do Máxima de dois membros
da forma @code{[x,n]},onde @var{x} é um número em onto flutuante e
@code{n} é um inteiro. A diferença relativa entre o valor de
'verdadeiro' de @code{x} e @code{x} é aproximadamente associado pelo épsilon da
máquina vezes @code{n}. O erro de execução associado arrasta alguns termos
da ordem do quadrado do épsilon da máquina.

Não existe interface de utilizador definida um novo anel. Um utilizador que estiver
familiazrizado com o Lisp Comum está apto para definir um novo corpo.  Para fazer
isso, um utilizador deve definir funções para as operações aritméticas e
funções para conversão para a representação de corpo do Máxima e
vice-versa. Adicionalmente, para corpos ordenados (onde a pivotagem parcial será
usada), um uduário deve definir funções para módulo e para
comparar membros do corpo.  Após isso tudo que resta é definir uma
estrutura de Lisp Comum @code{mring}.  O ficheiro @code{mring} tem muitos
exemplos.
 
Para calcular a factorização, a primeira tarefa é converter cada entrada de
matriz para um elemento do corpo indicado. Quando a cnversão não for
possível, a factorização encerra com uma mensagem de erro. Elementos do
corpo não precisam ser expressões do Maxima.  Elementos do
@code{complexfield}, por exemplo, são números complexos do Lisp Comum. Dessa forma
após calcular a factorização, como entradas da matriz devem ser
convertidas para expressões do Maxima.

Veja também  @code{get_lu_factors}.

Exemplos:
@c ===beg===
@c load (linearalgebra);
@c w[i,j] := random (1.0) + %i * random (1.0);
@c showtime : true$
@c M : genmatrix (w, 100, 100)$
@c lu_factor (M, complexfield)$
@c lu_factor (M, generalring)$
@c showtime : false$
@c M : matrix ([1 - z, 3], [3, 8 - z]);
@c lu_factor (M, generalring);
@c get_lu_factors (%);
@c %[1] . %[2] . %[3];
@c ===end===
@example
(%i1) load (linearalgebra);
Warning - you are redefining the Maxima function require_list
Warning - you are redefining the Maxima function matrix_size
Warning - you are redefining the Maxima function rank
(%o1) /usr/local/share/maxima/5.9.2/share/linearalgebra/linearalgebra.mac
(%i2) w[i,j] := random (1.0) + %i * random (1.0);
(%o2)          w     := random(1.) + %i random(1.)
                i, j
(%i3) showtime : true$
Evaluation took 0.00 seconds (0.00 elapsed)
(%i4) M : genmatrix (w, 100, 100)$
Evaluation took 7.40 seconds (8.23 elapsed)
(%i5) lu_factor (M, complexfield)$
Evaluation took 28.71 seconds (35.00 elapsed)
(%i6) lu_factor (M, generalring)$
Evaluation took 109.24 seconds (152.10 elapsed)
(%i7) showtime : false$

(%i8) M : matrix ([1 - z, 3], [3, 8 - z]); 
                        [ 1 - z    3   ]
(%o8)                   [              ]
                        [   3    8 - z ]
(%i9) lu_factor (M, generalring);
               [ 1 - z         3        ]
               [                        ]
(%o9)         [[   3            9       ], [1, 2]]
               [ -----  - z - ----- + 8 ]
               [ 1 - z        1 - z     ]
(%i10) get_lu_factors (%);
                  [   1    0 ]  [ 1 - z         3        ]
        [ 1  0 ]  [          ]  [                        ]
(%o10) [[      ], [   3      ], [                9       ]]
        [ 0  1 ]  [ -----  1 ]  [   0    - z - ----- + 8 ]
                  [ 1 - z    ]  [              1 - z     ]
(%i11) %[1] . %[2] . %[3];
                        [ 1 - z    3   ]
(%o11)                  [              ]
                        [   3    8 - z ]
@end example

@end deffn

@deffn {Função} mat_cond (@var{M}, 1)
@deffnx {Função} mat_cond (@var{M}, inf)

Retorna o número condiciona da norma de ordem @var{p} da matriz
@var{m}. Os valores permitidos para @var{p} são 1 e @var{inf}.  Essa
função utiliza a factorização linear alta para inverter a matriz @var{m}. Dessa forma
o tempode execução para @code{mat_cond} é proporcional ao cubo do
tamanho da matriz; @code{lu_factor} determina as associaçãoes baixa e alta
para o número de condição de norma infinita em tempo proporcional ao
quadrado do tamanho da matriz.

@end deffn

@deffn {Função} mat_norm (@var{M}, 1)
@deffnx {Função} mat_norm (@var{M}, inf)
@deffnx {Função} mat_norm (@var{M}, frobenius)

Retorna a matriz de norma @var{p} da matriz @var{M}.  Os valores permitidos para @var{p} são
1, @code{inf}, e @code{frobenius} (a norma da matriz de Frobenius). A matriz @var{M} pode ser
uma matriz não de bloco.

@end deffn

@deffn {Função} matrixp (@var{e}, @var{p})
@deffnx {Função} matrixp (@var{e})

Fornecendo um argumento opcional @var{p}, @code{matrixp} retorna @code{true} se @var{e} for
uma matriz e @var{p} avaliar para @code{true} para todo elemento da matriz.
Quando a @code{matrixp} não for fornecido umargumento opcional, retorna @code{true} 
se @code{e} for uma matriz.  em todos os outros casos, retorna @code{false}.

Veja também @code{blockmatrixp}

@end deffn

@deffn {Função} matrix_size (@var{M})

Retorna uma lista com dois elementos que fornecem o número de linhas e colunas, respectivamente
da matriz @var{M}.

@end deffn

@deffn {Função} mat_fullunblocker (@var{M})

Se @var{M} for uma matriz de bloco, expande todos os blocos da matriz em todos os níveis. Se @var{M} for uma matriz,
retorna @var{M}; de outra forma, emite uma mensagem de erro. 

@c precisa de exemplo aqui

@end deffn

@deffn {Função} mat_trace (@var{M})

Retorna o traço da matriz @var{M}. Se @var{M} não for uma matriz, retorna uma
forma substantiva. Quando @var{M} for uma matriz de bloco, @code{mat_trace(M)} retorna
o mesmo valor retornado por @code{mat_trace(mat_unblocker(m))}.

@end deffn

@deffn {Função} mat_unblocker (@var{M})

Se @var{M} for uma matriz de bloco, @code{mat_unbloker} desfaz o bloco de @var{M} um nível. Se @var{M} for uma matriz, 
@code{mat_unblocker (M)} retorna @var{M}; de outra forma, emite uma mensagem de erro.

Dessa forma se cada entrada de @var{M} for matriz, @code{mat_unblocker (M)} retorna uma 
matriz "desblocada", mas se cada entrada de @var{M} for uma matriz de bloco, @code{mat_unblocker (M)} 
retorna uma matriz de bloco com um nível de bloco a menos.

Se usar matrizes de bloco, muito provavelmente irá querer escolher @code{matrix_element_mult} para 
@code{"."} e @code{matrix_element_transpose} para @code{'transpose}. Veja também @code{mat_fullunblocker}.

Exemplo:

@c ===beg===
@c load (linearalgebra);
@c A : matrix ([1, 2], [3, 4]);
@c B : matrix ([7, 8], [9, 10]);
@c matrix ([A, B]);
@c mat_unblocker (%);
@c ===end===
@example
(%i1) load (linearalgebra);
Warning - you are redefining the Maxima function require_list
Warning - you are redefining the Maxima function matrix_size
Warning - you are redefining the Maxima function rank
(%o1) /usr/local/share/maxima/5.9.2/share/linearalgebra/linearalgebra.mac
(%i2) A : matrix ([1, 2], [3, 4]);
                            [ 1  2 ]
(%o2)                       [      ]
                            [ 3  4 ]
(%i3) B : matrix ([7, 8], [9, 10]);
                            [ 7  8  ]
(%o3)                       [       ]
                            [ 9  10 ]
(%i4) matrix ([A, B]);
                     [ [ 1  2 ]  [ 7  8  ] ]
(%o4)                [ [      ]  [       ] ]
                     [ [ 3  4 ]  [ 9  10 ] ]
(%i5) mat_unblocker (%);
                         [ 1  2  7  8  ]
(%o5)                    [             ]
                         [ 3  4  9  10 ]
@end example

@end deffn

@deffn {Função} nonnegintegerp (@var{n})

Retorna @code{true} se e somente se @code{@var{n} >= 0} e @var{n} for um inteiro.

@end deffn

@deffn {Função} nullspace (@var{M})

Se @var{M} for uma matriz, retorna @code{span (v_1, ..., v_n)}, onde o conjunto @code{@{v_1, ..., v_n@}}
é uma base para o espaço nulo de @var{M}.  A diferença entre o maior elemento e o menor elemento do conjunto vazio é  @code{@{0@}}.  
Dessa forma, quando o espaço nulo tiver somente um membro, retorna @code{span ()}.

@end deffn

@deffn {Função} nullity (@var{M})

Se @var{M} for uma matriz, retorna a dimensão do espaço nulo de @var{M}.

@end deffn

@deffn {Função} orthogonal_complement (@var{v_1}, ..., @var{v_n})

Retorna @code{span (u_1, ..., u_m)}, onde o conjunto @code{@{u_1, ..., u_m@}} é uma 
base para o complemento ortogonal do conjunto @code{(v_1, ..., v_n)}.

Cada vector no intervalo de @var{v_1} até @var{v_n} deve ser um vector coluna.

@end deffn

@deffn {Função} polynomialp (@var{p}, @var{L}, @var{coeffp}, @var{exponp})
@deffnx {Função} polynomialp (@var{p}, @var{L}, @var{coeffp})
@deffnx {Função} polynomialp (@var{p}, @var{L})

Retorna @code{true} se @var{p} for um polinómio nas variáveis da lista @var{L},
O predicado @var{coeffp} deve avaliar para @code{true} para cada
coeficiente, e o predicado @var{exponp} deve avaliar para @code{true} para todos os 
expoentes das variáveis na lista @var{L}. Se quiser usar um valor
personalizado para @var{exponp}, deverá fornecer @var{coeffp} com um valor mesmo se quiser
o valor padrão para @var{coeffp}.

@c WORK THE FOLLOWING INTO THE PRECEDING
@code{polynomialp (@var{p}, @var{L}, @var{coeffp})} é equivalente a
@code{polynomialp (@var{p}, @var{L}, @var{coeffp}, 'nonnegintegerp)}.

@code{polynomialp (@var{p}, @var{L})} é equivalente a
@code{polynomialp (@var{p}, L@var{,} 'constantp, 'nonnegintegerp)}.

O polinómio não precisa ser expandido:

@c ===beg===
@c load (linearalgebra);
@c polynomialp ((x + 1)*(x + 2), [x]);
@c polynomialp ((x + 1)*(x + 2)^a, [x]);
@c ===end===
@example
(%i1) load (linearalgebra);
Warning - you are redefining the Maxima function require_list
Warning - you are redefining the Maxima function matrix_size
Warning - you are redefining the Maxima function rank
(%o1) /usr/local/share/maxima/5.9.2/share/linearalgebra/linearalgebra.mac
(%i2) polynomialp ((x + 1)*(x + 2), [x]);
(%o2)                         true
(%i3) polynomialp ((x + 1)*(x + 2)^a, [x]);
(%o3)                         false
@end example

Um exemplo usando um valor personalizado para @code{coeffp} e para @code{exponp}:

@c ===beg===
@c load (linearalgebra);
@c polynomialp ((x + 1)*(x + 2)^(3/2), [x], numberp, numberp);
@c polynomialp ((x^(1/2) + 1)*(x + 2)^(3/2), [x], numberp, numberp);
@c ===end===
@example
(%i1) load (linearalgebra);
Warning - you are redefining the Maxima function require_list
Warning - you are redefining the Maxima function matrix_size
Warning - you are redefining the Maxima function rank
(%o1) /usr/local/share/maxima/5.9.2/share/linearalgebra/linearalgebra.mac
(%i2) polynomialp ((x + 1)*(x + 2)^(3/2), [x], numberp, numberp);
(%o2)                         true
(%i3) polynomialp ((x^(1/2) + 1)*(x + 2)^(3/2), [x], numberp, numberp);
(%o3)                         true
@end example

Polinómios com duas variáveis:

@c ===beg===
@c load (linearalgebra);
@c polynomialp (x^2 + 5*x*y + y^2, [x]);
@c polynomialp (x^2 + 5*x*y + y^2, [x, y]);
@c ===end===
@example
(%i1) load (linearalgebra);
Warning - you are redefining the Maxima function require_list
Warning - you are redefining the Maxima function matrix_size
Warning - you are redefining the Maxima function rank
(%o1) /usr/local/share/maxima/5.9.2/share/linearalgebra/linearalgebra.mac
(%i2) polynomialp (x^2 + 5*x*y + y^2, [x]);
(%o2)                         false
(%i3) polynomialp (x^2 + 5*x*y + y^2, [x, y]);
(%o3)                         true
@end example

@end deffn

@deffn {Função} polytocompanion (@var{p}, @var{x})

Se @var{p} for um polinómio em @var{x}, retorna a atriz companheira de @var{p}. Para
um polinómio m@^onico @var{p} de grau @var{n},
temos @code{@var{p} = (-1)^@var{n} charpoly (polytocompanion (@var{p}, @var{x}))}.

Quando @var{p} não for um polinómio em @var{x}, emite uma mensagem de erro.

@end deffn

@deffn {Função} ptriangularize (@var{M}, @var{v})

Se @var{M} for uma matriz onde cada entrada dessa matriz for um polinómio em @var{v}, retorna 
a matriz @var{M2} tal que

(1) @var{M2} é triangular alta,

(2) @code{@var{M2} = @var{E_n} ... @var{E_1} @var{M}},
onde os elemetnos de @var{E_1} a @var{E_n} são matrizes elementares 
cujas entrada são polinómios em @var{v},

(3) @code{|det (@var{M})| = |det (@var{M2})|},

Nota: Essa função não verifica se toda entrada é um polinómio em @var{v}.  

@end deffn

@deffn {Função} rowop (@var{M}, @var{i}, @var{j}, @var{theta})

Se @var{M} for uma matriz, retorna a matriz que resulta de se fazer a  
operação de linha @code{R_i <- R_i - theta * R_j}. Se @var{M} não tiver uma linha
@var{i} ou @var{j}, emite uma mensagem de erro.

@end deffn

@deffn {Função} rank (@var{M})

Retorna o ranque daquela matriz @var{M}. O rank é a dimensão do
espaço coluna. Exemplo:
@c ===beg===
@c load (linearalgebra)$
@c rank(matrix([1,2],[2,4]));
@c rank(matrix([1,b],[c,d]));
@c ===end===
@example
(%i1) load (linearalgebra)$
WARNING: DEFUN/DEFMACRO: redefining function $COPY in
         /share/maxima/5.11.0/share/linearalgebra/linalg-utilities.lisp,
         was defined in
         /maxima-5.11.0/src/binary-clisp/comm2.fas
(%i2) rank(matrix([1,2],[2,4]));
(%o2)                                  1
(%i3) rank(matrix([1,b],[c,d]));
Proviso:  @{d - b c # 0@}
(%o3)                                  2
@end example

@end deffn


@deffn {Função} rowswap (@var{M}, @var{i}, @var{j})

Se @var{M} for uma matriz, permuta as linha @var{i} e @var{j}. Se @var{M} não tiver uma linha
@var{i} ou @var{j}, emite uma mensagem de erro.

@end deffn

@deffn {Função} toeplitz (@var{col})
@deffnx {Função} toeplitz (@var{col}, @var{lin})

Retorna uma matriz de Toeplitz @var{T}. a primeira coluna de @var{T} é @var{col};
excepto para a primeira entrada, a primeira linha de @var{T} é @var{lin}. O
padrão para @var{lin} é o conjugado complexo de @var{col}. Exemplo:
@c ===beg===
@c load(linearalgebra)$
@c toeplitz([1,2,3],[x,y,z]);
@c toeplitz([1,1+%i]);
@c ==end===
@example
(%i1) load(linearalgebra)$

(%i2)  toeplitz([1,2,3],[x,y,z]);

                                  [ 1  y  z ]
                                  [         ]
(%o2)                             [ 2  1  y ]
                                  [         ]
                                  [ 3  2  1 ]
(%i3)  toeplitz([1,1+%i]);

                              [   1     1 - %I ]
(%o3)                         [                ]
                              [ %I + 1    1    ]
@end example

@end deffn

@deffn {Função} vandermonde_matrix ([@var{x_1}, ..., @var{x_n}])

Retorna uma matriz @var{n} por @var{n} cuja @var{i}-ésima linha é 
@code{[1, @var{x_i}, @var{x_i}^2, ... @var{x_i}^(@var{n}-1)]}. 

@end deffn

@deffn {Função} zerofor (@var{M})
@deffnx {Função}  zerofor (@var{M}, @var{fld})

Retorna uma matriz zero que tem o mesmo tamanho da matriz
@var{M}.  Toda entrada da matriz zero é a
identidade aditiva do anel @var{fld}; o valor padrão para
@var{fld} é @var{generalring}.

O primeiro argumento @var{M} pode ser uma matriz quadrada ou uma
não matriz. Quando @var{M} for uma matriz, cada entrada de @var{M} pode ser uma
matriz quadrada -- dessa forma @var{M} pode ser uma matriz de bloco do Maxima. A
matriz pode ser de bloco para qualquer nível (finito).

Veja também @code{identfor}

@end deffn

@deffn {Função} zeromatrixp (@var{M})

Se @var{M} não for uma matriz de bloco, retorna @code{true} se @code{is (equal (@var{e}, 0))} 
for verdadeiro para cada elemento @var{e} da matriz @var{M}.  Se @var{M} for uma matriz de bloco, retorna
@code{true} se @code{zeromatrixp} avaliar para @code{true} para cada elemento de @var{e}.

@end deffn

