Ejemplo 9. Wronskiano de n funciones.

El Wronskiano es una función muy usada en el análisis y solución de sistemas de Ecuaciones Diferenciales. 

Su principal utilidad es determinar si n funciones son linealmente independientes.

El Wronskiano se define:

$$W(f_1,f_2,...,f_n)=\begin{vmatrix}f_1 & f_2 & f_3 & ... & f_n \\ f'_1 & f'_2 & f'_3 & ... & f'_n \\ f''_1 & f''_2 & f''_3 & ... & f''_n \\ \vdots & \vdots & \vdots & \ddots & \vdots \\f_{1}^{^(n-1)} & f_{2}^{^(n-1)} & f_{3}^{^(n-1)} & ... & f_{n}^{^(n-1)}\end{vmatrix}$$

Siempre y cuando:

$$f_{n}=f_{n}(x)$$

Ya que se trata de un determinante, la matriz siempre es cuadrada, es decir, de dimensiones nxn. El número de funciones determina esa dimensión. Por ejemplo, si se tienen dos funciones, la matriz será de 2x2, si son 4 funciones, la matriz será 4x4.

El primer renglón tiene las funciones iniciales, es decir, $\frac{d^0 f_{n}}{dx^0}$

El segundo renglón tiene las primeras derivadas de las funciones iniciales: $\frac{d^1 f_{n}}{dx^1}$

El tercer renglón, las segundas derivadas de las funciones iniciales: $\frac{d^2 f_{n}}{dx^2}$

El n-ésimo renglón tiene las (n-1) derivadas de las funciones iniciales: $\frac{d^{n-1} f_{n}}{dx^{n-1}}$

*El orden de la derivada está dado por el índice del renglón menos uno. Fíjate en el renglón 1, es la derivada de orden cero (1-1), en el renglón 2, se trata de la derivada de orden 1 (2-1).

Como se ve, la función W no es tan compleja, simplemente debemos saber cómo usar matrices en la programación con TI-BASIC.

Propongamos un algoritmo:

1. La función recibe un vector con las n funciones iniciales.
2. Se obtiene el número n de funciones.
3. Se crea una matriz nxn.
4. Se guardan las funciones iniciales en el primer renglón de la matriz.
5. Inicio de un ciclo que repita lo siguiente:
1. Calcular derivada de orden (numFila - 1)
2. Guardar en el elemento correspondiente.
6. Calcular el determinante de la matriz final.
7. Regresar el resultado.

Antes de presentar el diagrama de flujo debes conocer lo siguiente, que se trata del algoritmo de un recorrido típico de una matriz, usando dos ciclos For anidados. Esto permite moverse por cada elemento de una matriz. Veamos el siguiente ejemplo:

[ 1,1 ][ 1,2 ][ 1,3 ]

[ 2,1 ][ 2,2 ][ 2,3 ]

[ 3,1 ][ 3,2 ][ 3,3 ]

Indicamos el índice de un elemento con dos variables [ i,j ], donde i representa el índice de fila y j el índice de columna. Como leíste, las dos son variables que para la matriz de arriba pueden tomar valores desde 1 hasta 3:

$$i\in[1,3]$$

$$j\in[1,3]$$

Por ejemplo, cuando $i=1$ y $j=2$, accedemos al elemento [ 1,2 ].

Con un ciclo puedo acceder a una fila o a una columna, dejando fija la otra variable. Imagina lo siguiente:

Aquí fijo j con el valor de 1, lo que me permitirá moverme sólo a través de la columna 1. i comienza en 1, por lo que el primer elemento que muestra es el [ 1,1 ].

i incrementa y ahora tiene el valor de 2, entonces se muestra [ 2,1 ]

i toma su último valor que es 3, por lo tanto, se muestra el elemento [ 3,1 ].

De esta forma sólo recorrí tres elementos de los nueve que tiene la matriz.

Ahora analicemos el siguiente algoritmo:

Ahora i tiene un valor fijo de 2. Esto sólo me deja recorrer los elementos de la fila número 2.

j variará desde 1 hasta 3, por lo que se muestran los elementos en el siguiente orden:

[ 2,1 ]

[ 2,2 ]

[ 2,3 ]

El siguiente algoritmo nos permite recorrer los elementos de la diagonal principal:

i comienza en 1 y termina en 3. Primero muestra el elemento [ 1,1 ]. i toma el valor de 2, por lo que imprime [ 2,2 ].Por último, i=3, entonces se muestra [ 3,3 ].

Como se ve es completamente necesario usar dos ciclos para recorrer toda la matriz:

Veamos:

i=1, j=1 $\rightarrow$ [ 1,1 ], j incrementa

i=1, j=2 $\rightarrow$ [ 1,2 ], j incrementa

i=1, j=3 $\rightarrow$ [ 1,3 ], j incrementa

i incrementa, j=1

i=2, j=1 $\rightarrow$ [ 2,1 ], j incrementa

i=2, j=2 $\rightarrow$ [ 2,2 ], j incrementa

i=2, j=3 $\rightarrow$ [ 2,3 ], j incrementa

i incrementa, j=2

i=3, j=1 $\rightarrow$ [ 3,1 ], j incrementa

i=3, j=2 $\rightarrow$ [ 3,2 ], j incrementa

i=3, j=3 $\rightarrow$ [ 3,3 ], j incrementa

terminan los ciclos

De esta forma accedemos por filas a cada uno de los elementos de la matriz. Teniendo esto, podemos continuar.

Nuestra función en la calculadora quedaría de la siguiente forma, (más detallada que en el diagrama):

Agregamos un editor de programas:

Como argumento recibe una matriz de 1 fila, n columnas (un vector), de forma que lo declaramos:

Veamos las variables que necesitaremos:

• Según nuestro algoritmo, usaremos una matriz de forma iterativa para llenarse a sí misma, por lo que declaramos una variable que almacenará dicha matriz, yo la llamo matRes (por matriz resultado) .
• Usaremos dos variables iteradoras i y j.
• Ya que la matriz del wrosnkiano es cuadrada nxn con n que corresponde al número de funciones, declaramos una variable n.

Y serían todas las variables necesarias.

Comencemos obteniendo el número de funciones n, que es igual al número de columnas de la matriz que se pasa como argumento. Para ello usamos el comando:

colDim(matriz)

Ahora hay que hacer algo nuevo para nosotros:

En los ejemplos anteriores trabajamos sobre matrices y vectores ya definidos, es decir, tenían una magnitud que no se iba a modificar. Por ejemplo, comenzaban de tamaño 6x3, y terminaban de tamaño 6x3.

En el caso de este ejemplo del wrosnkiano, comienza siempre de tamaño 1xn. Y debe aumentar hasta un tamaño nxn. 

Yo prefiero inicializar la matriz de la siguiente forma: ya conocemos n, de forma que se crea una matriz nxn llena de números aleatorios.

¿Y por qué de números aleatorios? Desde mi punto de vista es la forma más fácil de crear una matriz con un sólo comando. Después modificaremos cada elemento por el que necesitamos. PAra ello usamos el comando:

randMat(filas,columnas)

Con esto último:

matres:=randmat(n,n)

Creamos una matriz cuadrada aleatoria nxn y la asignamos a la variable matres.

Por definición del wrosnkiano y por nuestro algoritmo, matRes debe tener las funciones iniciales en el primer renglón, las cuales asignamos con un ciclo, tomando cada elemento de la matriz que pasamos como argumento y poniéndolo en el lugar correspondiente en la matriz matRes.

De esta forma ponemos las funciones están en el primer renglón de la matriz resultado matRes.

Vamos a mostrar el resultado regresando matRes:

Almacenemos CTRL + B y ejecutemos la función CTRL + R.

Pasamos una matriz de prueba, como la que se muestra. Podemos observar que matRes tiene las funciones que queremos en el primer renglón.

Continuemos.

Ahora hay que calcular las derivadas según el algoritmo: en el renglón 2 la primera derivada, en el renglón 3 la segunda derivada, ..., en el renglón n la derivada n-1.

Se usan dos ciclos For, uno con la variable iteradora i y otro con la variable iteradora j. En este caso, por la forma en que anidamos ambos ciclos, el ciclo con i corresponde a la fila y el ciclo con j a la columna.

NOTA: Esta estructura con dos ciclos For nos permite realizar un recorrido por cada elemento de una matriz, procura recordarla, es bastante útil.

Bien, ahora a calcular cada derivada:

Ya que el wronskiano es el determinante de esa matriz, regresamos el resultado del comando:

det(matriz)

Con esto habremos terminado nuestra función, ahora probemos:

El archivo se encuentra en el repositorio de GitHub:
https://github.com/ailr16/TINspireCXCAS-Programacion/blob/master/TI%20Basic/cursoDeProgramacion/wronskiano.tns

Con este ejemplo, vimos otras formas de trabajar con matrices, las cuales resultan de mucha utilidad para guardar datos y trabajar con ellos. Si tienes dudas o necesitas ayuda con algún programa, házmelo saber en los comentarios 😛.