Matrices sin álgebra lineal

Notas del curso MATE 3009, UPR­Humacao, mayo 2007.
Matrices sin álgebra lineal
Esta es una ilustración de cómo podemos usar matrices fuera del contexto del álgebra lineal.
Las matrices, como arreglos rectangulares de números, son útiles para representar propiedades en un
plano. Por ejemplo, las temperaturas en distintos puntos de una placa de metal se puede representar
con una matriz. Digamos que queremos usar una matriz 50x50. Podemos dividir la placa en un
cuadriculado 50x50.
const int N = 50, M=50;
double placa[NMAX][MMAX];
Cada entrada de la matriz puede representar la temperatura promedio en el cuadro correspondiente.
Valores iniciales
Podemos usar una función para iniciar la temperatura uniforme de la placa a un valor dado.
for(int n=0; n < N; n++)
for(int m=0; m < M; m++)
placa[n][m] = tInterior;
Aquí tInterior contiene la temperatura que queremos asignar a toda la placa. Suponga ahora que
queremos poner una fuente de calor pegada a la base de la placa. Eso mantendría ese borde de la placa
a esa temperatura. Para simular esa condición podemos poner la región apropiada de la matriz a esa
temperatura de la siguiente manera:
tempMax = tBorde;
for(int m=M/3; m < M*2/3; m++) placa[0][m] = tempMax;
Aquí estamos asignándole otra temperatura a una tercera parte del borde inferior de la placa. Podemos
unir todo esto para formar una función:
void iniciaPlaca(const double tInterior, const double tBorde) {
for(int n=0; n < N; n++)
for(int m=0; m < M; m++)
placa[n][m] = tInterior;
tempMax = tBorde; tempMin = tInterior;
for(int m=M/3; m < M*2/3; m++) placa[0][m] = tempMax;
}
Si queremos iniciar una placa a temperatura ambiente y una fuente de calor a 400 grados podemos usar

esa función haciendo la llamada
iniciaPlaca(25.0, 400.0);
Representación gráfica
Podemos usar una biblioteca gráfica simple para representar la temperatura de la placa en colores
falsos. La biblioteca que usamos en esta ilustración es “Introductory Graphics Library using
GLUT/OpenGL” de la Universidad Northwestern. A la plantilla del programa sólo tenemos que
cambiarle las funciones main() y myDisplay(). Sabemos cual es la función de main(). Por ahí
comienza a ejecutarse el programa. Así que allí es que tenemos que inicializar los valores de nuestra
placa:
int main(int argc, char **argv)
{
iniciaPlaca(25.0, 200.0);
InitGraphics();
return 0;
}
// añadido para la placa
// start GLUT/OpenGL
La función myDisplay() es llamada por el sistema gráfico para actualizar el dibujo cada vez que sea
necesario. Por tanto allí añadimos nuestra función para dibujar:
void myDisplay(void)
{
dibujaPlaca();
}
Pero no hemos definido a dibujaPlaca(). Para hacerlo simplemente recorremos la matriz que
tiene la información de la matriz y pintamos un cuadrito con un color que represente esa temperatura:
void dibujaPlaca(){
int anchoCuadrito = 400 / N;
}
for(int n=0; n < N; n++) // ciclos para recorrer la matriz
for(int m=0; m < M; m++){
double intensidad = (placa[n][m]­tempMin)/(tempMax­tempMin);
SetPenColor(intensidad, 0.0, 1.0­intensidad);
int baseX = n * anchoCuadrito, baseY = m * anchoCuadrito;
DrawFillBox(baseX, baseY, baseX+anchoCuadrito,
baseY+anchoCuadrito);
}
Note que:

● para determinar anchoCuadrito se divide el tamaño total en píxeles del área en que se va a
dibujar (en este caso 400) por la cantidad de entradas en la matriz (N) para saber qué ancho
tiene cada cuadrito.
● intensidad es un valor entre 0 y 1.
● SetPenColor es azul cuando la intensidad es cero, rojo cuando es uno y un color intermedio
en otros casos.
El meollo de la simulación
Para que la simulación evolucione tenemos que recomputar la matriz de temperaturas periódicamente.
Tenemos que definir un criterio para saber cuales son las nuevas temperaturas basadas en la
información anterior. La siguiente estrategia es muy común. La temperatura en una celda depende de
su temperatura y la de sus celdas vecinas. Si la temperaturas de las vecinas son más altas la celda se
debe calentar y si son más frías se debe enfriar. Una fórmula que refleja esto es:
placa[n][m] + (promTemp ­ placa[n][m]) * difusividad
PromTemp es el promedio de las temperaturas de las 8 celdas vecinas y difusividad es un parámetro
que define cuan rápido se disipa el calor en ese material. Tenemos que hacer eso con todas las celdas
interiores. Las del borde no tienen vecinas en todos los lados y requieren atención especial. Una
función que atiende el cómputo de las nuevas temperaturas en el interior es:
void calculaTemperaturas(const double difusividad){
for(int n=1; n < N­1; n++) // recorre matriz los
for(int m=1; m < M­1; m++){ // bordes no se consideran
double acumTemp = 0.0;
for(int dn=­1; dn