| blob | 231cdcf1852c7bb89aa99fafe8a5039d2bd6661d |
1 @c English version: 2009-12-10
2 @menu
3 * Funciones y variables para diag::
4 @end menu
6 @node Funciones y variables para diag, , diag, diag
7 @section Funciones y variables para diag
10 @deffn {Función} diag (@var{lm})
11 Genera una matriz cuadrada con las matrices de @var{lm}
12 en la diagonal, siendo @var{lm} una lista de matrices o de
13 escalares.
15 Ejemplo:
16 @example
17 (%i1) load("diag")$
19 (%i2) a1:matrix([1,2,3],[0,4,5],[0,0,6])$
21 (%i3) a2:matrix([1,1],[1,0])$
23 (%i4) diag([a1,x,a2]);
24 [ 1 2 3 0 0 0 ]
25 [ ]
26 [ 0 4 5 0 0 0 ]
27 [ ]
28 [ 0 0 6 0 0 0 ]
29 (%o4) [ ]
30 [ 0 0 0 x 0 0 ]
31 [ ]
32 [ 0 0 0 0 1 1 ]
33 [ ]
34 [ 0 0 0 0 1 0 ]
35 @end example
37 Antes de hacer uso de esta función ejecútese @code{load("diag")}.
38 @end deffn
41 @deffn {Función} JF (@var{lambda},@var{n})
42 Devuelve la célula de Jordan de orden @var{n} con
43 valor propio @var{lambda}.
45 Ejemplo:
46 @example
47 (%i1) load("diag")$
49 (%i2) JF(2,5);
50 [ 2 1 0 0 0 ]
51 [ ]
52 [ 0 2 1 0 0 ]
53 [ ]
54 (%o2) [ 0 0 2 1 0 ]
55 [ ]
56 [ 0 0 0 2 1 ]
57 [ ]
58 [ 0 0 0 0 2 ]
59 (%i3) JF(3,2);
60 [ 3 1 ]
61 (%o3) [ ]
62 [ 0 3 ]
63 @end example
65 Antes de hacer uso de esta función ejecútese @code{load("diag")}.
66 @end deffn
69 @deffn {Función} jordan (@var{mat})
70 Devuelve la forma de Jordan de la matriz @var{mat}, pero
71 en formato de lista de Maxima. Para obtener la matriz
72 correspondiente, llámese a la función @code{dispJordan}
73 utilizando como argumento la salida de @code{jordan}.
75 Ejemplo:
76 @example
77 (%i1) load("diag")$
79 (%i3) a:matrix([2,0,0,0,0,0,0,0],
80 [1,2,0,0,0,0,0,0],
81 [-4,1,2,0,0,0,0,0],
82 [2,0,0,2,0,0,0,0],
83 [-7,2,0,0,2,0,0,0],
84 [9,0,-2,0,1,2,0,0],
85 [-34,7,1,-2,-1,1,2,0],
86 [145,-17,-16,3,9,-2,0,3])$
88 (%i34) jordan(a);
89 (%o4) [[2, 3, 3, 1], [3, 1]]
90 (%i5) dispJordan(%);
91 [ 2 1 0 0 0 0 0 0 ]
92 [ ]
93 [ 0 2 1 0 0 0 0 0 ]
94 [ ]
95 [ 0 0 2 0 0 0 0 0 ]
96 [ ]
97 [ 0 0 0 2 1 0 0 0 ]
98 (%o5) [ ]
99 [ 0 0 0 0 2 1 0 0 ]
100 [ ]
101 [ 0 0 0 0 0 2 0 0 ]
102 [ ]
103 [ 0 0 0 0 0 0 2 0 ]
104 [ ]
105 [ 0 0 0 0 0 0 0 3 ]
106 @end example
108 Antes de hacer uso de esta función ejecútese @code{load("diag")}.
109 Véanse también @code{dispJordan} y @code{minimalPoly}.
110 @end deffn
113 @deffn {Función} dispJordan (@var{l})
114 Devuelve la matriz de Jordan asociada a la codificación
115 dada por la lista @var{l}, que habitualmente será la salida
116 de la función @code{jordan}.
118 Ejemplo:
119 @example
120 (%i1) load("diag")$
122 (%i2) b1:matrix([0,0,1,1,1],
123 [0,0,0,1,1],
124 [0,0,0,0,1],
125 [0,0,0,0,0],
126 [0,0,0,0,0])$
128 (%i3) jordan(b1);
129 (%o3) [[0, 3, 2]]
130 (%i4) dispJordan(%);
131 [ 0 1 0 0 0 ]
132 [ ]
133 [ 0 0 1 0 0 ]
134 [ ]
135 (%o4) [ 0 0 0 0 0 ]
136 [ ]
137 [ 0 0 0 0 1 ]
138 [ ]
139 [ 0 0 0 0 0 ]
140 @end example
142 Antes de hacer uso de esta función ejecútese @code{load("diag")}.
143 Véanse también @code{jordan} y @code{minimalPoly}.
144 @end deffn
147 @deffn {Función} minimalPoly (@var{l})
148 Devuelve el polinomio mínimo asociado a la
149 codificación dada por la lista @var{l}, que habitualmente
150 será la salida de la función @code{jordan}.
152 Ejemplo:
153 @example
154 (%i1) load("diag")$
156 (%i2) a:matrix([2,1,2,0],
157 [-2,2,1,2],
158 [-2,-1,-1,1],
159 [3,1,2,-1])$
161 (%i3) jordan(a);
162 (%o3) [[- 1, 1], [1, 3]]
163 (%i4) minimalPoly(%);
164 3
165 (%o4) (x - 1) (x + 1)
166 @end example
168 Antes de hacer uso de esta función ejecútese @code{load("diag")}.
169 Véanse también @code{jordan} y @code{dispJordan}.
170 @end deffn
172 @deffn {Función} ModeMatrix (@var{A},@var{l})
173 Devuelve la matriz @var{M} tal que @math{(M^^-1).A.M=J},
174 donde @var{J} es la forma de Jordan de @var{A}. La lista @var{l}
175 es la forma codificada de la forma de Jordan tal como la
176 devuelve la función @code{jordan}.
178 Ejemplo:
179 @example
180 (%i1) load("diag")$
182 (%i2) a:matrix([2,1,2,0],
183 [-2,2,1,2],
184 [-2,-1,-1,1],
185 [3,1,2,-1])$
187 (%i3) jordan(a);
188 (%o3) [[- 1, 1], [1, 3]]
189 (%i4) M: ModeMatrix(a,%);
190 [ 1 - 1 1 1 ]
191 [ ]
192 [ 1 ]
193 [ - - - 1 0 0 ]
194 [ 9 ]
195 [ ]
196 (%o4) [ 13 ]
197 [ - -- 1 - 1 0 ]
198 [ 9 ]
199 [ ]
200 [ 17 ]
201 [ -- - 1 1 1 ]
202 [ 9 ]
203 (%i5) is( (M^^-1).a.M = dispJordan(%o3) );
204 (%o5) true
205 @end example
206 Nótese que @code{dispJordan(%o3)} es la forma de Jordan de la matriz @code{a}.
208 Antes de hacer uso de esta función ejecútese @code{load("diag")}.
209 Véanse también @code{jordan} y @code{dispJordan}.
210 @end deffn
213 @deffn {Función} mat_function (@var{f},@var{mat})
214 Devuelve @math{f(mat)}, siendo @var{f} una función analítica
215 y @var{mat} una matriz. Este cálculo se basa en la fórmula integral
216 de Cauchy, que establece que si @code{f(x)} es analítica y
217 @example
218 mat=diag([JF(m1,n1),...,JF(mk,nk)]),
219 @end example
221 entonces
223 @example
224 f(mat)=ModeMatrix*diag([f(JF(m1,n1)),...,f(JF(mk,nk))])
225 * ModeMatrix^^(-1)
226 @end example
228 Nótese que hay otros métodos alternativos para
229 realizar este cálculo.
231 Se presentan algunos ejemplos.
233 Ejemplo 1:
234 @example
235 (%i1) load("diag")$
237 (%i2) b2:matrix([0,1,0], [0,0,1], [-1,-3,-3])$
239 (%i3) mat_function(exp,t*b2);
240 2 - t
241 t %e - t - t
242 (%o3) matrix([-------- + t %e + %e ,
243 2
244 - t - t - t
245 2 %e %e - t - t %e
246 t (- ----- - ----- + %e ) + t (2 %e - -----)
247 t 2 t
248 t
249 - t - t - t
250 - t - t %e 2 %e %e
251 + 2 %e , t (%e - -----) + t (----- - -----)
252 t 2 t
253 2 - t - t - t
254 - t t %e 2 %e %e - t
255 + %e ], [- --------, - t (- ----- - ----- + %e ),
256 2 t 2
257 t
258 - t - t 2 - t
259 2 %e %e t %e - t
260 - t (----- - -----)], [-------- - t %e ,
261 2 t 2
262 - t - t - t
263 2 %e %e - t - t %e
264 t (- ----- - ----- + %e ) - t (2 %e - -----),
265 t 2 t
266 t
267 - t - t - t
268 2 %e %e - t %e
269 t (----- - -----) - t (%e - -----)])
270 2 t t
271 (%i4) ratsimp(%);
272 [ 2 - t ]
273 [ (t + 2 t + 2) %e ]
274 [ -------------------- ]
275 [ 2 ]
276 [ ]
277 [ 2 - t ]
278 (%o4) Col 1 = [ t %e ]
279 [ - -------- ]
280 [ 2 ]
281 [ ]
282 [ 2 - t ]
283 [ (t - 2 t) %e ]
284 [ ---------------- ]
285 [ 2 ]
286 [ 2 - t ]
287 [ (t + t) %e ]
288 [ ]
289 Col 2 = [ 2 - t ]
290 [ - (t - t - 1) %e ]
291 [ ]
292 [ 2 - t ]
293 [ (t - 3 t) %e ]
294 [ 2 - t ]
295 [ t %e ]
296 [ -------- ]
297 [ 2 ]
298 [ ]
299 [ 2 - t ]
300 Col 3 = [ (t - 2 t) %e ]
301 [ - ---------------- ]
302 [ 2 ]
303 [ ]
304 [ 2 - t ]
305 [ (t - 4 t + 2) %e ]
306 [ -------------------- ]
307 [ 2 ]
309 @end example
312 Ejemplo 2:
313 @example
314 (%i5) b1:matrix([0,0,1,1,1],
315 [0,0,0,1,1],
316 [0,0,0,0,1],
317 [0,0,0,0,0],
318 [0,0,0,0,0])$
320 (%i6) mat_function(exp,t*b1);
321 [ 2 ]
322 [ t ]
323 [ 1 0 t t -- + t ]
324 [ 2 ]
325 [ ]
326 (%o6) [ 0 1 0 t t ]
327 [ ]
328 [ 0 0 1 0 t ]
329 [ ]
330 [ 0 0 0 1 0 ]
331 [ ]
332 [ 0 0 0 0 1 ]
333 (%i7) minimalPoly(jordan(b1));
334 3
335 (%o7) x
336 (%i8) ident(5)+t*b1+1/2*(t^2)*b1^^2;
337 [ 2 ]
338 [ t ]
339 [ 1 0 t t -- + t ]
340 [ 2 ]
341 [ ]
342 (%o8) [ 0 1 0 t t ]
343 [ ]
344 [ 0 0 1 0 t ]
345 [ ]
346 [ 0 0 0 1 0 ]
347 [ ]
348 [ 0 0 0 0 1 ]
349 (%i9) mat_function(exp,%i*t*b1);
350 [ 2 ]
351 [ t ]
352 [ 1 0 %i t %i t %i t - -- ]
353 [ 2 ]
354 [ ]
355 (%o9) [ 0 1 0 %i t %i t ]
356 [ ]
357 [ 0 0 1 0 %i t ]
358 [ ]
359 [ 0 0 0 1 0 ]
360 [ ]
361 [ 0 0 0 0 1 ]
362 (%i10) mat_function(cos,t*b1)+%i*mat_function(sin,t*b1);
363 [ 2 ]
364 [ t ]
365 [ 1 0 %i t %i t %i t - -- ]
366 [ 2 ]
367 [ ]
368 (%o10) [ 0 1 0 %i t %i t ]
369 [ ]
370 [ 0 0 1 0 %i t ]
371 [ ]
372 [ 0 0 0 1 0 ]
373 [ ]
374 [ 0 0 0 0 1 ]
375 @end example
377 Ejemplo 3:
378 @example
379 (%i11) a1:matrix([2,1,0,0,0,0],
380 [-1,4,0,0,0,0],
381 [-1,1,2,1,0,0],
382 [-1,1,-1,4,0,0],
383 [-1,1,-1,1,3,0],
384 [-1,1,-1,1,1,2])$
386 (%i12) fpow(x):=block([k],declare(k,integer),x^k)$
388 (%i13) mat_function(fpow,a1);
389 [ k k - 1 ] [ k - 1 ]
390 [ 3 - k 3 ] [ k 3 ]
391 [ ] [ ]
392 [ k - 1 ] [ k k - 1 ]
393 [ - k 3 ] [ 3 + k 3 ]
394 [ ] [ ]
395 [ k - 1 ] [ k - 1 ]
396 [ - k 3 ] [ k 3 ]
397 (%o13) Col 1 = [ ] Col 2 = [ ]
398 [ k - 1 ] [ k - 1 ]
399 [ - k 3 ] [ k 3 ]
400 [ ] [ ]
401 [ k - 1 ] [ k - 1 ]
402 [ - k 3 ] [ k 3 ]
403 [ ] [ ]
404 [ k - 1 ] [ k - 1 ]
405 [ - k 3 ] [ k 3 ]
406 [ 0 ] [ 0 ]
407 [ ] [ ]
408 [ 0 ] [ 0 ]
409 [ ] [ ]
410 [ k k - 1 ] [ k - 1 ]
411 [ 3 - k 3 ] [ k 3 ]
412 [ ] [ ]
413 Col 3 = [ k - 1 ] Col 4 = [ k k - 1 ]
414 [ - k 3 ] [ 3 + k 3 ]
415 [ ] [ ]
416 [ k - 1 ] [ k - 1 ]
417 [ - k 3 ] [ k 3 ]
418 [ ] [ ]
419 [ k - 1 ] [ k - 1 ]
420 [ - k 3 ] [ k 3 ]
421 [ 0 ]
422 [ ] [ 0 ]
423 [ 0 ] [ ]
424 [ ] [ 0 ]
425 [ 0 ] [ ]
426 [ ] [ 0 ]
427 Col 5 = [ 0 ] Col 6 = [ ]
428 [ ] [ 0 ]
429 [ k ] [ ]
430 [ 3 ] [ 0 ]
431 [ ] [ ]
432 [ k k ] [ k ]
433 [ 3 - 2 ] [ 2 ]
434 @end example
436 Antes de hacer uso de esta función ejecútese @code{load("diag")}.
437 @end deffn