doc/info/pt/linearalgebra.texi

   1 @c /linearalgebra.texi/1.11/Fri Jan  5 17:01:04 2007//
   2 @menu
   3 * Introdução a linearalgebra::
   4 * Definições para linearalgebra::
   5 @end menu
   6
   7 @node Introdução a linearalgebra, Definições para linearalgebra, linearalgebra, linearalgebra
   8 @section Introdução a linearalgebra
   9
  10 @code{linearalgebra} é uma colecção de funções para álgebra linear.
  11
  12 Exemplo:
  13
  14 @c ===beg===
  15 @c load ("linearalgebra")$
  16 @c M : matrix ([1, 2], [1, 2]);
  17 @c nullspace (M);
  18 @c columnspace (M);
  19 @c ptriangularize (M - z*ident(2), z);
  20 @c M : matrix ([1, 2, 3], [4, 5, 6], [7, 8, 9]) - z*ident(3);
  21 @c MM : ptriangularize (M, z);
  22 @c algebraic : true;
  23 @c tellrat (MM [3, 3]);
  24 @c MM : ratsimp (MM);
  25 @c nullspace (MM);
  26 @c M : matrix ([1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]);
  27 @c columnspace (M);
  28 @c apply ('orthogonal_complement, args (nullspace (transpose (M))));
  29 @c ===end===
  30 @example
  31 (%i1) load ("linearalgebra");
  32 Warning - you are redefining the Maxima function require_list
  33 Warning - you are redefining the Maxima function matrix_size
  34 Warning - you are redefining the Maxima function rank
  35 (%o1) /usr/local/share/maxima/5.9.2/share/linearalgebra/linearalgebra.mac
  36 (%i2) M : matrix ([1, 2], [1, 2]);
  37                             [ 1  2 ]
  38 (%o2)                       [      ]
  39                             [ 1  2 ]
  40 (%i3) nullspace (M);
  41                                [  1  ]
  42                                [     ]
  43 (%o3)                     span([   1 ])
  44                                [ - - ]
  45                                [   2 ]
  46 (%i4) columnspace (M);
  47                                 [ 1 ]
  48 (%o4)                      span([   ])
  49                                 [ 1 ]
  50 (%i5) ptriangularize (M - z*ident(2), z);
  51                          [ 1   2 - z   ]
  52 (%o5)                    [             ]
  53                          [           2 ]
  54                          [ 0  3 z - z  ]
  55 (%i6) M : matrix ([1, 2, 3], [4, 5, 6], [7, 8, 9]) - z*ident(3);
  56                      [ 1 - z    2      3   ]
  57                      [                     ]
  58 (%o6)                [   4    5 - z    6   ]
  59                      [                     ]
  60                      [   7      8    9 - z ]
  61 (%i7) MM : ptriangularize (M, z);
  62               [ 4  5 - z            6            ]
  63               [                                  ]
  64               [                2                 ]
  65               [     66        z    102 z   132   ]
  66               [ 0   --      - -- + ----- + ---   ]
  67 (%o7)         [     49        7     49     49    ]
  68               [                                  ]
  69               [               3        2         ]
  70               [           49 z    245 z    147 z ]
  71               [ 0    0    ----- - ------ - ----- ]
  72               [            264      88      44   ]
  73 (%i8) algebraic : true;
  74 (%o8)                         true
  75 (%i9) tellrat (MM [3, 3]);
  76                          3       2
  77 (%o9)                  [z  - 15 z  - 18 z]
  78 (%i10) MM : ratsimp (MM);
  79                [ 4  5 - z           6           ]
  80                [                                ]
  81                [                2               ]
  82 (%o10)         [     66      7 z  - 102 z - 132 ]
  83                [ 0   --    - ------------------ ]
  84                [     49              49         ]
  85                [                                ]
  86                [ 0    0             0           ]
  87 (%i11) nullspace (MM);
  88                         [        1         ]
  89                         [                  ]
  90                         [   2              ]
  91                         [  z  - 14 z - 16  ]
  92                         [  --------------  ]
  93 (%o11)             span([        8         ])
  94                         [                  ]
  95                         [    2             ]
  96                         [   z  - 18 z - 12 ]
  97                         [ - -------------- ]
  98                         [         12       ]
  99 (%i12) M : matrix ([1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]);
 100                        [ 1   2   3   4  ]
 101                        [                ]
 102                        [ 5   6   7   8  ]
 103 (%o12)                 [                ]
 104                        [ 9   10  11  12 ]
 105                        [                ]
 106                        [ 13  14  15  16 ]
 107 (%i13) columnspace (M);
 108                            [ 1  ]  [ 2  ]
 109                            [    ]  [    ]
 110                            [ 5  ]  [ 6  ]
 111 (%o13)                span([    ], [    ])
 112                            [ 9  ]  [ 10 ]
 113                            [    ]  [    ]
 114                            [ 13 ]  [ 14 ]
 115 (%i14) apply ('orthogonal_complement, args (nullspace (transpose (M))));
 116                            [ 0 ]  [  1  ]
 117                            [   ]  [     ]
 118                            [ 1 ]  [  0  ]
 119 (%o14)                span([   ], [     ])
 120                            [ 2 ]  [ - 1 ]
 121                            [   ]  [     ]
 122                            [ 3 ]  [ - 2 ]
 123 @end example
 124
 125 @node Definições para linearalgebra,  , Introdução a linearalgebra, linearalgebra
 126 @section Definições para linearalgebra
 127
 128 @deffn {Função} addmatrices (@var{f}, @var{M_1}, ..., @var{M_n})
 129
 130 @c REWORD -- THE RESULT IS NOT GENERALLY THE SUM OF M_1, ..., M_N
 131 Usando a função @var{f} como a função de adição, retorne a adição das
 132 matrizes @var{M_1}, ..., @var{M_n}. A função @var{f} deve aceitar qualquer número de
 133 argumentos (uma função enária do Maxima).
 134
 135 Exemplos:
 136
 137 @c ===beg===
 138 @c m1 : matrix([1,2],[3,4])$
 139 @c m2 : matrix([7,8],[9,10])$
 140 @c addmatrices('max,m1,m2);
 141 @c addmatrices('max,m1,m2,5*m1);
 142 @c ===end===
 143 @example
 144 (%i1) m1 : matrix([1,2],[3,4])$
 145 (%i2) m2 : matrix([7,8],[9,10])$
 146 (%i3) addmatrices('max,m1,m2);
 147 (%o3) matrix([7,8],[9,10])
 148 (%i4) addmatrices('max,m1,m2,5*m1);
 149 (%o4) matrix([7,10],[15,20])
 150 @end example
 151
 152 @end deffn
 153
 154 @deffn {Função} blockmatrixp (@var{M})
 155
 156 Retorna @code{true} se e somente se @var{M} for uma matriz e toda entrada de
 157 @var{M} também for uma matriz.
 158
 159 @end deffn
 160
 161 @deffn {Função} columnop (@var{M}, @var{i}, @var{j}, @var{theta})
 162
 163 Se @var{M} for uma matriz, retorna a matriz que resulta de fazer a
 164 operação de coluna @code{C_i <- C_i - @var{theta} * C_j}. Se @var{M} não tiver uma linha
 165 @var{i} ou @var{j}, emite uma mensagem de erro.
 166
 167 @end deffn
 168
 169 @deffn {Função} columnswap (@var{M}, @var{i}, @var{j})
 170
 171 Se @var{M} for uma matriz, troca as colunas @var{i} e @var{j}.  Se @var{M} não tiver uma coluna
 172 @var{i} ou @var{j}, emite uma mensagem de erro.
 173
 174 @end deffn
 175
 176 @deffn {Função} columnspace (@var{M})
 177
 178 Se @var{M} for uma matriz, retorna @code{span (v_1, ..., v_n)}, onde o conjunto
 179 @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
 180 conjunto vazio é @code{@{0@}}. Dessa forma, quando o espaço coluna tiver somente
 181 um membro, retorna @code{span ()}.
 182
 183 @end deffn
 184
 185 @deffn {Função} copy (@var{e})
 186
 187 Retorna uma cópia da expressão @var{e} do Maxima. Embora @var{e} possa ser qualquer
 188 expressão do Maxima, Afunção @code{copy} é mais útil quando @var{e} for ou
 189 uma lista ou uma matriz; considere:
 190 @c ===beg===
 191 load ("linearalgebra");
 192 m : [1,[2,3]]$
 193 mm : m$
 194 mm[2][1] : x$
 195 m;
 196 mm;
 197 @c ===end===
 198 @example
 199 (%i1) load("linearalgebra")$
 200 (%i2) m : [1,[2,3]]$
 201 (%i3) mm : m$
 202 (%i4) mm[2][1] : x$
 203 (%i5) m;
 204 (%o5) [1,[x,3]]
 205 (%i6) mm;
 206 (%o6) [1,[x,3]]
 207 @end example
 208 Vamos tentar a mesma experiência, mas dessa vez tomemos @var{mm} como sendo uma cópia de @var{m}
 209 @c ===beg===
 210 m : [1,[2,3]]$
 211 mm : copy(m)$
 212 mm[2][1] : x$
 213 m;
 214 mm;
 215 @c ===end===
 216 @example
 217 (%i7) m : [1,[2,3]]$
 218 (%i8) mm : copy(m)$
 219 (%i9) mm[2][1] : x$
 220 (%i10) m;
 221 (%o10) [1,[2,3]]
 222 (%i11) mm;
 223 (%o11) [1,[x,3]]
 224 @end example
 225 Dessa vez, a atribuição a @var{mm} não muda o valor de @var{m}.
 226
 227 @end deffn
 228
 229 @deffn {Função} cholesky (@var{M})
 230 @deffnx {Função} cholesky (@var{M}, @var{corpo})
 231
 232 Retorna factorização de Cholesky da matriz hermitiana (or autoadjunta)
 233 @var{M}. O valor padrão para o segundo argumento é @code{generalring}. Para uma descrição dos
 234 possíveis valores para @var{corpo}, veja @code{lu_factor}.
 235
 236 @end deffn
 237
 238 @deffn {Função} ctranspose (@var{M})
 239
 240 Retorna a matriz transposta conjugada complexa da matriz @var{M}. A função
 241 @code{ctranspose} usa @code{matrix_element_transpose} para transpor cada elemento da matriz.
 242
 243 @end deffn
 244
 245 @deffn {Função} diag_matrix (@var{d_1}, @var{d_2},...,@var{d_n})
 246
 247 Retorna uma matriz diagonal matriz com entradas de diagonal @var{d_1}, @var{d_2},...,@var{d_n}.
 248 Quando as entradas de diagonal forem matrizes, as entradas zero da matriz retornada
 249 serão todas matrizes de tamanho apropriado; por exemplo:
 250 @c ===beg===
 251 @c load("linearalgebra")$
 252 @c diag_matrix(diag_matrix(1,2),diag_matrix(3,4));
 253 @c diag_matrix(p,q);
 254 @c ===end===
 255 @example
 256 (%i1) load("linearalgebra")$
 257
 258 (%i2) diag_matrix(diag_matrix(1,2),diag_matrix(3,4));
 259
 260                             [ [ 1  0 ]  [ 0  0 ] ]
 261                             [ [      ]  [      ] ]
 262                             [ [ 0  2 ]  [ 0  0 ] ]
 263 (%o2)                       [                    ]
 264                             [ [ 0  0 ]  [ 3  0 ] ]
 265                             [ [      ]  [      ] ]
 266                             [ [ 0  0 ]  [ 0  4 ] ]
 267 (%i3) diag_matrix(p,q);
 268
 269                                    [ p  0 ]
 270 (%o3)                              [      ]
 271                                    [ 0  q ]
 272 @end example
 273 @end deffn
 274
 275 @deffn {Função} dotproduct (@var{u}, @var{v})
 276
 277 Retorna o produto do ponto (produto escalar) dos vectores @var{u} e @var{v}.  Isso é o mesmo
 278 que @code{conjugate (transpose (@var{u})) . @var{v}}.  Os argumentos @var{u} e @var{v} devem ser
 279 vectores coluna.
 280
 281 @end deffn
 282
 283 @deffn {Função} eigens_by_jacobi (@var{A})
 284 @deffnx {Função} eigens_by_jacobi (@var{A}, @var{tipo_corpo})
 285
 286 Calculam os autovalores e autovectores de @var{A} pelo método de rotações de Jacobi.
 287 @var{A} deve ser uma matriz simétrica (mas essa matriz simétrica precisa não ser nem definida positiva e nem semidefinida positiva).
 288 @var{tipo_corpo} indica o corpo computacional, pode ser ou @code{floatfield} ou @code{bigfloatfield}.
 289 Se @var{tipo_corpo} não for especificado, o padrão é @code{floatfield}.
 290
 291 Os elementos de @var{A} devem ser números ou expressões que avaliam para números
 292 via @code{float} ou @code{bfloat} (dependendo do valor de @var{tipo_corpo}).
 293
 294 Exemplos:
 295 @c ===beg===
 296 @c load ("linearalgebra");
 297 @c S : matrix ([1/sqrt(2), 1/sqrt(2)], [- 1/sqrt(2), 1/sqrt(2)]);
 298 @c L : matrix ([sqrt(3), 0], [0, sqrt(5)]);
 299 @c M : S . L . transpose (S);
 300 @c eigens_by_jacobi (M);
 301 @c float ([[sqrt(3), sqrt(5)], S]);
 302 @c eigens_by_jacobi (M, bigfloatfield);
 303 @c ===end===
 304
 305 @example
 306 (%i1) load ("linearalgebra");
 307 (%o1) /home/robert/tmp/maxima-head/maxima/share/linearalgebra/li\
 308 nearalgebra.mac
 309 (%i2) S : matrix ([1/sqrt(2), 1/sqrt(2)], [- 1/sqrt(2), 1/sqrt(2)]);
 310                      [     1         1    ]
 311                      [  -------   ------- ]
 312                      [  sqrt(2)   sqrt(2) ]
 313 (%o2)                [                    ]
 314                      [      1        1    ]
 315                      [ - -------  ------- ]
 316                      [   sqrt(2)  sqrt(2) ]
 317 (%i3) L : matrix ([sqrt(3), 0], [0, sqrt(5)]);
 318                       [ sqrt(3)     0    ]
 319 (%o3)                 [                  ]
 320                       [    0     sqrt(5) ]
 321 (%i4) M : S . L . transpose (S);
 322             [ sqrt(5)   sqrt(3)  sqrt(5)   sqrt(3) ]
 323             [ ------- + -------  ------- - ------- ]
 324             [    2         2        2         2    ]
 325 (%o4)       [                                      ]
 326             [ sqrt(5)   sqrt(3)  sqrt(5)   sqrt(3) ]
 327             [ ------- - -------  ------- + ------- ]
 328             [    2         2        2         2    ]
 329 (%i5) eigens_by_jacobi (M);
 330 The largest percent change was 0.1454972243679
 331 The largest percent change was 0.0
 332 number of sweeps: 2
 333 number of rotations: 1
 334 (%o5) [[1.732050807568877, 2.23606797749979],
 335                         [  0.70710678118655   0.70710678118655 ]
 336                         [                                      ]]
 337                         [ - 0.70710678118655  0.70710678118655 ]
 338 (%i6) float ([[sqrt(3), sqrt(5)], S]);
 339 (%o6) [[1.732050807568877, 2.23606797749979],
 340                         [  0.70710678118655   0.70710678118655 ]
 341                         [                                      ]]
 342                         [ - 0.70710678118655  0.70710678118655 ]
 343 (%i7) eigens_by_jacobi (M, bigfloatfield);
 344 The largest percent change was 1.454972243679028b-1
 345 The largest percent change was 0.0b0
 346 number of sweeps: 2
 347 number of rotations: 1
 348 (%o7) [[1.732050807568877b0, 2.23606797749979b0],
 349                 [  7.071067811865475b-1   7.071067811865475b-1 ]
 350                 [                                              ]]
 351                 [ - 7.071067811865475b-1  7.071067811865475b-1 ]
 352 @end example
 353
 354 @end deffn
 355
 356 @deffn {Função} get_lu_factors (@var{x})
 357
 358 Quando @code{@var{x} = lu_factor (@var{A})}, então @code{get_lu_factors} retorna uma lista da
 359 forma @code{[P, L, U]}, onde @var{P} é uma matriz de permutação, @var{L} é triangular baixa com
 360 a diagonal preenchida com a unidade, e @var{U} é triangular alta, e @code{@var{A} = @var{P} @var{L} @var{U}}.
 361
 362 @end deffn
 363
 364 @deffn {Função} hankel (@var{col})
 365 @deffnx {Função} hankel (@var{col}, @var{lin})
 366
 367 Retorna uma matriz de Hankel @var{H}. A primeira coluna de @var{H} é @var{col};
 368 excepto para a primeira entrada, a última linha de @var{H} é @var{lin}. O
 369 valor padrão para @var{lin} é o vector nulo com o mesmo comprimento que @var{col}.
 370
 371 @end deffn
 372
 373 @deffn {Função} hessian (@var{f},@var{vars})
 374
 375 Retorna a matriz hessiana de @var{f} com relação às variáveis na lista
 376 @var{vars}.  As entradas @var{i},@var{j} da matriz hessiana são
 377 @var{diff(f vars[i],1,vars[j],1)}.
 378
 379 @end deffn
 380
 381 @deffn {Função} hilbert_matrix (@var{n})
 382
 383 Retorna the @var{n} by @var{n} matriz de Hilbert. Quando @var{n} não for um inteiro
 384 positivo, emite uma mensagem de erro.
 385
 386 @end deffn
 387
 388 @deffn {Função} identfor (@var{M})
 389 @deffnx {Função} identfor (@var{M}, @var{corpo})
 390
 391 Retorna uma matriz identidade que tem o mesmo tamanho que a matriz
 392 @var{M}.  As entradas de diagonal da matriz identidade são a
 393 identidade multiplicativa do corpo @var{corpo}; o padrão para
 394 @var{corpo} é @var{generalring}.
 395
 396 O primeiro argumento @var{M} pode ser uma  matriz quadrada ou um
 397 não matriz. Quando @var{M} for uma matriz, cada entrada de @var{M} pode ser uma
 398 matriz quadrada -- dessa forma @var{M} pode ser uma matriz de bloco do Maxima. A
 399 matriz pode ser de bloco para qualquer (finita) quantidade de níveis.
 400
 401 Veja também @code{zerofor}
 402
 403 @end deffn
 404
 405 @deffn {Função} invert_by_lu (@var{M}, @var{(rng generalring)})
 406
 407 Inverte a matriz @var{M} através de factorização linear alta (LU).  A factorização LU
 408 é concluída usando o anel @var{rng}.
 409
 410 @end deffn
 411
 412 @deffn {Função} kronecker_product (@var{A}, @var{B})
 413
 414 Retorna o produto de Kronecker das matrizes @var{A} e @var{B}.
 415
 416 @end deffn
 417
 418 @deffn {Função} listp (@var{e}, @var{p})
 419 @deffnx {Função} listp (@var{e})
 420
 421 Recebendo um argumento opcional @var{p}, retorna @code{true} se @var{e} for
 422 uma lista do Maxima e @var{p} avalia para @code{true} para elemento da lista.
 423 Quando @code{listp} não recebe o argumento opcional, retorna @code{true} se @var{e} for
 424 uma lista do Maxima.  em todos os outros casos, retorna @code{false}.
 425
 426 @end deffn
 427
 428 @deffn {Função} locate_matrix_entry (@var{M}, @var{r_1}, @var{c_1}, @var{r_2}, @var{c_2}, @var{f}, @var{rel})
 429
 430 O primeiro argumento deve ser uma matriz; os argumentos que vão de
 431 @var{r_1} até @var{c_2} determinam um sub-matriz de @var{M} que consiste de
 432 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}.
 433
 434 Encontra uma entrada na sub-matriz @var{M} que satisfaz alguma propriedade.
 435 Existem três casos:
 436
 437 (1) @code{@var{rel} = 'bool} e @var{f} um predicado:
 438
 439 Examina a sub-matriz da esquerda para a direita e de cima para baixo,
 440 e retorna o índice da primeira entrada que satisfizer o
 441 predicado @var{f}. Se nenhuma entrada da matriz satisfizer o predicado @var{f}, retorna @code{false}.
 442
 443 (2) @code{@var{rel} = 'max} e @var{f} avaliar para um número real:
 444
 445 Examina a sub-matriz procurando por uma entrada que maximize @var{f}.
 446 Retorna retorna o índice da entrada maximizada.
 447
 448 (3) @code{@var{rel} = 'min} e @var{f} avaliar para um número real:
 449
 450 Examina a sub-matriz procurando por uma entrada que minimize @var{f}.
 451 Retorna o índice de uma entrada minimizada.
 452
 453 @end deffn
 454
 455 @deffn {Função} lu_backsub (@var{M}, @var{b})
 456
 457 Quando @code{@var{M} = lu_factor (@var{A}, @var{corpo})},
 458 então @code{lu_backsub (@var{M}, @var{b})} resolve o sistema
 459 linear @code{@var{A} @var{x} = @var{b}}.
 460
 461 @end deffn
 462
 463 @deffn {Função} lu_factor (@var{M}, @var{corpo})
 464
 465 Retorna uma lista da forma @code{[@var{LU}, @var{perm}, @var{corpo}]},
 466 ou da forma @code{[@var{LU}, @var{perm}, @var{cmp}, @var{baixo-cnd} @var{alto-cnd}]}, onde
 467
 468   (1) A matriz @var{LU} contéa factorização de @var{M} na forma enpacotada. Forma
 469       empacotada significa três coisas: Primeiro, as linhas de @var{LU} são permutadas confirme a
 470       lista @var{perm}.  Se, por exemplo, @var{perm} for a lista list @code{[3,2,1]}, a primeira linha actual
 471       da factorização @var{LU} será a terceira linha da matriz @var{LU}. Segundo,
 472       o factor triangular baixo de m é a parte triangular baixa de @var{LU} com as
 473       entradas de diagonal todas substituídas pela unidade. Terceiro, o factor triangular alto de
 474       @var{M} é a parte triangular alta de @var{LU}.
 475
 476   (2) Quando o corpo for ou @code{floatfield} ou @code{complexfield},
 477       os números @var{baixo-cnd} e @var{alto-cnd} serão associados baixo e alto para o
 478       número condicional de norma infinita de @var{M}.  Para todos os corpos (fields), o número condicional de norma infinita
 479       não pode ser estimado; para tais corpos, @code{lu_factor} retorna uma lista com dois itens.
 480       Ambos o baixo e o alto associado  podem diferir de seus verdadeiros valores de
 481       factores arbitráriamente grandes. (Veja também @code{mat_cond}.)
 482
 483   O argumento @var{M} deve ser a matriz quadrada.
 484
 485   O argumento opcional @var{cmp} deve ser um símbolo que determine um anel ou corpo. Os corpos e anéis
 486   predefinidos são:
 487
 488     (a) @code{generalring} -- o anel de expressões do Maxima,
 489     (b) @code{floatfield} --  o corpo dos números em ponto flutuante do tipo de precisão dupla,
 490     (c) @code{complexfield} --  o corpo dos números complexos em ponto flutuante do
 491         tipo de precisão dupla,
 492     (d) @code{crering}  -- o anel das expressões racionais canónicas (CRE) do Maxima,
 493     (e) @code{rationalfield} -- o corpo dos números racionais,
 494     (f) @code{runningerror} -- rastro de todos os erros de arredondamento de números em ponto flutuante,
 495      (g) @code{noncommutingring} -- o anel de expressões do Maxima onde multiplicação for o
 496         operador ponto não comutativo.
 497
 498 Quando o corpo for @code{floatfield}, @code{complexfield}, ou
 499 @code{runningerror}, o algoritmo usa pivotagem parcial; para todos
 500 os outros corpos, linhas são comutadas somente quando necessário para evitar um piv@^o
 501 nulo.
 502
 503 A adição aritmética em ponto flutuante não é associativa, então o significado
 504 de 'corpo' difere da definição matemática.
 505
 506 Um membro do corpo @code{runningerror} é uma lista do Máxima de dois membros
 507 da forma @code{[x,n]},onde @var{x} é um número em onto flutuante e
 508 @code{n} é um inteiro. A diferença relativa entre o valor de
 509 'verdadeiro' de @code{x} e @code{x} é aproximadamente associado pelo épsilon da
 510 máquina vezes @code{n}. O erro de execução associado arrasta alguns termos
 511 da ordem do quadrado do épsilon da máquina.
 512
 513 Não existe interface de utilizador definida um novo anel. Um utilizador que estiver
 514 familiazrizado com o Lisp Comum está apto para definir um novo corpo.  Para fazer
 515 isso, um utilizador deve definir funções para as operações aritméticas e
 516 funções para conversão para a representação de corpo do Máxima e
 517 vice-versa. Adicionalmente, para corpos ordenados (onde a pivotagem parcial será
 518 usada), um uduário deve definir funções para módulo e para
 519 comparar membros do corpo.  Após isso tudo que resta é definir uma
 520 estrutura de Lisp Comum @code{mring}.  O ficheiro @code{mring} tem muitos
 521 exemplos.
 522
 523 Para calcular a factorização, a primeira tarefa é converter cada entrada de
 524 matriz para um elemento do corpo indicado. Quando a cnversão não for
 525 possível, a factorização encerra com uma mensagem de erro. Elementos do
 526 corpo não precisam ser expressões do Maxima.  Elementos do
 527 @code{complexfield}, por exemplo, são números complexos do Lisp Comum. Dessa forma
 528 após calcular a factorização, como entradas da matriz devem ser
 529 convertidas para expressões do Maxima.
 530
 531 Veja também  @code{get_lu_factors}.
 532
 533 Exemplos:
 534 @c ===beg===
 535 @c load ("linearalgebra");
 536 @c w[i,j] := random (1.0) + %i * random (1.0);
 537 @c showtime : true$
 538 @c M : genmatrix (w, 100, 100)$
 539 @c lu_factor (M, complexfield)$
 540 @c lu_factor (M, generalring)$
 541 @c showtime : false$
 542 @c M : matrix ([1 - z, 3], [3, 8 - z]);
 543 @c lu_factor (M, generalring);
 544 @c get_lu_factors (%);
 545 @c %[1] . %[2] . %[3];
 546 @c ===end===
 547 @example
 548 (%i1) load ("linearalgebra");
 549 Warning - you are redefining the Maxima function require_list
 550 Warning - you are redefining the Maxima function matrix_size
 551 Warning - you are redefining the Maxima function rank
 552 (%o1) /usr/local/share/maxima/5.9.2/share/linearalgebra/linearalgebra.mac
 553 (%i2) w[i,j] := random (1.0) + %i * random (1.0);
 554 (%o2)          w     := random(1.) + %i random(1.)
 555                 i, j
 556 (%i3) showtime : true$
 557 Evaluation took 0.00 seconds (0.00 elapsed)
 558 (%i4) M : genmatrix (w, 100, 100)$
 559 Evaluation took 7.40 seconds (8.23 elapsed)
 560 (%i5) lu_factor (M, complexfield)$
 561 Evaluation took 28.71 seconds (35.00 elapsed)
 562 (%i6) lu_factor (M, generalring)$
 563 Evaluation took 109.24 seconds (152.10 elapsed)
 564 (%i7) showtime : false$
 565
 566 (%i8) M : matrix ([1 - z, 3], [3, 8 - z]);
 567                         [ 1 - z    3   ]
 568 (%o8)                   [              ]
 569                         [   3    8 - z ]
 570 (%i9) lu_factor (M, generalring);
 571                [ 1 - z         3        ]
 572                [                        ]
 573 (%o9)         [[   3            9       ], [1, 2]]
 574                [ -----  - z - ----- + 8 ]
 575                [ 1 - z        1 - z     ]
 576 (%i10) get_lu_factors (%);
 577                   [   1    0 ]  [ 1 - z         3        ]
 578         [ 1  0 ]  [          ]  [                        ]
 579 (%o10) [[      ], [   3      ], [                9       ]]
 580         [ 0  1 ]  [ -----  1 ]  [   0    - z - ----- + 8 ]
 581                   [ 1 - z    ]  [              1 - z     ]
 582 (%i11) %[1] . %[2] . %[3];
 583                         [ 1 - z    3   ]
 584 (%o11)                  [              ]
 585                         [   3    8 - z ]
 586 @end example
 587
 588 @end deffn
 589
 590 @deffn {Função} mat_cond (@var{M}, 1)
 591 @deffnx {Função} mat_cond (@var{M}, inf)
 592
 593 Retorna o número condiciona da norma de ordem @var{p} da matriz
 594 @var{m}. Os valores permitidos para @var{p} são 1 e @var{inf}.  Essa
 595 função utiliza a factorização linear alta para inverter a matriz @var{m}. Dessa forma
 596 o tempode execução para @code{mat_cond} é proporcional ao cubo do
 597 tamanho da matriz; @code{lu_factor} determina as associaçãoes baixa e alta
 598 para o número de condição de norma infinita em tempo proporcional ao
 599 quadrado do tamanho da matriz.
 600
 601 @end deffn
 602
 603 @deffn {Função} mat_norm (@var{M}, 1)
 604 @deffnx {Função} mat_norm (@var{M}, inf)
 605 @deffnx {Função} mat_norm (@var{M}, frobenius)
 606
 607 Retorna a matriz de norma @var{p} da matriz @var{M}.  Os valores permitidos para @var{p} são
 608 1, @code{inf}, e @code{frobenius} (a norma da matriz de Frobenius). A matriz @var{M} pode ser
 609 uma matriz não de bloco.
 610
 611 @end deffn
 612
 613 @deffn {Função} matrixp (@var{e}, @var{p})
 614 @deffnx {Função} matrixp (@var{e})
 615
 616 Fornecendo um argumento opcional @var{p}, @code{matrixp} retorna @code{true} se @var{e} for
 617 uma matriz e @var{p} avaliar para @code{true} para todo elemento da matriz.
 618 Quando a @code{matrixp} não for fornecido umargumento opcional, retorna @code{true}
 619 se @code{e} for uma matriz.  em todos os outros casos, retorna @code{false}.
 620
 621 Veja também @code{blockmatrixp}
 622
 623 @end deffn
 624
 625 @deffn {Função} matrix_size (@var{M})
 626
 627 Retorna uma lista com dois elementos que fornecem o número de linhas e colunas, respectivamente
 628 da matriz @var{M}.
 629
 630 @end deffn
 631
 632 @deffn {Função} mat_fullunblocker (@var{M})
 633
 634 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,
 635 retorna @var{M}; de outra forma, emite uma mensagem de erro.
 636
 637 @c precisa de exemplo aqui
 638
 639 @end deffn
 640
 641 @deffn {Função} mat_trace (@var{M})
 642
 643 Retorna o traço da matriz @var{M}. Se @var{M} não for uma matriz, retorna uma
 644 forma substantiva. Quando @var{M} for uma matriz de bloco, @code{mat_trace(M)} retorna
 645 o mesmo valor retornado por @code{mat_trace(mat_unblocker(m))}.
 646
 647 @end deffn
 648
 649 @deffn {Função} mat_unblocker (@var{M})
 650
 651 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,
 652 @code{mat_unblocker (M)} retorna @var{M}; de outra forma, emite uma mensagem de erro.
 653
 654 Dessa forma se cada entrada de @var{M} for matriz, @code{mat_unblocker (M)} retorna uma
 655 matriz "desblocada", mas se cada entrada de @var{M} for uma matriz de bloco, @code{mat_unblocker (M)}
 656 retorna uma matriz de bloco com um nível de bloco a menos.
 657
 658 Se usar matrizes de bloco, muito provavelmente irá querer escolher @code{matrix_element_mult} para
 659 @code{"."} e @code{matrix_element_transpose} para @code{'transpose}. Veja também @code{mat_fullunblocker}.
 660
 661 Exemplo:
 662
 663 @c ===beg===
 664 @c load ("linearalgebra");
 665 @c A : matrix ([1, 2], [3, 4]);
 666 @c B : matrix ([7, 8], [9, 10]);
 667 @c matrix ([A, B]);
 668 @c mat_unblocker (%);
 669 @c ===end===
 670 @example
 671 (%i1) load ("linearalgebra");
 672 Warning - you are redefining the Maxima function require_list
 673 Warning - you are redefining the Maxima function matrix_size
 674 Warning - you are redefining the Maxima function rank
 675 (%o1) /usr/local/share/maxima/5.9.2/share/linearalgebra/linearalgebra.mac
 676 (%i2) A : matrix ([1, 2], [3, 4]);
 677                             [ 1  2 ]
 678 (%o2)                       [      ]
 679                             [ 3  4 ]
 680 (%i3) B : matrix ([7, 8], [9, 10]);
 681                             [ 7  8  ]
 682 (%o3)                       [       ]
 683                             [ 9  10 ]
 684 (%i4) matrix ([A, B]);
 685                      [ [ 1  2 ]  [ 7  8  ] ]
 686 (%o4)                [ [      ]  [       ] ]
 687                      [ [ 3  4 ]  [ 9  10 ] ]
 688 (%i5) mat_unblocker (%);
 689                          [ 1  2  7  8  ]
 690 (%o5)                    [             ]
 691                          [ 3  4  9  10 ]
 692 @end example
 693
 694 @end deffn
 695
 696 @deffn {Função} nonnegintegerp (@var{n})
 697
 698 Retorna @code{true} se e somente se @code{@var{n} >= 0} e @var{n} for um inteiro.
 699
 700 @end deffn
 701
 702 @deffn {Função} nullspace (@var{M})
 703
 704 Se @var{M} for uma matriz, retorna @code{span (v_1, ..., v_n)}, onde o conjunto @code{@{v_1, ..., v_n@}}
 705 é 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@}}.
 706 Dessa forma, quando o espaço nulo tiver somente um membro, retorna @code{span ()}.
 707
 708 @end deffn
 709
 710 @deffn {Função} nullity (@var{M})
 711
 712 Se @var{M} for uma matriz, retorna a dimensão do espaço nulo de @var{M}.
 713
 714 @end deffn
 715
 716 @deffn {Função} orthogonal_complement (@var{v_1}, ..., @var{v_n})
 717
 718 Retorna @code{span (u_1, ..., u_m)}, onde o conjunto @code{@{u_1, ..., u_m@}} é uma
 719 base para o complemento ortogonal do conjunto @code{(v_1, ..., v_n)}.
 720
 721 Cada vector no intervalo de @var{v_1} até @var{v_n} deve ser um vector coluna.
 722
 723 @end deffn
 724
 725 @deffn {Função} polynomialp (@var{p}, @var{L}, @var{coeffp}, @var{exponp})
 726 @deffnx {Função} polynomialp (@var{p}, @var{L}, @var{coeffp})
 727 @deffnx {Função} polynomialp (@var{p}, @var{L})
 728
 729 Retorna @code{true} se @var{p} for um polinómio nas variáveis da lista @var{L},
 730 O predicado @var{coeffp} deve avaliar para @code{true} para cada
 731 coeficiente, e o predicado @var{exponp} deve avaliar para @code{true} para todos os
 732 expoentes das variáveis na lista @var{L}. Se quiser usar um valor
 733 personalizado para @var{exponp}, deverá fornecer @var{coeffp} com um valor mesmo se quiser
 734 o valor padrão para @var{coeffp}.
 735
 736 @c WORK THE FOLLOWING INTO THE PRECEDING
 737 @code{polynomialp (@var{p}, @var{L}, @var{coeffp})} é equivalente a
 738 @code{polynomialp (@var{p}, @var{L}, @var{coeffp}, 'nonnegintegerp)}.
 739
 740 @code{polynomialp (@var{p}, @var{L})} é equivalente a
 741 @code{polynomialp (@var{p}, L@var{,} 'constantp, 'nonnegintegerp)}.
 742
 743 O polinómio não precisa ser expandido:
 744
 745 @c ===beg===
 746 @c load ("linearalgebra");
 747 @c polynomialp ((x + 1)*(x + 2), [x]);
 748 @c polynomialp ((x + 1)*(x + 2)^a, [x]);
 749 @c ===end===
 750 @example
 751 (%i1) load ("linearalgebra");
 752 Warning - you are redefining the Maxima function require_list
 753 Warning - you are redefining the Maxima function matrix_size
 754 Warning - you are redefining the Maxima function rank
 755 (%o1) /usr/local/share/maxima/5.9.2/share/linearalgebra/linearalgebra.mac
 756 (%i2) polynomialp ((x + 1)*(x + 2), [x]);
 757 (%o2)                         true
 758 (%i3) polynomialp ((x + 1)*(x + 2)^a, [x]);
 759 (%o3)                         false
 760 @end example
 761
 762 Um exemplo usando um valor personalizado para @code{coeffp} e para @code{exponp}:
 763
 764 @c ===beg===
 765 @c load ("linearalgebra");
 766 @c polynomialp ((x + 1)*(x + 2)^(3/2), [x], numberp, numberp);
 767 @c polynomialp ((x^(1/2) + 1)*(x + 2)^(3/2), [x], numberp, numberp);
 768 @c ===end===
 769 @example
 770 (%i1) load ("linearalgebra");
 771 Warning - you are redefining the Maxima function require_list
 772 Warning - you are redefining the Maxima function matrix_size
 773 Warning - you are redefining the Maxima function rank
 774 (%o1) /usr/local/share/maxima/5.9.2/share/linearalgebra/linearalgebra.mac
 775 (%i2) polynomialp ((x + 1)*(x + 2)^(3/2), [x], numberp, numberp);
 776 (%o2)                         true
 777 (%i3) polynomialp ((x^(1/2) + 1)*(x + 2)^(3/2), [x], numberp, numberp);
 778 (%o3)                         true
 779 @end example
 780
 781 Polinómios com duas variáveis:
 782
 783 @c ===beg===
 784 @c load ("linearalgebra");
 785 @c polynomialp (x^2 + 5*x*y + y^2, [x]);
 786 @c polynomialp (x^2 + 5*x*y + y^2, [x, y]);
 787 @c ===end===
 788 @example
 789 (%i1) load ("linearalgebra");
 790 Warning - you are redefining the Maxima function require_list
 791 Warning - you are redefining the Maxima function matrix_size
 792 Warning - you are redefining the Maxima function rank
 793 (%o1) /usr/local/share/maxima/5.9.2/share/linearalgebra/linearalgebra.mac
 794 (%i2) polynomialp (x^2 + 5*x*y + y^2, [x]);
 795 (%o2)                         false
 796 (%i3) polynomialp (x^2 + 5*x*y + y^2, [x, y]);
 797 (%o3)                         true
 798 @end example
 799
 800 @end deffn
 801
 802 @deffn {Função} polytocompanion (@var{p}, @var{x})
 803
 804 Se @var{p} for um polinómio em @var{x}, retorna a atriz companheira de @var{p}. Para
 805 um polinómio m@^onico @var{p} de grau @var{n},
 806 temos @code{@var{p} = (-1)^@var{n} charpoly (polytocompanion (@var{p}, @var{x}))}.
 807
 808 Quando @var{p} não for um polinómio em @var{x}, emite uma mensagem de erro.
 809
 810 @end deffn
 811
 812 @deffn {Função} ptriangularize (@var{M}, @var{v})
 813
 814 Se @var{M} for uma matriz onde cada entrada dessa matriz for um polinómio em @var{v}, retorna
 815 a matriz @var{M2} tal que
 816
 817 (1) @var{M2} é triangular alta,
 818
 819 (2) @code{@var{M2} = @var{E_n} ... @var{E_1} @var{M}},
 820 onde os elemetnos de @var{E_1} a @var{E_n} são matrizes elementares
 821 cujas entrada são polinómios em @var{v},
 822
 823 (3) @code{|det (@var{M})| = |det (@var{M2})|},
 824
 825 Nota: Essa função não verifica se toda entrada é um polinómio em @var{v}.
 826
 827 @end deffn
 828
 829 @deffn {Função} rowop (@var{M}, @var{i}, @var{j}, @var{theta})
 830
 831 Se @var{M} for uma matriz, retorna a matriz que resulta de se fazer a
 832 operação de linha @code{R_i <- R_i - theta * R_j}. Se @var{M} não tiver uma linha
 833 @var{i} ou @var{j}, emite uma mensagem de erro.
 834
 835 @end deffn
 836
 837 @deffn {Função} rank (@var{M})
 838
 839 Retorna o ranque daquela matriz @var{M}. O rank é a dimensão do
 840 espaço coluna. Exemplo:
 841 @c ===beg===
 842 @c load ("linearalgebra")$
 843 @c rank(matrix([1,2],[2,4]));
 844 @c rank(matrix([1,b],[c,d]));
 845 @c ===end===
 846 @example
 847 (%i1) load ("linearalgebra")$
 848 WARNING: DEFUN/DEFMACRO: redefining function $COPY in
 849          /share/maxima/5.11.0/share/linearalgebra/linalg-utilities.lisp,
 850          was defined in
 851          /maxima-5.11.0/src/binary-clisp/comm2.fas
 852 (%i2) rank(matrix([1,2],[2,4]));
 853 (%o2)                                  1
 854 (%i3) rank(matrix([1,b],[c,d]));
 855 Proviso:  @{d - b c # 0@}
 856 (%o3)                                  2
 857 @end example
 858
 859 @end deffn
 860
 861
 862 @deffn {Função} rowswap (@var{M}, @var{i}, @var{j})
 863
 864 Se @var{M} for uma matriz, permuta as linha @var{i} e @var{j}. Se @var{M} não tiver uma linha
 865 @var{i} ou @var{j}, emite uma mensagem de erro.
 866
 867 @end deffn
 868
 869 @deffn {Função} toeplitz (@var{col})
 870 @deffnx {Função} toeplitz (@var{col}, @var{lin})
 871
 872 Retorna uma matriz de Toeplitz @var{T}. a primeira coluna de @var{T} é @var{col};
 873 excepto para a primeira entrada, a primeira linha de @var{T} é @var{lin}. O
 874 padrão para @var{lin} é o conjugado complexo de @var{col}. Exemplo:
 875 @c ===beg===
 876 @c load("linearalgebra")$
 877 @c toeplitz([1,2,3],[x,y,z]);
 878 @c toeplitz([1,1+%i]);
 879 @c ===end===
 880 @example
 881 (%i1) load("linearalgebra")$
 882
 883 (%i2)  toeplitz([1,2,3],[x,y,z]);
 884
 885                                   [ 1  y  z ]
 886                                   [         ]
 887 (%o2)                             [ 2  1  y ]
 888                                   [         ]
 889                                   [ 3  2  1 ]
 890 (%i3)  toeplitz([1,1+%i]);
 891
 892                               [   1     1 - %I ]
 893 (%o3)                         [                ]
 894                               [ %I + 1    1    ]
 895 @end example
 896
 897 @end deffn
 898
 899 @deffn {Função} vandermonde_matrix ([@var{x_1}, ..., @var{x_n}])
 900
 901 Retorna uma matriz @var{n} por @var{n} cuja @var{i}-ésima linha é
 902 @code{[1, @var{x_i}, @var{x_i}^2, ... @var{x_i}^(@var{n}-1)]}.
 903
 904 @end deffn
 905
 906 @deffn {Função} zerofor (@var{M})
 907 @deffnx {Função}  zerofor (@var{M}, @var{fld})
 908
 909 Retorna uma matriz zero que tem o mesmo tamanho da matriz
 910 @var{M}.  Toda entrada da matriz zero é a
 911 identidade aditiva do anel @var{fld}; o valor padrão para
 912 @var{fld} é @var{generalring}.
 913
 914 O primeiro argumento @var{M} pode ser uma matriz quadrada ou uma
 915 não matriz. Quando @var{M} for uma matriz, cada entrada de @var{M} pode ser uma
 916 matriz quadrada -- dessa forma @var{M} pode ser uma matriz de bloco do Maxima. A
 917 matriz pode ser de bloco para qualquer nível (finito).
 918
 919 Veja também @code{identfor}
 920
 921 @end deffn
 922
 923 @deffn {Função} zeromatrixp (@var{M})
 924
 925 Se @var{M} não for uma matriz de bloco, retorna @code{true} se @code{is (equal (@var{e}, 0))}
 926 for verdadeiro para cada elemento @var{e} da matriz @var{M}.  Se @var{M} for uma matriz de bloco, retorna
 927 @code{true} se @code{zeromatrixp} avaliar para @code{true} para cada elemento de @var{e}.
 928
 929 @end deffn
 930