\documentclass[11pt,twoside,a4paper,spanish]{article}
\usepackage[T1]{fontenc}
\usepackage{a4wide}
\usepackage{calc}
\usepackage[latin1]{inputenc}
\usepackage{isolatin1}
\usepackage{babel}
\usepackage{amsmath}
\usepackage{amsfonts}
% ---------------------------
\setlength{\textheight}{\topmargin+\headheight+\headsep+\textheight}
\setlength{\topmargin}{0pt}
\setlength{\headheight}{0pt}
\setlength{\headsep}{0pt}
\setlength{\parindent}{0pt}
\setlength{\parskip}{1 ex plus 0.5 ex minus 0.2 ex}
\newcommand{\vect}[1]{\mathbf{#1}}    % Notación vectorial negrita
\newcommand{\for}[1]{\mathsf{#1}}
% ------------------------------
\begin{document}
\begin{center}\textbf{COMPUTACIÓN 2002 -- ASTRONOMÍA}\end{center}
\begin{center}\textbf{PRACTICA 7}\end{center}
\bigskip

El objetivo de esta práctica es construir una pequeña biblioteca de
subrutinas para las principales operaciones con matrices. Esto permite
reutilizar código, sin tener que estar reescribiendo subrutinas cada
vez que las necesitemos.

\begin{enumerate}

\item Para comenzar nos pondremos de acuerdo en como guardar los elementos
de una matriz en forma eficiente. En principio, podemos utilizar un
arreglo bidimensional. Sin embargo, esto no es adecuado por diversas
razones técnicas. En vez de ésto, guardaremos las matrices fila por
fila en un arreglo unidimensional (vector), como sigue.

Sea $\vect{A} = (a_{ij})$ una matriz $(n \times m)$ (esto es, de $n$
filas y $m$ columnas),
\begin{displaymath}
  \begin{pmatrix}
    a_{11} & a_{12} & \dots & a_{1m} \\
    a_{21} & a_{21} & \dots & a_{2m} \\
    \dots  & \dots  & \dots & \dots  \\
    a_{n1} & a_{n2} & \dots & a_{nm} 
  \end{pmatrix}
\end{displaymath}
entonces los elementos de $\vect{A}$ son guardados en el arreglo
unidimensional $\for{A}$ de tamaño $\for{N}*\for{M}$ fila por
fila:
\begin{displaymath}
\begin{split}
  \for{A(1)} &= a_{11} \\
  \for{A(2)}  & = a_{12}\\
  \dots\\
  \for{A(M)}&=a_{1m}\\ 
  \for{A(M+1)} &= a_{21}\\
  \for{A(M+2)}&=a_{22} \\
  \dots \\
  \for{A(2*M)}&=a_{2m} \\ 
  \dots  \\
  \for{A(N*M)} &=a_{nm} 
\end{split}
\end{displaymath}
Así, si los índices de un elemento $a_{ij}$ son representados por las
variables $\for{FORTRAN}$ $\for{I}$ y $\for{J}$, el índice $\for{K}$
del correspondiente elemento del arreglo unidimensional $\for{A}$ está
dado por
\begin{displaymath}
  \for{K=(I-1)*M + J}
\end{displaymath}
!`Verifíquelo!

\item En lo que sigue llamaremos $\for{A}$, $\for{B}$, $\for{C}$ a las
matrices sobre las cuales se realiza una operación y $\for{R}$ a la
matriz resultante de esta operación. Los símbolos $\for{N}$,
$\for{M}$, $\for{L}$ representan los tamaños de estas
matrices. 

Construya entonces las siguientes subrutinas:
\begin{enumerate}
\item La subrutina $\for{MTXTRA}$ transfiere la matriz $\for{A}$
  $(n\times m)$ en el arreglo $\for{R}$, esto es realiza una copia de 
  $\for{A}$ en $\for{R}$.
\item La subrutina $\for{MTXMSC}$ multiplica la matriz $\for{A}$
  $(n\times\ m)$ por un escalar $\for{S}$ y coloca el resultado en
  $\for{R}$.
\item La subrutina $\for{MTXUNT}$ construye la matriz unidad de orden
  $n$ en el arreglo $\for{R}$.
\item La subrutina $\for{MTXTRP}$ coloca la traspuesta de la matriz $\for{A}$
  $(n\times m)$ en $\for{R}$.
\item La subrutina $\for{MTXADD}$ realiza la suma de dos matrices
  $(n\times m)$  $\for{A}$ y $\for{B}$ y pone el resultado en
  $\for{R}$.
\item La subrutina $\for{MTXSUB}$ resta la matriz $(n\times m)$
  $\for{B}$ de la matriz $(n\times m)$  $\for{A}$ colocando el
  resultado en  $\for{R}$.
\item La subrutina $\for{MTXMLT}$ multiplica la matriz
  $(n\times l)$ $\for{A}$ por la matriz $(l\times m)$
  $\for{B}$ y coloca la matriz producto $(n\times m)$ en $\for{R}$.
\item La subrutina $\for{MTXWRT}$ escribe la matriz $(n\times m)$
  guardada en $\for{A}$ fila por fila por pantalla.
\end{enumerate}
Verifique que cada subrutina funcione correctamente.

\item Utilizando las subrutinas anteriores construya un programa tal que
dadas dos matrices $(n\times n)$ $\vect{A}$ y $\vect{B}$ y el escalar
$\lambda$ realice los siguientes cálculos:
\begin{displaymath}
  \vect{AB}, \quad \vect{A}-\lambda\vect{I}, \quad \vect{AB^t}, \quad
  \vect{A^tB}, \quad \vect{AB^t}-\vect{A^tB}
\end{displaymath}

\end{enumerate} 

\textbf{Nota:} Para utilizar las subrutinas no es necesario
  insertar el código dentro del programa (aunque, por supuesto, puede
  hacer esto). Puede compilar por separado las
  subrutinas y luego unir (\emph{link}) las necesarias con el programa
  principal en un único ejecutable como sigue. 

  Supongamos que mi programa \texttt{matriz.f} llama a la subrutina
  $\for{MTXMLT}$, la cual está guardada en el archivo
  \texttt{mtxmlt.f}. Entonces primero compilamos \texttt{mtxmlt.f}
  como sigue
  \begin{quote}
\begin{verbatim}
$ g77 -c mtxmlt.f
\end{verbatim}%$
  \end{quote}
  Esto genera un archivo \texttt{mtxmlt.o} conocido como código
  objeto. A continuación unimos el código objeto de nuestra subrutina
  con el programa principal y generamos el ejecutable,
  \begin{quote}
\begin{verbatim}
$ g77 -o matriz matriz.f  mtxmlt.o
\end{verbatim}%$
  \end{quote}
\end{document}



