doc/info/ru/diag.texi

   1 @c Language=Russian
   2 @c Encoding=UTF-8
   3 @c File=diag.texi
   4 @c OriginalRevision=1.5
   5 @c TranslatedBy: (c) 2007-07 Vadim V. Zhytnikov <vvzhyt@gmail.com>
   6
   7 @menu
   8 * Функции и переменные пакета diag::
   9 @end menu
  10
  11 @node Функции и переменные пакета diag,  , Пакет diag, Пакет diag
  12 @section Функции и переменные пакета diag
  13
  14
  15 @deffn {Функция} diag (@var{lm})
  16 Строит квадратную матрицу с матрицами из @var{lm} на диагонали. Здесь, @var{lm} есть список матриц или скаляров.
  17
  18 Пример:
  19 @example
  20 (%i1) load("diag")$
  21
  22 (%i2) a1:matrix([1,2,3],[0,4,5],[0,0,6])$
  23
  24 (%i3) a2:matrix([1,1],[1,0])$
  25
  26 (%i4) diag([a1,x,a2]);
  27                    [ 1  2  3  0  0  0 ]
  28                    [                  ]
  29                    [ 0  4  5  0  0  0 ]
  30                    [                  ]
  31                    [ 0  0  6  0  0  0 ]
  32 (%o4)              [                  ]
  33                    [ 0  0  0  x  0  0 ]
  34                    [                  ]
  35                    [ 0  0  0  0  1  1 ]
  36                    [                  ]
  37                    [ 0  0  0  0  1  0 ]
  38 @end example
  39
  40 Для использования функцию следует загрузить командой @code{load("diag")}.
  41
  42 @opencatbox{Категории:}
  43 @category{Матрицы}
  44 @category{Пакеты библиотеки share}
  45 @category{Пакет diag}
  46 @closecatbox
  47
  48 @end deffn
  49
  50
  51 @deffn {Функция} JF (@var{lambda},@var{n})
  52 Возвращает жорданову клетку порядка @var{n} с собственными значениями @var{lambda}.
  53
  54 Пример:
  55 @example
  56 (%i1) load("diag")$
  57
  58 (%i2) JF(2,5);
  59                     [ 2  1  0  0  0 ]
  60                     [               ]
  61                     [ 0  2  1  0  0 ]
  62                     [               ]
  63 (%o2)               [ 0  0  2  1  0 ]
  64                     [               ]
  65                     [ 0  0  0  2  1 ]
  66                     [               ]
  67                     [ 0  0  0  0  2 ]
  68 (%i3) JF(3,2);
  69                          [ 3  1 ]
  70 (%o3)                    [      ]
  71                          [ 0  3 ]
  72 @end example
  73
  74 Для использования функцию следует загрузить командой @code{load("diag")}.
  75
  76 @opencatbox{Категории:}
  77 @category{Пакет diag}
  78 @closecatbox
  79
  80 @end deffn
  81
  82
  83 @deffn {Функция} jordan (@var{mat})
  84 Возвращает жорданову форму матрицы @var{mat}, но представленную в форме списка Maxima.
  85 Для получения матрицы к результату функции @code{jordan} следует применить функцию @code{dispJordan}.
  86
  87 Пример:
  88 @example
  89 (%i1) load("diag")$
  90
  91 (%i3) a:matrix([2,0,0,0,0,0,0,0],
  92                [1,2,0,0,0,0,0,0],
  93                [-4,1,2,0,0,0,0,0],
  94                [2,0,0,2,0,0,0,0],
  95                [-7,2,0,0,2,0,0,0],
  96                [9,0,-2,0,1,2,0,0],
  97                [-34,7,1,-2,-1,1,2,0],
  98                [145,-17,-16,3,9,-2,0,3])$
  99
 100 (%i34) jordan(a);
 101 (%o4)             [[2, 3, 3, 1], [3, 1]]
 102 (%i5) dispJordan(%);
 103                 [ 2  1  0  0  0  0  0  0 ]
 104                 [                        ]
 105                 [ 0  2  1  0  0  0  0  0 ]
 106                 [                        ]
 107                 [ 0  0  2  0  0  0  0  0 ]
 108                 [                        ]
 109                 [ 0  0  0  2  1  0  0  0 ]
 110 (%o5)           [                        ]
 111                 [ 0  0  0  0  2  1  0  0 ]
 112                 [                        ]
 113                 [ 0  0  0  0  0  2  0  0 ]
 114                 [                        ]
 115                 [ 0  0  0  0  0  0  2  0 ]
 116                 [                        ]
 117                 [ 0  0  0  0  0  0  0  3 ]
 118 @end example
 119
 120 Для использования функцию следует загрузить командой @code{load("diag")}.
 121 См. @code{dispJordan} и @code{minimalPoly}.
 122
 123 @opencatbox{Категории:}
 124 @category{Пакет diag}
 125 @closecatbox
 126
 127 @end deffn
 128
 129
 130 @deffn {Функция} dispJordan (@var{l})
 131 Возвращает жорданову матрицу, соответствующую представлению в виде Maxima списка @var{l},
 132 возвращаемого функцией @code{jordan}.
 133
 134 Пример:
 135 @example
 136 (%i1) load("diag")$
 137
 138 (%i2) b1:matrix([0,0,1,1,1],
 139                 [0,0,0,1,1],
 140                 [0,0,0,0,1],
 141                 [0,0,0,0,0],
 142                 [0,0,0,0,0])$
 143
 144 (%i3) jordan(b1);
 145 (%o3)                  [[0, 3, 2]]
 146 (%i4) dispJordan(%);
 147                     [ 0  1  0  0  0 ]
 148                     [               ]
 149                     [ 0  0  1  0  0 ]
 150                     [               ]
 151 (%o4)               [ 0  0  0  0  0 ]
 152                     [               ]
 153                     [ 0  0  0  0  1 ]
 154                     [               ]
 155                     [ 0  0  0  0  0 ]
 156 @end example
 157
 158 Для использования функцию следует загрузить командой @code{load("diag")}.
 159 См. @code{jordan} и @code{minimalPoly}.
 160
 161 @opencatbox{Категории:}
 162 @category{Пакет diag}
 163 @closecatbox
 164
 165 @end deffn
 166
 167
 168 @deffn {Функция} minimalPoly (@var{l})
 169 Возвращает минимальный многочлен, соответствующий представлению в виде Maxima списка @var{l},
 170 возвращаемого функцией @code{jordan}.
 171
 172 Пример:
 173 @example
 174 (%i1) load("diag")$
 175
 176 (%i2) a:matrix([2,1,2,0],
 177                [-2,2,1,2],
 178                [-2,-1,-1,1],
 179                [3,1,2,-1])$
 180
 181 (%i3) jordan(a);
 182 (%o3)               [[- 1, 1], [1, 3]]
 183 (%i4) minimalPoly(%);
 184                             3
 185 (%o4)                (x - 1)  (x + 1)
 186 @end example
 187
 188 Для использования функцию следует загрузить командой @code{load("diag")}.
 189 См. @code{jordan} и @code{dispJordan}.
 190
 191 @opencatbox{Категории:}
 192 @category{Пакет diag}
 193 @closecatbox
 194
 195 @end deffn
 196
 197 @deffn {Функция} ModeMatrix (@var{A},@var{l})
 198 Возвращает матрицу @var{M}, такую что @math{(M^^-1).A.M=J}, где @var{J} есть жорданова форма @var{A}.
 199 Список @var{l} является представлением жордановой формы матрицы,
 200 возвращаемым функцией @code{jordan}.
 201
 202 Пример:
 203 @example
 204 (%i1) load("diag")$
 205
 206 (%i2) a:matrix([2,1,2,0],
 207           [-2,2,1,2],
 208           [-2,-1,-1,1],
 209           [3,1,2,-1])$
 210
 211 (%i3) jordan(a);
 212 (%o3)               [[- 1, 1], [1, 3]]
 213 (%i4) M: ModeMatrix(a,%);
 214                   [  1    - 1   1   1 ]
 215                   [                   ]
 216                   [   1               ]
 217                   [ - -   - 1   0   0 ]
 218                   [   9               ]
 219                   [                   ]
 220 (%o4)             [   13              ]
 221                   [ - --   1   - 1  0 ]
 222                   [   9               ]
 223                   [                   ]
 224                   [  17               ]
 225                   [  --   - 1   1   1 ]
 226                   [  9                ]
 227 (%i5) is(  (M^^-1).a.M = dispJordan(%o3)  );
 228 (%o5)                      true
 229 @end example
 230 Отметим, что @code{dispJordan(%o3)} есть жорданова форма матрицы @code{a}.
 231
 232 Для использования функцию следует загрузить командой @code{load("diag")}.
 233 См. @code{jordan} и @code{dispJordan}.
 234
 235 @opencatbox{Категории:}
 236 @category{Пакет diag}
 237 @closecatbox
 238
 239 @end deffn
 240
 241
 242 @deffn {Функция} mat_function (@var{f},@var{mat})
 243 Возвращает @math{f(mat)}, где @var{f} есть аналитическая функция а @var{mat} -- матрица.
 244 Вычисление основано на интегральной формуле Коши, которая утверждает, что, если @code{f(x)}
 245 является аналитической функцией и
 246
 247 @example
 248 mat = diag([JF(m1,n1),...,JF(mk,nk)]),
 249 @end example
 250
 251 то
 252
 253 @example
 254 f(mat) = ModeMatrix*diag([f(JF(m1,n1)), ..., f(JF(mk,nk))])
 255                                               *ModeMatrix^^(-1)
 256 @end example
 257
 258 Отметим, что существует 6 или 8 методов выполнения данного вычисления.
 259
 260 Пример 1:
 261 @example
 262 (%i1) load("diag")$
 263
 264 (%i2) b2:matrix([0,1,0], [0,0,1], [-1,-3,-3])$
 265
 266 (%i3) mat_function(exp,t*b2);
 267                2   - t
 268               t  %e          - t     - t
 269 (%o3) matrix([-------- + t %e    + %e   ,
 270                  2
 271         - t     - t                           - t
 272  2    %e      %e        - t           - t   %e
 273 t  (- ----- - ----- + %e   ) + t (2 %e    - -----)
 274         t       2                             t
 275                t
 276                          - t          - t     - t
 277        - t       - t   %e        2  %e      %e
 278  + 2 %e   , t (%e    - -----) + t  (----- - -----)
 279                          t            2       t
 280                2   - t            - t     - t
 281      - t      t  %e        2    %e      %e        - t
 282  + %e   ], [- --------, - t  (- ----- - ----- + %e   ),
 283                  2                t       2
 284                                          t
 285         - t     - t      2   - t
 286    2  %e      %e        t  %e          - t
 287 - t  (----- - -----)], [-------- - t %e   ,
 288         2       t          2
 289         - t     - t                           - t
 290  2    %e      %e        - t           - t   %e
 291 t  (- ----- - ----- + %e   ) - t (2 %e    - -----),
 292         t       2                             t
 293                t
 294       - t     - t                 - t
 295  2  %e      %e            - t   %e
 296 t  (----- - -----) - t (%e    - -----)])
 297       2       t                   t
 298 (%i4) ratsimp(%);
 299                [   2              - t ]
 300                [ (t  + 2 t + 2) %e    ]
 301                [ -------------------- ]
 302                [          2           ]
 303                [                      ]
 304                [         2   - t      ]
 305 (%o4)  Col 1 = [        t  %e         ]
 306                [      - --------      ]
 307                [           2          ]
 308                [                      ]
 309                [     2          - t   ]
 310                [   (t  - 2 t) %e      ]
 311                [   ----------------   ]
 312                [          2           ]
 313          [      2        - t    ]
 314          [    (t  + t) %e       ]
 315          [                      ]
 316  Col 2 = [     2            - t ]
 317          [ - (t  - t - 1) %e    ]
 318          [                      ]
 319          [     2          - t   ]
 320          [   (t  - 3 t) %e      ]
 321          [        2   - t       ]
 322          [       t  %e          ]
 323          [       --------       ]
 324          [          2           ]
 325          [                      ]
 326          [      2          - t  ]
 327  Col 3 = [    (t  - 2 t) %e     ]
 328          [  - ----------------  ]
 329          [           2          ]
 330          [                      ]
 331          [   2              - t ]
 332          [ (t  - 4 t + 2) %e    ]
 333          [ -------------------- ]
 334          [          2           ]
 335
 336 @end example
 337
 338
 339 Пример 2:
 340 @example
 341 (%i5) b1:matrix([0,0,1,1,1],
 342                 [0,0,0,1,1],
 343                 [0,0,0,0,1],
 344                 [0,0,0,0,0],
 345                 [0,0,0,0,0])$
 346
 347 (%i6) mat_function(exp,t*b1);
 348                   [              2     ]
 349                   [             t      ]
 350                   [ 1  0  t  t  -- + t ]
 351                   [             2      ]
 352                   [                    ]
 353 (%o6)             [ 0  1  0  t    t    ]
 354                   [                    ]
 355                   [ 0  0  1  0    t    ]
 356                   [                    ]
 357                   [ 0  0  0  1    0    ]
 358                   [                    ]
 359                   [ 0  0  0  0    1    ]
 360 (%i7) minimalPoly(jordan(b1));
 361                              3
 362 (%o7)                       x
 363 (%i8) ident(5)+t*b1+1/2*(t^2)*b1^^2;
 364                   [              2     ]
 365                   [             t      ]
 366                   [ 1  0  t  t  -- + t ]
 367                   [             2      ]
 368                   [                    ]
 369 (%o8)             [ 0  1  0  t    t    ]
 370                   [                    ]
 371                   [ 0  0  1  0    t    ]
 372                   [                    ]
 373                   [ 0  0  0  1    0    ]
 374                   [                    ]
 375                   [ 0  0  0  0    1    ]
 376 (%i9) mat_function(exp,%i*t*b1);
 377              [                           2 ]
 378              [                          t  ]
 379              [ 1  0  %i t  %i t  %i t - -- ]
 380              [                          2  ]
 381              [                             ]
 382 (%o9)        [ 0  1   0    %i t    %i t    ]
 383              [                             ]
 384              [ 0  0   1     0      %i t    ]
 385              [                             ]
 386              [ 0  0   0     1        0     ]
 387              [                             ]
 388              [ 0  0   0     0        1     ]
 389 (%i10) mat_function(cos,t*b1)+%i*mat_function(sin,t*b1);
 390               [                           2 ]
 391               [                          t  ]
 392               [ 1  0  %i t  %i t  %i t - -- ]
 393               [                          2  ]
 394               [                             ]
 395 (%o10)        [ 0  1   0    %i t    %i t    ]
 396               [                             ]
 397               [ 0  0   1     0      %i t    ]
 398               [                             ]
 399               [ 0  0   0     1        0     ]
 400               [                             ]
 401               [ 0  0   0     0        1     ]
 402 @end example
 403
 404 Пример 3:
 405 @example
 406 (%i11) a1:matrix([2,1,0,0,0,0],
 407                  [-1,4,0,0,0,0],
 408                  [-1,1,2,1,0,0],
 409                  [-1,1,-1,4,0,0],
 410                  [-1,1,-1,1,3,0],
 411                  [-1,1,-1,1,1,2])$
 412
 413 (%i12) fpow(x):=block([k],declare(k,integer),x^k)$
 414
 415 (%i13) mat_function(fpow,a1);
 416                 [  k      k - 1 ]         [      k - 1    ]
 417                 [ 3  - k 3      ]         [   k 3         ]
 418                 [               ]         [               ]
 419                 [       k - 1   ]         [  k      k - 1 ]
 420                 [  - k 3        ]         [ 3  + k 3      ]
 421                 [               ]         [               ]
 422                 [       k - 1   ]         [      k - 1    ]
 423                 [  - k 3        ]         [   k 3         ]
 424 (%o13)  Col 1 = [               ] Col 2 = [               ]
 425                 [       k - 1   ]         [      k - 1    ]
 426                 [  - k 3        ]         [   k 3         ]
 427                 [               ]         [               ]
 428                 [       k - 1   ]         [      k - 1    ]
 429                 [  - k 3        ]         [   k 3         ]
 430                 [               ]         [               ]
 431                 [       k - 1   ]         [      k - 1    ]
 432                 [  - k 3        ]         [   k 3         ]
 433          [       0       ]         [       0       ]
 434          [               ]         [               ]
 435          [       0       ]         [       0       ]
 436          [               ]         [               ]
 437          [  k      k - 1 ]         [      k - 1    ]
 438          [ 3  - k 3      ]         [   k 3         ]
 439          [               ]         [               ]
 440  Col 3 = [       k - 1   ] Col 4 = [  k      k - 1 ]
 441          [  - k 3        ]         [ 3  + k 3      ]
 442          [               ]         [               ]
 443          [       k - 1   ]         [      k - 1    ]
 444          [  - k 3        ]         [   k 3         ]
 445          [               ]         [               ]
 446          [       k - 1   ]         [      k - 1    ]
 447          [  - k 3        ]         [   k 3         ]
 448          [    0    ]
 449          [         ]         [ 0  ]
 450          [    0    ]         [    ]
 451          [         ]         [ 0  ]
 452          [    0    ]         [    ]
 453          [         ]         [ 0  ]
 454  Col 5 = [    0    ] Col 6 = [    ]
 455          [         ]         [ 0  ]
 456          [    k    ]         [    ]
 457          [   3     ]         [ 0  ]
 458          [         ]         [    ]
 459          [  k    k ]         [  k ]
 460          [ 3  - 2  ]         [ 2  ]
 461 @end example
 462
 463 Для использования функцию следует загрузить командой @code{load("diag")}.
 464
 465 @opencatbox{Категории:}
 466 @category{Пакет diag}
 467 @closecatbox
 468
 469 @end deffn
 470
 471