INTRODUCCION AL USO

DEL PROGRAMA GAUSS 5.0

(EL GRIMORIO1)

Raimundo Soto
Saturday 19 July 2008

1 Un grimorio es un libro de conocimiento mágico escrito entre la Alta Edad Media y el siglo XVIII. Tales libros
contienen correspondencias astrológicas, listas de ángeles y demonios, instrucciones para lanzar encantamientos y
hechizos, mezclar medicamentos, convocar entidades sobrenaturales y fabricar talismanes.
1. Introducción

Gauss es un programa matemático que opera sobre la base de matrices y se usa para hacer
econometría.

Tiene dos características fundamentales: (1) no es amistoso y (2) es tremendamente

poderoso.

La primera característica significa que el econometrista debe programar toda acción que el
programa deba hacer. El número de “comandos” es muy limitado, circunscribiéndose a aquellas
operaciones que se puede hacer con matrices.

El programa es 100% estúpido, lo que significa que cada vez que se comete un error, es
culpa del econometrista y no de Gauss. Existe un número enorme de aplicaciones de Gauss
(subrutinas existentes) que son de fácil acceso, abiertas y que nosotros no vamos a usar (p.e.,
mínimos cuadrados). Abiertas significa que se puede ver el código base. NO las vamos a usar para
aprender econometría en serio.

La segunda característica es excepcional. Gauss es extremadamente eficiente, muy rápido y

tremendamente flexible (en la familia de los programas sobre base Fortran).

El programa tiene dos ambientes:

● Editor
● Ambiente de comandos

En el editor crearemos una secuencia de instrucciones que llamamos “programa”.

En el ambiente de comandos realizaremos acciones tales como ejecutar un programa,

compilar un programa, etc.

● Inicie Gauss
● Abra un archivo en blanco (File → New)
● Divida la pantalla usando Window → Tile Horizontal

1/15
Las instrucciones de Gauss se terminan todas con el caracter ;
Si no ponen ;, Gauss seguirá leyendo la línea siguiente (y se va a caer).

El signo = significa “asignación” y no equivalencia. Por ello, la siguiente instrucción es

perfectamente lógica:

A = A + 2;

La instrucción se lee como: Asignar a la matriz A lo que hay en la matriz A más 2.

● Ahora vamos a trabajar en el editor

2/15
/* MANEJO DE MATRICES

Creación de matrices */

y = 3; /* Crea un escalar */
x = {1 2 3 4 5 6 7 8 9}; /* Crea una matriz de 1x9 */
z = {1,2,3,4,5,6,7,8,9}; /* Crea una matriz de 9x1 */
w = {1 2 3, 4 5 6, 7 8 9}; /* Crea una matriz de 3x3 */

Para ejecutar el programa, grabe el archivo del editor con algún nombre y luego presione F6.

Como se ve, no pasa nada cuando se ejecuta (si no pasa nada es un buen síntoma)

3/15
En el ambiente de comandos escriba show para obtener:

Esto quiere decir que Gauss creó –y tiene en la memoria– cuatro matrices con las
dimensiones que se ven en la última columna.

4/15
/* se puede operar con estas matrices directamente */

xz = x*z; /* Crea una matriz de 1x1 */

zx = z*x; /* Crea una matriz de 9x9 */
xx = x+x; /* Crea una matriz de 1x9 */
trasx = x'; /* Traspone la matriz x */

/* Para referirse a los elementos de una matriz se usa [ , ] */

a=x[1,5]; /* Selecciona el elemento 1,5 de x */

/* GAUSS permite expresiones como argumentos */

b = w[y-1,y^0];

/* Podemos usar un pedazo de la matriz (submatriz), con [:,:] */

c = w[1:2,2:3];
d = w[a^0:y-1,2*b^0:y]; /* produce lo mismo */

/* Podemos pegar (concatenar) matrices conformables */

e = c~d; /* concatenado horizontal */

f = c|d; /* concatenado vertical */

/* Las precedencias son las estandares de matemáticas (casa, punto, raya).

La concatenación es la última precedencia. Por ejemplo, */

g = 1+1~2*2|3-2~6/2; /* produce una matriz de 2x2 */

5/15
/* Las matrices pueden contener alfanuméricos (strings) */

h = "Colo ";

/* Y se puede operar con ellas (usando $+) */

j = "Viva ";
i =j$+h$+h;
print i;

● Es buena idea incluir una instrucción para que borre los resultados de la pantalla después de
cada ejecución: escriba cls; (clear screen) en la primera línea del editor y corra el programa.

6/15
7/15
/* FUNCIONES, CICLOS, Y CONDICIONALES

FUNCIONES Hay dos tipos de funciones: intrínsecas y particulares

Funciones intrínsecas tipicas (hay cientos) */

y = sqrt(2); /* funcion raiz cuadrada */

z = exp(3); /* funcion exponencial */

/* Tambien se pueden definir funciones particulares */

fn area(r) = pi * r * r;
z = area(4);

/* Las funciones aceptan expresiones como argumentos */

x = area(2*pi);

/* Las funciones aceptan otras funciones como argumentos */

w = sqrt(area(3*cos(30)));

8/15
/* CICLOS (bucles) Los ciclos permiten hacer operaciones repetidas */

i = 1; /* Casi siempre usamos un contador */

do while i<10;
"Viva Colo Colo " i;
i = i+1;
endo;

/* Esta es una herramienta sumamente poderosa y la van a usar bastante */

9/15
/* CONDICIONALES Los condicionales son tambien muy utiles */

i = 1;
if i==1;
"Colo Colo Campeon";
else;
"Muera la U";
endif;

10/15
/*

PROCEDIMIENTOS Esta son subrutinas que realizan un programa auxiliar y que

puede ser "llamado" desde el programa principal a voluntad

Estructura: (1) Declaracion del procedure

(2) Argumentos
(3) Variables locales
(4) Rutina
(5) Retorno del procedure
(6) Fin del procedure

Se ve confuso pero es trivial */

proc(3) = mico(x,y); /* Nombre del procedimiento "mico" y sus argumentos son dos
matrices "x" e "y". Entre parentesis el número de retornos.
*/

local xxi,b,ymxb,sse,sd,t; /* Variables locales */

xxi = inv(x'x); /* calcula inversa matriz de momentos */

b = xxi*(x'y); /* calcula los parametros */
ymxb = y-x*b; /* calcula errores */
sse = ymxb'ymxb/(rows(x)-cols(x)); /* calcula estimador std dev errores */
sd = sqrt(diag(sse*xxi)); /* calcula estimador std dev params */
t = b./sd; /* calcula tests t */

retp(b,sd,t); /* Retornos del procedure */

endp; /* Fin del procedure */

11/15
/* Suponga ahora que en el programa principal se llama este procedure (como
necesitamos datos, los vamos a "inventar" usando una distribucion normal) */

x = rndn(150,6);
y = rndn(150,1);
{b,sd,t} = mico(x,y);

/* Desplegamos los resultados */

" betas desv.est test t";
b~sd~t;

12/15
13/15
/* Este programa convierte datos leidos de un archivo ASCII en formato Gauss (.dat)

- "OBS" = tamaño de muestra.

- "REG" = número de series en el archivo de datos.
- "DATA.TXT" = archivo que contiene los datos en ASCII.
- "DATA" = nuevo archivo en formato GAUSS.
- "VAR1", "VAR2", ... , "VAR8" = nombre de las variables */

obs = 33;
reg = 8;

load x[obs,reg] = DATA0.TXT;

let vnames = VAR1 VAR2 VAR3 VAR4 VAR5 VAR6 VAR7 VAR8 ;
create f1 = dataconvert with ^vnames, reg, 8; /* 8 es doble precision */
dataconvert = writer(f1,x);

/*
Esto va a crear un archivo dataconvert.dat que es un archivo de datos GAUSS
Note que es de un tamaño menor que el archivo de texto, lo que es util
*/

/* Esta instrucción lee datos de un archivo Excel */

/* Si se leen sólo valores */

mat = xlsReadM("DATA.XLS", "A10:H65", 5,"");

/* Si se leen etiquetas */
mat = xlsReadSa("DATA.XLS", "A10:H65", 5,"");

/* donde Data.xls es el nombre del archivo, A10:H65 es el rango a leer, 5 es la hoja dentro
del archivo, y "" es un vector nulo que */

14/15